← Back to branch summary

~ubuntu-branches/ubuntu/precise/nss/precise-security

« back to all changes in this revision

Viewing changes to mozilla/security/coreconf/mkdepend/include.c

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2013-11-14 14:58:07 UTC
  • mfrom: (1.1.19)
  • Revision ID: package-import@ubuntu.com-20131114145807-ay302kimn72ovt88
Tags: 3.15.3-0ubuntu0.12.04.1
* SECURITY UPDATE: New upstream release to fix multiple security issues
  and add TLSv1.2 support.
  - CVE-2013-1739
  - CVE-2013-1741
  - CVE-2013-5605
  - CVE-2013-5606
* Adjusted packaging for 3.15.3:
  - debian/patches/*: refreshed.
  - debian/patches/lower-dhe-priority.patch: removed, no longer needed,
    was a workaround for an old version of firefox.
  - debian/libnss3.symbols: added new symbols.
  - debian/rules: updated for new source layout.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/security/coreconf/mkdepend/include.c
1
 
/* $Xorg: include.c,v 1.4 2001/02/09 02:03:16 xorgcvs Exp $ */
2
 
/*
3
 
 
4
 
Copyright (c) 1993, 1994, 1998 The Open Group
5
 
 
6
 
Permission to use, copy, modify, distribute, and sell this software and its
7
 
documentation for any purpose is hereby granted without fee, provided that
8
 
the above copyright notice appear in all copies and that both that
9
 
copyright notice and this permission notice appear in supporting
10
 
documentation.
11
 
 
12
 
The above copyright notice and this permission notice shall be included in
13
 
all copies or substantial portions of the Software.
14
 
 
15
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
 
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
 
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
18
 
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
19
 
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20
 
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21
 
 
22
 
Except as contained in this notice, the name of The Open Group shall not be
23
 
used in advertising or otherwise to promote the sale, use or other dealings
24
 
in this Software without prior written authorization from The Open Group.
25
 
 
26
 
*/
27
 
/* $XFree86: xc/config/makedepend/include.c,v 3.7 2001/12/14 19:53:20 dawes Exp $ */
28
 
 
29
 
 
30
 
#include "def.h"
31
 
 
32
 
#ifdef _MSC_VER
33
 
#include <windows.h>
34
 
static int
35
 
does_file_exist(char *file)
36
 
{
37
 
  WIN32_FILE_ATTRIBUTE_DATA data;
38
 
  BOOL b = GetFileAttributesExA(file, GetFileExInfoStandard, &data);
39
 
  if (!b)
40
 
    return 0;
41
 
  return (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
42
 
}
43
 
#else
44
 
static int
45
 
does_file_exist(char *file)
46
 
{
47
 
  struct stat sb;
48
 
  return stat(file, &sb) == 0 && !S_ISDIR(sb.st_mode);
49
 
}
50
 
#endif
51
 
 
52
 
extern struct   inclist inclist[ MAXFILES ],
53
 
                        *inclistp, *inclistnext;
54
 
extern char     *includedirs[ ],
55
 
                **includedirsnext;
56
 
extern char     *notdotdot[ ];
57
 
extern boolean show_where_not;
58
 
extern boolean warn_multiple;
59
 
 
60
 
static boolean
61
 
isdot(char *p)
62
 
{
63
 
        if(p && *p++ == '.' && *p++ == '\0')
64
 
                return(TRUE);
65
 
        return(FALSE);
66
 
}
67
 
 
68
 
static boolean
69
 
isdotdot(char *p)
70
 
{
71
 
        if(p && *p++ == '.' && *p++ == '.' && *p++ == '\0')
72
 
                return(TRUE);
73
 
        return(FALSE);
74
 
}
75
 
 
76
 
static boolean
77
 
issymbolic(char *dir, char *component)
78
 
{
79
 
#ifdef S_IFLNK
80
 
        struct stat     st;
81
 
        char    buf[ BUFSIZ ], **pp;
82
 
 
83
 
        sprintf(buf, "%s%s%s", dir, *dir ? "/" : "", component);
84
 
        for (pp=notdotdot; *pp; pp++)
85
 
                if (strcmp(*pp, buf) == 0)
86
 
                        return (TRUE);
87
 
        if (lstat(buf, &st) == 0
88
 
        && (st.st_mode & S_IFMT) == S_IFLNK) {
89
 
                *pp++ = copy(buf);
90
 
                if (pp >= &notdotdot[ MAXDIRS ])
91
 
                        fatalerr("out of .. dirs, increase MAXDIRS\n");
92
 
                return(TRUE);
93
 
        }
94
 
#endif
95
 
        return(FALSE);
96
 
}
97
 
 
98
 
/*
99
 
 * Occasionally, pathnames are created that look like .../x/../y
100
 
 * Any of the 'x/..' sequences within the name can be eliminated.
101
 
 * (but only if 'x' is not a symbolic link!!)
102
 
 */
103
 
static void
104
 
remove_dotdot(char *path)
105
 
{
106
 
        register char   *end, *from, *to, **cp;
107
 
        char            *components[ MAXFILES ],
108
 
                        newpath[ BUFSIZ ];
109
 
        boolean         component_copied;
110
 
 
111
 
        /*
112
 
         * slice path up into components.
113
 
         */
114
 
        to = newpath;
115
 
        if (*path == '/')
116
 
                *to++ = '/';
117
 
        *to = '\0';
118
 
        cp = components;
119
 
        for (from=end=path; *end; end++)
120
 
                if (*end == '/') {
121
 
                        while (*end == '/')
122
 
                                *end++ = '\0';
123
 
                        if (*from)
124
 
                                *cp++ = from;
125
 
                        from = end;
126
 
                }
127
 
        *cp++ = from;
128
 
        *cp = NULL;
129
 
 
130
 
        /*
131
 
         * Recursively remove all 'x/..' component pairs.
132
 
         */
133
 
        cp = components;
134
 
        while(*cp) {
135
 
                if (!isdot(*cp) && !isdotdot(*cp) && isdotdot(*(cp+1))
136
 
                    && !issymbolic(newpath, *cp))
137
 
                {
138
 
                    char **fp = cp + 2;
139
 
                    char **tp = cp;
140
 
 
141
 
                    do 
142
 
                        *tp++ = *fp; /* move all the pointers down */
143
 
                    while (*fp++);
144
 
                    if (cp != components)
145
 
                        cp--;   /* go back and check for nested ".." */
146
 
                } else {
147
 
                    cp++;
148
 
                }
149
 
        }
150
 
        /*
151
 
         * Concatenate the remaining path elements.
152
 
         */
153
 
        cp = components;
154
 
        component_copied = FALSE;
155
 
        while(*cp) {
156
 
                if (component_copied)
157
 
                        *to++ = '/';
158
 
                component_copied = TRUE;
159
 
                for (from = *cp; *from; )
160
 
                        *to++ = *from++;
161
 
                *to = '\0';
162
 
                cp++;
163
 
        }
164
 
        *to++ = '\0';
165
 
 
166
 
        /*
167
 
         * copy the reconstituted path back to our pointer.
168
 
         */
169
 
        strcpy(path, newpath);
170
 
}
171
 
 
172
 
/*
173
 
 * Add an include file to the list of those included by 'file'.
174
 
 */
175
 
struct inclist *
176
 
newinclude(char *newfile, char *incstring)
177
 
{
178
 
        register struct inclist *ip;
179
 
 
180
 
        /*
181
 
         * First, put this file on the global list of include files.
182
 
         */
183
 
        ip = inclistp++;
184
 
        if (inclistp == inclist + MAXFILES - 1)
185
 
                fatalerr("out of space: increase MAXFILES\n");
186
 
        ip->i_file = copy(newfile);
187
 
 
188
 
        if (incstring == NULL)
189
 
                ip->i_incstring = ip->i_file;
190
 
        else
191
 
                ip->i_incstring = copy(incstring);
192
 
 
193
 
        inclistnext = inclistp;
194
 
        return(ip);
195
 
}
196
 
 
197
 
void
198
 
included_by(struct inclist *ip, struct inclist *newfile)
199
 
{
200
 
        register int i;
201
 
 
202
 
        if (ip == NULL)
203
 
                return;
204
 
        /*
205
 
         * Put this include file (newfile) on the list of files included
206
 
         * by 'file'.  If 'file' is NULL, then it is not an include
207
 
         * file itself (i.e. was probably mentioned on the command line).
208
 
         * If it is already on the list, don't stick it on again.
209
 
         */
210
 
        if (ip->i_list == NULL) {
211
 
                ip->i_list = (struct inclist **)
212
 
                        malloc(sizeof(struct inclist *) * ++ip->i_listlen);
213
 
                ip->i_merged = (boolean *)
214
 
                    malloc(sizeof(boolean) * ip->i_listlen);
215
 
        } else {
216
 
                for (i=0; i<ip->i_listlen; i++)
217
 
                        if (ip->i_list[ i ] == newfile) {
218
 
                            i = strlen(newfile->i_file);
219
 
                            if (!(ip->i_flags & INCLUDED_SYM) &&
220
 
                                !(i > 2 &&
221
 
                                  newfile->i_file[i-1] == 'c' &&
222
 
                                  newfile->i_file[i-2] == '.'))
223
 
                            {
224
 
                                /* only bitch if ip has */
225
 
                                /* no #include SYMBOL lines  */
226
 
                                /* and is not a .c file */
227
 
                                if (warn_multiple)
228
 
                                {
229
 
                                        warning("%s includes %s more than once!\n",
230
 
                                                ip->i_file, newfile->i_file);
231
 
                                        warning1("Already have\n");
232
 
                                        for (i=0; i<ip->i_listlen; i++)
233
 
                                                warning1("\t%s\n", ip->i_list[i]->i_file);
234
 
                                }
235
 
                            }
236
 
                            return;
237
 
                        }
238
 
                ip->i_list = (struct inclist **) realloc(ip->i_list,
239
 
                        sizeof(struct inclist *) * ++ip->i_listlen);
240
 
                ip->i_merged = (boolean *)
241
 
                    realloc(ip->i_merged, sizeof(boolean) * ip->i_listlen);
242
 
        }
243
 
        ip->i_list[ ip->i_listlen-1 ] = newfile;
244
 
        ip->i_merged[ ip->i_listlen-1 ] = FALSE;
245
 
}
246
 
 
247
 
void
248
 
inc_clean (void)
249
 
{
250
 
        register struct inclist *ip;
251
 
 
252
 
        for (ip = inclist; ip < inclistp; ip++) {
253
 
                ip->i_flags &= ~MARKED;
254
 
        }
255
 
}
256
 
 
257
 
struct inclist *
258
 
inc_path(char *file, char *include, int type)
259
 
{
260
 
        static char             path[ BUFSIZ ];
261
 
        register char           **pp, *p;
262
 
        register struct inclist *ip;
263
 
 
264
 
        /*
265
 
         * Check all previously found include files for a path that
266
 
         * has already been expanded.
267
 
         */
268
 
        if ((type == INCLUDE) || (type == INCLUDEDOT))
269
 
                inclistnext = inclist;
270
 
        ip = inclistnext;
271
 
 
272
 
        for (; ip->i_file; ip++) {
273
 
                if ((strcmp(ip->i_incstring, include) == 0) &&
274
 
                    !(ip->i_flags & INCLUDED_SYM)) {
275
 
                        inclistnext = ip + 1;
276
 
                        return ip;
277
 
                }
278
 
        }
279
 
 
280
 
        if (inclistnext == inclist) {
281
 
                /*
282
 
                 * If the path was surrounded by "" or is an absolute path,
283
 
                 * then check the exact path provided.
284
 
                 */
285
 
                if ((type == INCLUDEDOT) ||
286
 
                    (type == INCLUDENEXTDOT) ||
287
 
                    (*include == '/')) {
288
 
                        if (does_file_exist(include))
289
 
                                return newinclude(include, include);
290
 
                        if (show_where_not)
291
 
                                warning1("\tnot in %s\n", include);
292
 
                }
293
 
 
294
 
                /*
295
 
                 * If the path was surrounded by "" see if this include file is
296
 
                 * in the directory of the file being parsed.
297
 
                 */
298
 
                if ((type == INCLUDEDOT) || (type == INCLUDENEXTDOT)) {
299
 
                        for (p=file+strlen(file); p>file; p--)
300
 
                                if (*p == '/')
301
 
                                        break;
302
 
                        if (p == file) {
303
 
                                strcpy(path, include);
304
 
                        } else {
305
 
                                strncpy(path, file, (p-file) + 1);
306
 
                                path[ (p-file) + 1 ] = '\0';
307
 
                                strcpy(path + (p-file) + 1, include);
308
 
                        }
309
 
                        remove_dotdot(path);
310
 
                        if (does_file_exist(path))
311
 
                                return newinclude(path, include);
312
 
                        if (show_where_not)
313
 
                                warning1("\tnot in %s\n", path);
314
 
                }
315
 
        }
316
 
 
317
 
        /*
318
 
         * Check the include directories specified.  Standard include dirs
319
 
         * should be at the end.
320
 
         */
321
 
        if ((type == INCLUDE) || (type == INCLUDEDOT))
322
 
                includedirsnext = includedirs;
323
 
        pp = includedirsnext;
324
 
 
325
 
        for (; *pp; pp++) {
326
 
                sprintf(path, "%s/%s", *pp, include);
327
 
                remove_dotdot(path);
328
 
                if (does_file_exist(path)) {
329
 
                        includedirsnext = pp + 1;
330
 
                        return newinclude(path, include);
331
 
                }
332
 
                if (show_where_not)
333
 
                        warning1("\tnot in %s\n", path);
334
 
        }
335
 
 
336
 
        return NULL;
337
 
}