/[jscoverage]/trunk/js/config/nsinstall.c
ViewVC logotype

Annotation of /trunk/js/config/nsinstall.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 399 - (hide annotations)
Tue Dec 9 03:37:47 2008 UTC (11 years, 6 months ago) by siliconforks
File MIME type: text/plain
File size: 12257 byte(s)
Use SpiderMonkey from Firefox 3.1b2.

1 siliconforks 399 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2     /* ***** BEGIN LICENSE BLOCK *****
3     * Version: MPL 1.1/GPL 2.0/LGPL 2.1
4     *
5     * The contents of this file are subject to the Mozilla Public License Version
6     * 1.1 (the "License"); you may not use this file except in compliance with
7     * the License. You may obtain a copy of the License at
8     * http://www.mozilla.org/MPL/
9     *
10     * Software distributed under the License is distributed on an "AS IS" basis,
11     * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12     * for the specific language governing rights and limitations under the
13     * License.
14     *
15     * The Original Code is mozilla.org code.
16     *
17     * The Initial Developer of the Original Code is
18     * Netscape Communications Corporation.
19     * Portions created by the Initial Developer are Copyright (C) 1998
20     * the Initial Developer. All Rights Reserved.
21     *
22     * Contributor(s):
23     *
24     * Alternatively, the contents of this file may be used under the terms of
25     * either of the GNU General Public License Version 2 or later (the "GPL"),
26     * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
27     * in which case the provisions of the GPL or the LGPL are applicable instead
28     * of those above. If you wish to allow use of your version of this file only
29     * under the terms of either the GPL or the LGPL, and not to allow others to
30     * use your version of this file under the terms of the MPL, indicate your
31     * decision by deleting the provisions above and replace them with the notice
32     * and other provisions required by the GPL or the LGPL. If you do not delete
33     * the provisions above, a recipient may use your version of this file under
34     * the terms of any one of the MPL, the GPL or the LGPL.
35     *
36     * ***** END LICENSE BLOCK ***** */
37     /*
38     ** Netscape portable install command.
39     **
40     ** Brendan Eich, 7/20/95
41     */
42     #include <stdio.h> /* OSF/1 requires this before grp.h, so put it first */
43     #include <assert.h>
44     #include <fcntl.h>
45     #include <errno.h>
46     #include <dirent.h>
47     #include <limits.h>
48     #include <grp.h>
49     #include <pwd.h>
50     #include <stdio.h>
51     #include <stdlib.h>
52     #include <string.h>
53     #include <unistd.h>
54     #include <utime.h>
55     #include <sys/types.h>
56     #include <sys/stat.h>
57     #include "pathsub.h"
58    
59     #ifdef HAVE_GETOPT_H
60     #include <getopt.h>
61     #endif
62    
63     #ifdef SUNOS4
64     #include "sunos4.h"
65     #endif
66    
67     #ifdef NEXTSTEP
68     #include <bsd/libc.h>
69     #endif
70    
71     #ifdef __QNX__
72     #include <unix.h>
73     #endif
74    
75     #ifdef NEED_S_ISLNK
76     #if !defined(S_ISLNK) && defined(S_IFLNK)
77     #define S_ISLNK(a) (((a) & S_IFMT) == S_IFLNK)
78     #endif
79     #endif
80    
81     #ifndef _DIRECTORY_SEPARATOR
82     #define _DIRECTORY_SEPARATOR "/"
83     #endif /* _DIRECTORY_SEPARATOR */
84    
85     #ifdef NEED_FCHMOD_PROTO
86     extern int fchmod(int fildes, mode_t mode);
87     #endif
88    
89     static void
90     usage(void)
91     {
92     fprintf(stderr,
93     "usage: %s [-C cwd] [-L linkprefix] [-m mode] [-o owner] [-g group]\n"
94     " %*s [-DdltR] file [file ...] directory\n",
95     program, (int) strlen(program), "");
96     exit(2);
97     }
98    
99     static int
100     mkdirs(char *path, mode_t mode)
101     {
102     char *cp;
103     struct stat sb;
104     int res;
105     int l;
106    
107     /* strip trailing "/." */
108     l = strlen(path);
109     if(l > 1 && path[l - 1] == '.' && path[l - 2] == '/')
110     path[l - 2] = 0;
111    
112     while (*path == '/' && path[1] == '/')
113     path++;
114     for (cp = strrchr(path, '/'); cp && cp != path && *(cp - 1) == '/'; cp--);
115     if (cp && cp != path) {
116     *cp = '\0';
117     if ((lstat(path, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
118     mkdirs(path, mode) < 0) {
119     return -1;
120     }
121     *cp = '/';
122     }
123    
124     res = mkdir(path, mode);
125     if ((res != 0) && (errno == EEXIST))
126     return 0;
127     else
128     return res;
129     }
130    
131     static uid_t
132     touid(char *owner)
133     {
134     struct passwd *pw;
135     uid_t uid;
136     char *cp;
137    
138     pw = getpwnam(owner);
139     if (pw)
140     return pw->pw_uid;
141     uid = strtol(owner, &cp, 0);
142     if (uid == 0 && cp == owner)
143     fail("cannot find uid for %s", owner);
144     return uid;
145     }
146    
147     static gid_t
148     togid(char *group)
149     {
150     struct group *gr;
151     gid_t gid;
152     char *cp;
153    
154     gr = getgrnam(group);
155     if (gr)
156     return gr->gr_gid;
157     gid = strtol(group, &cp, 0);
158     if (gid == 0 && cp == group)
159     fail("cannot find gid for %s", group);
160     return gid;
161     }
162    
163     static void
164     copyfile( char *name, char *toname, mode_t mode, char *group, char *owner,
165     int dotimes, uid_t uid, gid_t gid )
166     {
167     int fromfd, tofd = -1, cc, wc, exists;
168     char buf[BUFSIZ], *bp;
169     struct stat sb, tosb;
170     struct utimbuf utb;
171    
172     exists = (lstat(toname, &tosb) == 0);
173    
174     fromfd = open(name, O_RDONLY);
175     if (fromfd < 0 || fstat(fromfd, &sb) < 0)
176     fail("cannot access %s", name);
177     if (exists) {
178     if (S_ISREG(tosb.st_mode)) {
179     /* See if we can open it. This is more reliable than 'access'. */
180     tofd = open(toname, O_CREAT | O_WRONLY, 0666);
181     }
182     if (tofd < 0) {
183     (void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
184     }
185     }
186     if (tofd < 0) {
187     tofd = open(toname, O_CREAT | O_WRONLY, 0666);
188     if (tofd < 0)
189     fail("cannot create %s", toname);
190     }
191    
192     bp = buf;
193     while ((cc = read(fromfd, bp, sizeof buf)) > 0)
194     {
195     while ((wc = write(tofd, bp, (unsigned int)cc)) > 0)
196     {
197     if ((cc -= wc) == 0)
198     break;
199     bp += wc;
200     }
201     if (wc < 0)
202     fail("cannot write to %s", toname);
203     }
204     if (cc < 0)
205     fail("cannot read from %s", name);
206    
207     if (ftruncate(tofd, sb.st_size) < 0)
208     fail("cannot truncate %s", toname);
209     #if !defined(VMS)
210     if (dotimes)
211     {
212     utb.actime = sb.st_atime;
213     utb.modtime = sb.st_mtime;
214     if (utime(toname, &utb) < 0)
215     fail("cannot set times of %s", toname);
216     }
217     #ifdef HAVE_FCHMOD
218     if (fchmod(tofd, mode) < 0)
219     #else
220     if (chmod(toname, mode) < 0)
221     #endif
222     fail("cannot change mode of %s", toname);
223     #endif
224     if ((owner || group) && fchown(tofd, uid, gid) < 0)
225     fail("cannot change owner of %s", toname);
226    
227     /* Must check for delayed (NFS) write errors on close. */
228     if (close(tofd) < 0)
229     fail("cannot write to %s", toname);
230     close(fromfd);
231     #if defined(VMS)
232     if (chmod(toname, (mode & (S_IREAD | S_IWRITE))) < 0)
233     fail("cannot change mode of %s", toname);
234     if (dotimes)
235     {
236     utb.actime = sb.st_atime;
237     utb.modtime = sb.st_mtime;
238     if (utime(toname, &utb) < 0)
239     fail("cannot set times of %s", toname);
240     }
241     #endif
242     }
243    
244     static void
245     copydir( char *from, char *to, mode_t mode, char *group, char *owner,
246     int dotimes, uid_t uid, gid_t gid)
247     {
248     int i;
249     DIR *dir;
250     struct dirent *ep;
251     struct stat sb;
252     char *base, *destdir, *direntry, *destentry;
253    
254     base = xbasename(from);
255    
256     /* create destination directory */
257     destdir = xmalloc((unsigned int)(strlen(to) + 1 + strlen(base) + 1));
258     sprintf(destdir, "%s%s%s", to, _DIRECTORY_SEPARATOR, base);
259     if (mkdirs(destdir, mode) != 0) {
260     fail("cannot make directory %s\n", destdir);
261     return;
262     }
263    
264     dir = opendir(from);
265    
266     direntry = xmalloc((unsigned int)PATH_MAX);
267     destentry = xmalloc((unsigned int)PATH_MAX);
268    
269     while ((ep = readdir(dir)))
270     {
271     if (strcmp(ep->d_name, ".") == 0 || strcmp(ep->d_name, "..") == 0)
272     continue;
273    
274     sprintf(direntry, "%s/%s", from, ep->d_name);
275     sprintf(destentry, "%s%s%s", destdir, _DIRECTORY_SEPARATOR, ep->d_name);
276    
277     if (stat(direntry, &sb) == 0 && S_ISDIR(sb.st_mode))
278     copydir( direntry, destdir, mode, group, owner, dotimes, uid, gid );
279     else
280     copyfile( direntry, destentry, mode, group, owner, dotimes, uid, gid );
281     }
282    
283     free(direntry);
284     free(destentry);
285     closedir(dir);
286     }
287    
288     int
289     main(int argc, char **argv)
290     {
291     int onlydir, dodir, dolink, dorelsymlink, dotimes, opt, len, lplen, tdlen, bnlen, exists, fromfd, tofd, cc, wc;
292     mode_t mode = 0755;
293     char *linkprefix, *owner, *group, *cp, *cwd, *todir, *toname, *name, *base, *linkname, *bp, buf[BUFSIZ];
294     uid_t uid;
295     gid_t gid;
296     struct stat sb, tosb, fromsb;
297     struct utimbuf utb;
298    
299     program = argv[0];
300     cwd = linkname = linkprefix = owner = group = 0;
301     onlydir = dodir = dolink = dorelsymlink = dotimes = lplen = 0;
302    
303     while ((opt = getopt(argc, argv, "C:DdlL:Rm:o:g:t")) != EOF) {
304     switch (opt) {
305     case 'C':
306     cwd = optarg;
307     break;
308     case 'D':
309     onlydir = 1;
310     break;
311     case 'd':
312     dodir = 1;
313     break;
314     case 'l':
315     dolink = 1;
316     break;
317     case 'L':
318     linkprefix = optarg;
319     lplen = strlen(linkprefix);
320     dolink = 1;
321     break;
322     case 'R':
323     dolink = dorelsymlink = 1;
324     break;
325     case 'm':
326     mode = strtoul(optarg, &cp, 8);
327     if (mode == 0 && cp == optarg)
328     usage();
329     break;
330     case 'o':
331     owner = optarg;
332     break;
333     case 'g':
334     group = optarg;
335     break;
336     case 't':
337     dotimes = 1;
338     break;
339     default:
340     usage();
341     }
342     }
343    
344     argc -= optind;
345     argv += optind;
346     if (argc < 2 - onlydir)
347     usage();
348    
349     todir = argv[argc-1];
350     if ((stat(todir, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
351     mkdirs(todir, 0777) < 0) {
352     fail("cannot make directory %s", todir);
353     }
354     if (onlydir)
355     return 0;
356    
357     if (!cwd) {
358     #ifndef NEEDS_GETCWD
359     #ifndef GETCWD_CANT_MALLOC
360     cwd = getcwd(0, PATH_MAX);
361     #else
362     cwd = malloc(PATH_MAX + 1);
363     cwd = getcwd(cwd, PATH_MAX);
364     #endif
365     #else
366     cwd = malloc(PATH_MAX + 1);
367     cwd = getwd(cwd);
368     #endif
369     }
370    
371     xchdir(todir);
372     #ifndef NEEDS_GETCWD
373     #ifndef GETCWD_CANT_MALLOC
374     todir = getcwd(0, PATH_MAX);
375     #else
376     todir = malloc(PATH_MAX + 1);
377     todir = getcwd(todir, PATH_MAX);
378     #endif
379     #else
380     todir = malloc(PATH_MAX + 1);
381     todir = getwd(todir);
382     #endif
383     tdlen = strlen(todir);
384     xchdir(cwd);
385     tdlen = strlen(todir);
386    
387     uid = owner ? touid(owner) : (uid_t)(-1);
388     gid = group ? togid(group) : (gid_t)(-1);
389    
390     while (--argc > 0) {
391     name = *argv++;
392     len = strlen(name);
393     base = xbasename(name);
394     bnlen = strlen(base);
395     toname = xmalloc((unsigned int)(tdlen + 1 + bnlen + 1));
396     sprintf(toname, "%s%s%s", todir, _DIRECTORY_SEPARATOR, base);
397     exists = (lstat(toname, &tosb) == 0);
398    
399     if (dodir) {
400     /* -d means create a directory, always */
401     if (exists && !S_ISDIR(tosb.st_mode)) {
402     (void) unlink(toname);
403     exists = 0;
404     }
405     if (!exists && mkdir(toname, mode) < 0)
406     fail("cannot make directory %s", toname);
407     if ((owner || group) && chown(toname, uid, gid) < 0)
408     fail("cannot change owner of %s", toname);
409     } else if (dolink) {
410     if (access(name, R_OK) != 0) {
411     fail("cannot access %s", name);
412     }
413     if (*name == '/') {
414     /* source is absolute pathname, link to it directly */
415     linkname = 0;
416     } else {
417     if (linkprefix) {
418     /* -L implies -l and prefixes names with a $cwd arg. */
419     len += lplen + 1;
420     linkname = xmalloc((unsigned int)(len + 1));
421     sprintf(linkname, "%s/%s", linkprefix, name);
422     } else if (dorelsymlink) {
423     /* Symlink the relative path from todir to source name. */
424     linkname = xmalloc(PATH_MAX);
425    
426     if (*todir == '/') {
427     /* todir is absolute: skip over common prefix. */
428     lplen = relatepaths(todir, cwd, linkname);
429     strcpy(linkname + lplen, name);
430     } else {
431     /* todir is named by a relative path: reverse it. */
432     reversepath(todir, name, len, linkname);
433     xchdir(cwd);
434     }
435    
436     len = strlen(linkname);
437     }
438     name = linkname;
439     }
440    
441     /* Check for a pre-existing symlink with identical content. */
442     if ((exists && (!S_ISLNK(tosb.st_mode) ||
443     readlink(toname, buf, sizeof buf) != len ||
444     strncmp(buf, name, (unsigned int)len) != 0)) ||
445     ((stat(name, &fromsb) == 0) &&
446     (fromsb.st_mtime > tosb.st_mtime))) {
447     (void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
448     exists = 0;
449     }
450     if (!exists && symlink(name, toname) < 0)
451     fail("cannot make symbolic link %s", toname);
452     #ifdef HAVE_LCHOWN
453     if ((owner || group) && lchown(toname, uid, gid) < 0)
454     fail("cannot change owner of %s", toname);
455     #endif
456    
457     if (linkname) {
458     free(linkname);
459     linkname = 0;
460     }
461     } else {
462     /* Copy from name to toname, which might be the same file. */
463     if( stat(name, &sb) == 0 && S_IFDIR & sb.st_mode )
464     {
465     /* then is directory: must explicitly create destination dir */
466     /* and manually copy files over */
467     copydir( name, todir, mode, group, owner, dotimes, uid, gid );
468     }
469     else
470     {
471     copyfile(name, toname, mode, group, owner, dotimes, uid, gid);
472     }
473     }
474    
475     free(toname);
476     }
477    
478     free(cwd);
479     free(todir);
480     return 0;
481     }

  ViewVC Help
Powered by ViewVC 1.1.24