← Back to branch summary

~ubuntu-branches/ubuntu/lucid/nss/lucid-security

« back to all changes in this revision

Viewing changes to nss/coreconf/mkdepend/include.c

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2013-11-15 08:08:08 UTC
  • mfrom: (1.2.7)
  • Revision ID: package-import@ubuntu.com-20131115080808-dba1asgnjl9tc66s
Tags: 3.15.3-0ubuntu0.10.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/01_dont_build_nspr.patch: removed, changed build
    options in debian/rules instead.
  - debian/libnss3-1d.symbols: added new symbols.
  - debian/rules: updated for new source layout.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nss/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
}