From 456ca25e79337b24d5e5c87e4f414fb1a1e2fb5c Mon Sep 17 00:00:00 2001 From: =?utf8?q?Fran=C3=A7ois=20Pinard?= Date: Wed, 16 Nov 1994 02:43:39 +0000 Subject: [PATCH] *** empty log message *** --- src/create.c | 2 +- src/port.c | 1357 ++++++++++++++++++++++++++----------------------- src/version.c | 2 +- 3 files changed, 723 insertions(+), 638 deletions(-) diff --git a/src/create.c b/src/create.c index 018044f..62b9c51 100644 --- a/src/create.c +++ b/src/create.c @@ -253,7 +253,7 @@ dump_file (p, curdev, toplevel) && !S_ISDIR (hstat.st_mode) && (f_new_files > 1 || new_time > hstat.st_ctime)) { - if (curdev < 0) + if (curdev == -1) { msg ("%s: is unchanged; not dumped", p); } diff --git a/src/port.c b/src/port.c index 6fb9418..aab6039 100644 --- a/src/port.c +++ b/src/port.c @@ -48,7 +48,7 @@ char TTY_NAME[] = "con"; #else /* not __MSDOS__ */ -char TTY_NAME[] ="/dev/tty"; +char TTY_NAME[] = "/dev/tty"; #endif /* not __MSDOS__ */ @@ -62,15 +62,16 @@ char TTY_NAME[] ="/dev/tty"; */ char * valloc (size) - unsigned size; + unsigned size; { - return (malloc (size)); + return (malloc (size)); } + #endif /* !HAVE_VALLOC */ #ifndef HAVE_MKDIR /* - * Written by Robert Rother, Mariah Corporation, August 1985. + * Written by Robert Rother, Mariah Corporation, August 1985. * * If you want it, it's yours. All I ask in return is that if you * figure out how to do this in a Bourne Shell script you send me @@ -88,82 +89,90 @@ valloc (size) * Make a directory. */ int -mkdir(dpath, dmode) - char *dpath; - int dmode; +mkdir (dpath, dmode) + char *dpath; + int dmode; { - int cpid, status; - struct stat statbuf; + int cpid, status; + struct stat statbuf; - if (stat(dpath,&statbuf) == 0) { - errno = EEXIST; /* Stat worked, so it already exists */ - return -1; - } + if (stat (dpath, &statbuf) == 0) + { + errno = EEXIST; /* Stat worked, so it already exists */ + return -1; + } - /* If stat fails for a reason other than non-existence, return error */ - if (errno != ENOENT) return -1; + /* If stat fails for a reason other than non-existence, return error */ + if (errno != ENOENT) + return -1; - switch (cpid = fork()) { + switch (cpid = fork ()) + { - case -1: /* Error in fork() */ - return(-1); /* Errno is set already */ + case -1: /* Error in fork() */ + return (-1); /* Errno is set already */ - case 0: /* Child process */ - /* + case 0: /* Child process */ + /* * Cheap hack to set mode of new directory. Since this * child process is going away anyway, we zap its umask. * FIXME, this won't suffice to set SUID, SGID, etc. on this * directory. Does anybody care? */ - status = umask(0); /* Get current umask */ - status = umask(status | (0777 & ~dmode)); /* Set for mkdir */ - execl("/bin/mkdir", "mkdir", dpath, (char *)0); - _exit(-1); /* Can't exec /bin/mkdir */ - - default: /* Parent process */ - while (cpid != wait(&status)) ; /* Wait for kid to finish */ - } + status = umask (0); /* Get current umask */ + status = umask (status | (0777 & ~dmode)); /* Set for mkdir */ + execl ("/bin/mkdir", "mkdir", dpath, (char *) 0); + _exit (-1); /* Can't exec /bin/mkdir */ - if (WIFSIGNALED(status) || WEXITSTATUS(status) != 0) { - errno = EIO; /* We don't know why, but */ - return -1; /* /bin/mkdir failed */ - } + default: /* Parent process */ + while (cpid != wait (&status)); /* Wait for kid to finish */ + } - return 0; + if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0) + { + errno = EIO; /* We don't know why, but */ + return -1; /* /bin/mkdir failed */ + } + + return 0; } int -rmdir(dpath) - char *dpath; +rmdir (dpath) + char *dpath; { - int cpid, status; - struct stat statbuf; + int cpid, status; + struct stat statbuf; - if (stat(dpath,&statbuf) != 0) { - /* Stat just set errno. We don't have to */ - return -1; - } + if (stat (dpath, &statbuf) != 0) + { + /* Stat just set errno. We don't have to */ + return -1; + } - switch (cpid = fork()) { + switch (cpid = fork ()) + { - case -1: /* Error in fork() */ - return(-1); /* Errno is set already */ + case -1: /* Error in fork() */ + return (-1); /* Errno is set already */ - case 0: /* Child process */ - execl("/bin/rmdir", "rmdir", dpath, (char *)0); - _exit(-1); /* Can't exec /bin/mkdir */ - - default: /* Parent process */ - while (cpid != wait(&status)) ; /* Wait for kid to finish */ - } + case 0: /* Child process */ + execl ("/bin/rmdir", "rmdir", dpath, (char *) 0); + _exit (-1); /* Can't exec /bin/mkdir */ - if (WIFSIGNALED(status) || WEXITSTATUS(status) != 0) { - errno = EIO; /* We don't know why, but */ - return -1; /* /bin/mkdir failed */ - } + default: /* Parent process */ + while (cpid != wait (&status)); /* Wait for kid to finish */ + } - return 0; + if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0) + { + errno = EIO; /* We don't know why, but */ + return -1; /* /bin/mkdir failed */ + } + + return 0; } + #endif /* !HAVE_MKDIR */ #ifndef HAVE_RENAME @@ -194,28 +203,32 @@ rename (from, to) return 0; } + #endif /* !HAVE_RENAME */ #ifdef minix /* Minix has bcopy but not bzero, and no memset. Thanks, Andy. */ void bzero (s1, n) - register char *s1; - register int n; + register char *s1; + register int n; { - while (n--) *s1++ = '\0'; + while (n--) + *s1++ = '\0'; } /* It also has no bcmp() */ int -bcmp (s1, s2, n) - register char *s1,*s2; - register int n; +bcmp (s1, s2, n) + register char *s1, *s2; + register int n; { - for ( ; n-- ; ++s1, ++s2) { - if (*s1 != *s2) return *s1 - *s2; - } - return 0; + for (; n--; ++s1, ++s2) + { + if (*s1 != *s2) + return *s1 - *s2; + } + return 0; } /* @@ -230,66 +243,75 @@ bcmp (s1, s2, n) * *and* doesn't have execlp, YOU get to fix it. */ int -execlp(filename, arg0) - char *filename, *arg0; +execlp (filename, arg0) + char *filename, *arg0; { - register char *p, *path; - register char *fnbuffer; - char **argstart = &arg0; - struct stat statbuf; - extern char **environ; - - if ((p = getenv("PATH")) == NULL) { - /* couldn't find path variable -- try to exec given filename */ - return execve(filename, argstart, environ); - } + register char *p, *path; + register char *fnbuffer; + char **argstart = &arg0; + struct stat statbuf; + extern char **environ; - /* + if ((p = getenv ("PATH")) == NULL) + { + /* couldn't find path variable -- try to exec given filename */ + return execve (filename, argstart, environ); + } + + /* * make a place to build the filename. We malloc larger than we * need, but we know it will fit in this. */ - fnbuffer = malloc( strlen(p) + 1 + strlen(filename) ); - if (fnbuffer == NULL) { - errno = ENOMEM; - return -1; - } + fnbuffer = malloc (strlen (p) + 1 + strlen (filename)); + if (fnbuffer == NULL) + { + errno = ENOMEM; + return -1; + } - /* + /* * try each component of the path to see if the file's there * and executable. */ - for (path = p ; path ; path = p) { - /* construct full path name to try */ - if ((p = index(path,':')) == NULL) { - strcpy(fnbuffer, path); - } else { - strncpy(fnbuffer, path, p-path); - fnbuffer[p-path] = '\0'; - p++; /* Skip : for next time */ - } - if (strlen(fnbuffer) != 0) - strcat(fnbuffer,"/"); - strcat(fnbuffer,filename); - - /* check to see if file is there and is a normal file */ - if (stat(fnbuffer, &statbuf) < 0) { - if (errno == ENOENT) - continue; /* file not there,keep on looking */ - else - goto fail; /* failed for some reason, return */ - } - if (!S_ISREG(statbuf.st_mode)) continue; - - if (execve(fnbuffer, argstart, environ) < 0 - && errno != ENOENT - && errno != ENOEXEC) { - /* failed, for some other reason besides "file + for (path = p; path; path = p) + { + /* construct full path name to try */ + if ((p = index (path, ':')) == NULL) + { + strcpy (fnbuffer, path); + } + else + { + strncpy (fnbuffer, path, p - path); + fnbuffer[p - path] = '\0'; + p++; /* Skip : for next time */ + } + if (strlen (fnbuffer) != 0) + strcat (fnbuffer, "/"); + strcat (fnbuffer, filename); + + /* check to see if file is there and is a normal file */ + if (stat (fnbuffer, &statbuf) < 0) + { + if (errno == ENOENT) + continue; /* file not there,keep on looking */ + else + goto fail; /* failed for some reason, return */ + } + if (!S_ISREG (statbuf.st_mode)) + continue; + + if (execve (fnbuffer, argstart, environ) < 0 + && errno != ENOENT + && errno != ENOEXEC) + { + /* failed, for some other reason besides "file * not found" or "not a.out format" */ - goto fail; - } + goto fail; + } - /* + /* * If we got error ENOEXEC, the file is executable but is * not an object file. Try to execute it as a shell script, * returning error if we can't execute /bin/sh. @@ -301,32 +323,34 @@ execlp(filename, arg0) * code clobbers argstart[-1] if the exec of the shell * fails. */ - if (errno == ENOEXEC) { - char *shell; - - /* Try to execute command "sh arg0 arg1 ..." */ - if ((shell = getenv("SHELL")) == NULL) - shell = "/bin/sh"; - argstart[-1] = shell; - argstart[0] = fnbuffer; - execve(shell, &argstart[-1], environ); - goto fail; /* Exec didn't work */ - } - - /* + if (errno == ENOEXEC) + { + char *shell; + + /* Try to execute command "sh arg0 arg1 ..." */ + if ((shell = getenv ("SHELL")) == NULL) + shell = "/bin/sh"; + argstart[-1] = shell; + argstart[0] = fnbuffer; + execve (shell, &argstart[-1], environ); + goto fail; /* Exec didn't work */ + } + + /* * If we succeeded, the execve() doesn't return, so we * can only be here is if the file hasn't been found yet. * Try the next place on the path. */ - } + } - /* all attempts failed to locate the file. Give up. */ - errno = ENOENT; + /* all attempts failed to locate the file. Give up. */ + errno = ENOENT; fail: - free(fnbuffer); - return -1; + free (fnbuffer); + return -1; } + #endif /* minix */ @@ -362,32 +386,32 @@ fail: * and also contains integers (args to 'access') that should be #define's. */ static int modes[] = - { - 04, /* O_RDONLY */ - 02, /* O_WRONLY */ - 06, /* O_RDWR */ - 06, /* invalid but we'd better cope -- O_WRONLY+O_RDWR */ - }; +{ + 04, /* O_RDONLY */ + 02, /* O_WRONLY */ + 06, /* O_RDWR */ + 06, /* invalid but we'd better cope -- O_WRONLY+O_RDWR */ +}; /* Shut off the automatic emulation of open(), we'll need it. */ #undef open int -open3(path, flags, mode) -char *path; -int flags, mode; +open3 (path, flags, mode) + char *path; + int flags, mode; { - int exists = 1; - int call_creat = 0; - int fd; - /* + int exists = 1; + int call_creat = 0; + int fd; + /* * We actually do the work by calling the open() or creat() system - * call, depending on the flags. Call_creat is true if we will use + * call, depending on the flags. Call_creat is true if we will use * creat(), false if we will use open(). */ - /* - * See if the file exists and is accessible in the requested mode. + /* + * See if the file exists and is accessible in the requested mode. * * Strictly speaking we shouldn't be using access, since access checks * against real uid, and the open call should check against euid. @@ -395,67 +419,83 @@ int flags, mode; * FIXME, the construction "flags & 3" and the modes table depends * on the specific integer values of the O_XXX #define's. Foo! */ - if (access(path,modes[flags & 3]) < 0) { - if (errno == ENOENT) { - /* the file does not exist */ - exists = 0; - } else { - /* probably permission violation */ - if (flags & O_EXCL) { - /* Oops, the file exists, we didn't want it. */ - /* No matter what the error, claim EEXIST. */ - errno = EEXIST; - } - return -1; - } + if (access (path, modes[flags & 3]) < 0) + { + if (errno == ENOENT) + { + /* the file does not exist */ + exists = 0; } + else + { + /* probably permission violation */ + if (flags & O_EXCL) + { + /* Oops, the file exists, we didn't want it. */ + /* No matter what the error, claim EEXIST. */ + errno = EEXIST; + } + return -1; + } + } - /* if we have the O_CREAT bit set, check for O_EXCL */ - if (flags & O_CREAT) { - if ((flags & O_EXCL) && exists) { - /* Oops, the file exists and we didn't want it to. */ - errno = EEXIST; - return -1; - } - /* + /* if we have the O_CREAT bit set, check for O_EXCL */ + if (flags & O_CREAT) + { + if ((flags & O_EXCL) && exists) + { + /* Oops, the file exists and we didn't want it to. */ + errno = EEXIST; + return -1; + } + /* * If the file doesn't exist, be sure to call creat() so that * it will be created with the proper mode. */ - if (!exists) call_creat = 1; - } else { - /* If O_CREAT isn't set and the file doesn't exist, error. */ - if (!exists) { - errno = ENOENT; - return -1; - } + if (!exists) + call_creat = 1; + } + else + { + /* If O_CREAT isn't set and the file doesn't exist, error. */ + if (!exists) + { + errno = ENOENT; + return -1; } + } - /* + /* * If the O_TRUNC flag is set and the file exists, we want to call * creat() anyway, since creat() guarantees that the file will be * truncated and open()-for-writing doesn't. * (If the file doesn't exist, we're calling creat() anyway and the * file will be created with zero length.) */ - if ((flags & O_TRUNC) && exists) call_creat = 1; - /* actually do the call */ - if (call_creat) { - /* + if ((flags & O_TRUNC) && exists) + call_creat = 1; + /* actually do the call */ + if (call_creat) + { + /* * call creat. May have to close and reopen the file if we * want O_RDONLY or O_RDWR access -- creat() only gives * O_WRONLY. */ - fd = creat(path,mode); - if (fd < 0 || (flags & O_WRONLY)) return fd; - if (close(fd) < 0) return -1; - /* Fall out to reopen the file we've created */ - } + fd = creat (path, mode); + if (fd < 0 || (flags & O_WRONLY)) + return fd; + if (close (fd) < 0) + return -1; + /* Fall out to reopen the file we've created */ + } - /* + /* * calling old open, we strip most of the new flags just in case. */ - return open(path, flags & (O_RDONLY|O_WRONLY|O_RDWR|O_BINARY)); + return open (path, flags & (O_RDONLY | O_WRONLY | O_RDWR | O_BINARY)); } + #endif /* EMUL_OPEN3 */ #ifndef HAVE_MKNOD @@ -464,67 +504,71 @@ typedef int dev_t; #endif /* Fake mknod by complaining */ int -mknod(path, mode, dev) - char *path; - unsigned short mode; - dev_t dev; +mknod (path, mode, dev) + char *path; + unsigned short mode; + dev_t dev; { - int fd; - - errno = ENXIO; /* No such device or address */ - return -1; /* Just give an error */ + int fd; + + errno = ENXIO; /* No such device or address */ + return -1; /* Just give an error */ } /* Fake links by copying */ int -link(path1, path2) - char *path1; - char *path2; +link (path1, path2) + char *path1; + char *path2; { - char buf[256]; - int ifd, ofd; - int nrbytes; - int nwbytes; - - fprintf(stderr, "%s: %s: cannot link to %s, copying instead\n", - tar, path1, path2); - if ((ifd = open(path1, O_RDONLY|O_BINARY)) < 0) - return -1; - if ((ofd = creat(path2, 0666)) < 0) - return -1; - setmode(ofd, O_BINARY); - while ((nrbytes = read(ifd, buf, sizeof(buf))) > 0) { - if ((nwbytes = write(ofd, buf, nrbytes)) != nrbytes) { - nrbytes = -1; - break; - } + char buf[256]; + int ifd, ofd; + int nrbytes; + int nwbytes; + + fprintf (stderr, "%s: %s: cannot link to %s, copying instead\n", + tar, path1, path2); + if ((ifd = open (path1, O_RDONLY | O_BINARY)) < 0) + return -1; + if ((ofd = creat (path2, 0666)) < 0) + return -1; + setmode (ofd, O_BINARY); + while ((nrbytes = read (ifd, buf, sizeof (buf))) > 0) + { + if ((nwbytes = write (ofd, buf, nrbytes)) != nrbytes) + { + nrbytes = -1; + break; } - /* Note use of "|" rather than "||" below: we want to close + } + /* Note use of "|" rather than "||" below: we want to close * the files even if an error occurs. */ - if ((nrbytes < 0) | (0 != close(ifd)) | (0 != close(ofd))) { - unlink(path2); - return -1; - } - return 0; + if ((nrbytes < 0) | (0 != close (ifd)) | (0 != close (ofd))) + { + unlink (path2); + return -1; + } + return 0; } /* everyone owns everything on MS-DOS (or is it no one owns anything?) */ int -chown(path, uid, gid) - char *path; - int uid; - int gid; +chown (path, uid, gid) + char *path; + int uid; + int gid; { - return 0; + return 0; } int -geteuid() +geteuid () { - return 0; + return 0; } -#endif /* !HAVE_MKNOD */ + +#endif /* !HAVE_MKNOD */ #ifdef __TURBOC__ #include @@ -533,8 +577,8 @@ geteuid() struct utimbuf { - time_t actime; /* Access time. */ - time_t modtime; /* Modification time. */ + time_t actime; /* Access time. */ + time_t modtime; /* Modification time. */ }; int @@ -573,193 +617,203 @@ utime (char *filename, struct utimbuf *utb) _close (fd); return status; } + #endif /* __TURBOC__ */ /* Stash argv[0] here so panic will know what the program is called */ char *myname = 0; void -panic(s) -char *s; +panic (s) + char *s; { - if(myname) - fprintf(stderr,"%s:",myname); - fprintf(stderr,s); - putc('\n',stderr); - exit(12); + if (myname) + fprintf (stderr, "%s:", myname); + fprintf (stderr, s); + putc ('\n', stderr); + exit (12); } PTR -ck_malloc(size) -size_t size; +ck_malloc (size) + size_t size; { - PTR ret; - - if(!size) - size++; - ret=malloc(size); - if(ret==0) - panic("Couldn't allocate memory"); - return ret; + PTR ret; + + if (!size) + size++; + ret = malloc (size); + if (ret == 0) + panic ("Couldn't allocate memory"); + return ret; } /* Used by alloca.c and bison.simple. */ char * -xmalloc(size) -size_t size; +xmalloc (size) + size_t size; { - return (char *) ck_malloc(size); + return (char *) ck_malloc (size); } PTR -ck_realloc(ptr,size) -PTR ptr; -size_t size; +ck_realloc (ptr, size) + PTR ptr; + size_t size; { - PTR ret; - - if(!ptr) - ret=ck_malloc(size); - else - ret=realloc(ptr,size); - if(ret==0) - panic("Couldn't re-allocate memory"); - return ret; + PTR ret; + + if (!ptr) + ret = ck_malloc (size); + else + ret = realloc (ptr, size); + if (ret == 0) + panic ("Couldn't re-allocate memory"); + return ret; } /* Implement a variable sized buffer of 'stuff'. We don't know what it is, nor do we care, as long as it doesn't mind being aligned on a char boundry. */ -struct buffer { - int allocated; - int length; - char *b; -}; +struct buffer + { + int allocated; + int length; + char *b; + }; #define MIN_ALLOCATE 50 char * -init_buffer() +init_buffer () { - struct buffer *b; + struct buffer *b; - b=(struct buffer *)ck_malloc(sizeof(struct buffer)); - b->allocated=MIN_ALLOCATE; - b->b=(char *)ck_malloc(MIN_ALLOCATE); - b->length=0; - return (char *)b; + b = (struct buffer *) ck_malloc (sizeof (struct buffer)); + b->allocated = MIN_ALLOCATE; + b->b = (char *) ck_malloc (MIN_ALLOCATE); + b->length = 0; + return (char *) b; } void -flush_buffer(bb) -char *bb; +flush_buffer (bb) + char *bb; { - struct buffer *b; - - b=(struct buffer *)bb; - free(b->b); - b->b=0; - b->allocated=0; - b->length=0; - free((void *)b); + struct buffer *b; + + b = (struct buffer *) bb; + free (b->b); + b->b = 0; + b->allocated = 0; + b->length = 0; + free ((void *) b); } void -add_buffer(bb,p,n) -char *bb; -char *p; -int n; +add_buffer (bb, p, n) + char *bb; + char *p; + int n; { - struct buffer *b; + struct buffer *b; - b=(struct buffer *)bb; - if(b->length+n>b->allocated) { - b->allocated=b->length+n+MIN_ALLOCATE; - b->b=(char *)ck_realloc(b->b,b->allocated); - } - bcopy(p,b->b+b->length,n); - b->length+=n; + b = (struct buffer *) bb; + if (b->length + n > b->allocated) + { + b->allocated = b->length + n + MIN_ALLOCATE; + b->b = (char *) ck_realloc (b->b, b->allocated); + } + bcopy (p, b->b + b->length, n); + b->length += n; } char * -get_buffer(bb) -char *bb; +get_buffer (bb) + char *bb; { - struct buffer *b; + struct buffer *b; - b=(struct buffer *)bb; - return b->b; + b = (struct buffer *) bb; + return b->b; } char * -merge_sort(list,n,off,cmp) -char *list; -int (*cmp)(); -unsigned n; -int off; +merge_sort (list, n, off, cmp) + char *list; + int (*cmp) (); + unsigned n; + int off; { - char *ret; + char *ret; - char *alist,*blist; - unsigned alength,blength; + char *alist, *blist; + unsigned alength, blength; - char *tptr; - int tmp; - char **prev; + char *tptr; + int tmp; + char **prev; #define NEXTOF(ptr) (* ((char **)(((char *)(ptr))+off) ) ) - if(n==1) - return list; - if(n==2) { - if((*cmp)(list,NEXTOF(list))>0) { - ret=NEXTOF(list); - NEXTOF(ret)=list; - NEXTOF(list)=0; - return ret; - } - return list; + if (n == 1) + return list; + if (n == 2) + { + if ((*cmp) (list, NEXTOF (list)) > 0) + { + ret = NEXTOF (list); + NEXTOF (ret) = list; + NEXTOF (list) = 0; + return ret; } - alist=list; - alength=(n+1)/2; - blength=n/2; - for(tptr=list,tmp=(n-1)/2;tmp;tptr=NEXTOF(tptr),tmp--) - ; - blist=NEXTOF(tptr); - NEXTOF(tptr)=0; - - alist=merge_sort(alist,alength,off,cmp); - blist=merge_sort(blist,blength,off,cmp); - prev = &ret; - for(;alist && blist;) { - if((*cmp)(alist,blist)<0) { - tptr=NEXTOF(alist); - *prev = alist; - prev = &(NEXTOF(alist)); - alist=tptr; - } else { - tptr=NEXTOF(blist); - *prev = blist; - prev = &(NEXTOF(blist)); - blist=tptr; - } + return list; + } + alist = list; + alength = (n + 1) / 2; + blength = n / 2; + for (tptr = list, tmp = (n - 1) / 2; tmp; tptr = NEXTOF (tptr), tmp--) + ; + blist = NEXTOF (tptr); + NEXTOF (tptr) = 0; + + alist = merge_sort (alist, alength, off, cmp); + blist = merge_sort (blist, blength, off, cmp); + prev = &ret; + for (; alist && blist;) + { + if ((*cmp) (alist, blist) < 0) + { + tptr = NEXTOF (alist); + *prev = alist; + prev = &(NEXTOF (alist)); + alist = tptr; + } + else + { + tptr = NEXTOF (blist); + *prev = blist; + prev = &(NEXTOF (blist)); + blist = tptr; } - if(alist) - *prev = alist; - else - *prev = blist; + } + if (alist) + *prev = alist; + else + *prev = blist; - return ret; + return ret; } void -ck_close(fd) -int fd; +ck_close (fd) + int fd; { - if(close(fd)<0) { - msg_perror("can't close a file #%d",fd); - exit(EX_SYSTEM); - } + if (close (fd) < 0) + { + msg_perror ("can't close a file #%d", fd); + exit (EX_SYSTEM); + } } #include @@ -771,67 +825,83 @@ int fd; caller is done with it. */ char * -quote_copy_string(string) -char *string; +quote_copy_string (string) + char *string; { - char *from_here; - char *to_there = 0; - char *copy_buf = 0; - int c; - int copying = 0; - - from_here=string; - while(*from_here) { - c= *from_here++; - if(c=='\\') { - if(!copying) { - int n; - - n=(from_here-string)-1; - copying++; - copy_buf=(char *)malloc(n+5+strlen(from_here)*4); - if(!copy_buf) - return 0; - bcopy(string,copy_buf,n); - to_there=copy_buf+n; - } - *to_there++='\\'; - *to_there++='\\'; - } else if(isprint(c)) { - if(copying) - *to_there++= c; - } else { - if(!copying) { - int n; - - n=(from_here-string)-1; - copying++; - copy_buf=(char *)malloc(n+5+strlen(from_here)*4); - if(!copy_buf) - return 0; - bcopy(string,copy_buf,n); - to_there=copy_buf+n; - } - *to_there++='\\'; - if(c=='\n') *to_there++='n'; - else if(c=='\t') *to_there++='t'; - else if(c=='\f') *to_there++='f'; - else if(c=='\b') *to_there++='b'; - else if(c=='\r') *to_there++='r'; - else if(c=='\177') *to_there++='?'; - else { - to_there[0]=(c>>6)+'0'; - to_there[1]=((c>>3)&07)+'0'; - to_there[2]=(c&07)+'0'; - to_there+=3; - } - } + char *from_here; + char *to_there = 0; + char *copy_buf = 0; + int c; + int copying = 0; + + from_here = string; + while (*from_here) + { + c = *from_here++; + if (c == '\\') + { + if (!copying) + { + int n; + + n = (from_here - string) - 1; + copying++; + copy_buf = (char *) malloc (n + 5 + strlen (from_here) * 4); + if (!copy_buf) + return 0; + bcopy (string, copy_buf, n); + to_there = copy_buf + n; + } + *to_there++ = '\\'; + *to_there++ = '\\'; + } + else if (isprint (c)) + { + if (copying) + *to_there++ = c; } - if(copying) { - *to_there='\0'; - return copy_buf; + else + { + if (!copying) + { + int n; + + n = (from_here - string) - 1; + copying++; + copy_buf = (char *) malloc (n + 5 + strlen (from_here) * 4); + if (!copy_buf) + return 0; + bcopy (string, copy_buf, n); + to_there = copy_buf + n; + } + *to_there++ = '\\'; + if (c == '\n') + *to_there++ = 'n'; + else if (c == '\t') + *to_there++ = 't'; + else if (c == '\f') + *to_there++ = 'f'; + else if (c == '\b') + *to_there++ = 'b'; + else if (c == '\r') + *to_there++ = 'r'; + else if (c == '\177') + *to_there++ = '?'; + else + { + to_there[0] = (c >> 6) + '0'; + to_there[1] = ((c >> 3) & 07) + '0'; + to_there[2] = (c & 07) + '0'; + to_there += 3; + } } - return (char *)0; + } + if (copying) + { + *to_there = '\0'; + return copy_buf; + } + return (char *) 0; } @@ -843,96 +913,103 @@ char *string; /* There is no un-quote-copy-string. Write it yourself */ char * -un_quote_string(string) -char *string; +un_quote_string (string) + char *string; { - char *ret; - char *from_here; - char *to_there; - int tmp; - - ret=string; - to_there=string; - from_here=string; - while(*from_here) { - if(*from_here!='\\') { - if(from_here!=to_there) - *to_there++= *from_here++; - else - from_here++,to_there++; - continue; - } - switch(*++from_here) { - case '\\': - *to_there++= *from_here++; - break; - case 'n': - *to_there++= '\n'; - from_here++; - break; - case 't': - *to_there++= '\t'; - from_here++; - break; - case 'f': - *to_there++= '\f'; - from_here++; - break; - case 'b': - *to_there++= '\b'; - from_here++; - break; - case 'r': - *to_there++= '\r'; - from_here++; - break; - case '?': - *to_there++= 0177; - from_here++; - break; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - tmp= *from_here - '0'; - from_here++; - if(*from_here<'0' || *from_here>'7') { - *to_there++= tmp; - break; - } - tmp= tmp*8 + *from_here-'0'; - from_here++; - if(*from_here<'0' || *from_here>'7') { - *to_there++= tmp; - break; - } - tmp=tmp*8 + *from_here-'0'; - from_here++; - *to_there=tmp; - break; - default: - ret=0; - *to_there++='\\'; - *to_there++= *from_here++; - break; - } + char *ret; + char *from_here; + char *to_there; + int tmp; + + ret = string; + to_there = string; + from_here = string; + while (*from_here) + { + if (*from_here != '\\') + { + if (from_here != to_there) + *to_there++ = *from_here++; + else + from_here++, to_there++; + continue; + } + switch (*++from_here) + { + case '\\': + *to_there++ = *from_here++; + break; + case 'n': + *to_there++ = '\n'; + from_here++; + break; + case 't': + *to_there++ = '\t'; + from_here++; + break; + case 'f': + *to_there++ = '\f'; + from_here++; + break; + case 'b': + *to_there++ = '\b'; + from_here++; + break; + case 'r': + *to_there++ = '\r'; + from_here++; + break; + case '?': + *to_there++ = 0177; + from_here++; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + tmp = *from_here - '0'; + from_here++; + if (*from_here < '0' || *from_here > '7') + { + *to_there++ = tmp; + break; + } + tmp = tmp * 8 + *from_here - '0'; + from_here++; + if (*from_here < '0' || *from_here > '7') + { + *to_there++ = tmp; + break; + } + tmp = tmp * 8 + *from_here - '0'; + from_here++; + *to_there = tmp; + break; + default: + ret = 0; + *to_there++ = '\\'; + *to_there++ = *from_here++; + break; } - if(*to_there) - *to_there++='\0'; - return ret; + } + if (*to_there) + *to_there++ = '\0'; + return ret; } -void ck_pipe(pipes) -int *pipes; +void +ck_pipe (pipes) + int *pipes; { - if(pipe(pipes)<0) { - msg_perror("can't open a pipe"); - exit(EX_SYSTEM); - } + if (pipe (pipes) < 0) + { + msg_perror ("can't open a pipe"); + exit (EX_SYSTEM); + } } @@ -942,28 +1019,29 @@ int *pipes; */ char * /* found string, or NULL if none */ -strstr(s, wanted) -char *s; -char *wanted; +strstr (s, wanted) + char *s; + char *wanted; { - register char *scan; - register size_t len; - register char firstc; + register char *scan; + register size_t len; + register char firstc; - if (*wanted == '\0') - return (char *)0; - /* + if (*wanted == '\0') + return (char *) 0; + /* * The odd placement of the two tests is so "" is findable. * Also, we inline the first char for speed. * The ++ on scan has been moved down for optimization. */ - firstc = *wanted; - len = strlen(wanted); - for (scan = s; *scan != firstc || strncmp(scan, wanted, len) != 0; ) - if (*scan++ == '\0') - return (char *)0; - return scan; + firstc = *wanted; + len = strlen (wanted); + for (scan = s; *scan != firstc || strncmp (scan, wanted, len) != 0;) + if (*scan++ == '\0') + return (char *) 0; + return scan; } + #endif /* !HAVE_STRSTR */ #ifndef HAVE_FTRUNCATE @@ -976,23 +1054,24 @@ ftruncate (fd, length) { return fcntl (fd, F_CHSIZE, length); } + #else /* !F_CHSIZE */ #ifdef F_FREESP /* code courtesy of William Kucharski, kucharsk@Solbourne.com */ int -ftruncate(fd, length) -int fd; /* file descriptor */ -off_t length; /* length to set file to */ +ftruncate (fd, length) + int fd; /* file descriptor */ + off_t length; /* length to set file to */ { - struct flock fl; + struct flock fl; - fl.l_whence = 0; - fl.l_len = 0; - fl.l_start = length; - fl.l_type = F_WRLCK; /* write lock on file space */ + fl.l_whence = 0; + fl.l_len = 0; + fl.l_start = length; + fl.l_type = F_WRLCK; /* write lock on file space */ - /* + /* * This relies on the UNDOCUMENTED F_FREESP argument to * fcntl(2), which truncates the file so that it ends at the * position indicated by fl.l_start. @@ -1000,22 +1079,23 @@ off_t length; /* length to set file to */ * Will minor miracles never cease? */ - if (fcntl(fd, F_FREESP, &fl) < 0) - return -1; + if (fcntl (fd, F_FREESP, &fl) < 0) + return -1; - return 0; + return 0; } #else /* !F_FREESP */ int -ftruncate(fd, length) -int fd; -off_t length; +ftruncate (fd, length) + int fd; + off_t length; { - errno = EIO; - return -1; + errno = EIO; + return -1; } + #endif /* !F_FREESP */ #endif /* !F_CHSIZE */ #endif /* !HAVE_FTRUNCATE */ @@ -1027,143 +1107,148 @@ extern FILE *msg_file; #include void -msg(char *str,...) +msg (char *str,...) { - va_list args; - - va_start(args,str); - fflush(msg_file); - fprintf(stderr,"%s: ",tar); - if(f_sayblock) - fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block)); - vfprintf(stderr,str,args); - va_end(args); - putc('\n',stderr); - fflush(stderr); + va_list args; + + va_start (args, str); + fflush (msg_file); + fprintf (stderr, "%s: ", tar); + if (f_sayblock) + fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block)); + vfprintf (stderr, str, args); + va_end (args); + putc ('\n', stderr); + fflush (stderr); } void -msg_perror(char *str,...) +msg_perror (char *str,...) { - va_list args; - int save_e; - - save_e=errno; - fflush(msg_file); - fprintf(stderr,"%s: ",tar); - if(f_sayblock) - fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block)); - va_start(args,str); - vfprintf(stderr,str,args); - va_end(args); - errno=save_e; - perror(" "); - fflush(stderr); + va_list args; + int save_e; + + save_e = errno; + fflush (msg_file); + fprintf (stderr, "%s: ", tar); + if (f_sayblock) + fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block)); + va_start (args, str); + vfprintf (stderr, str, args); + va_end (args); + errno = save_e; + perror (" "); + fflush (stderr); } + #endif /* HAVE_VPRINTF and __STDC__ */ #if defined(HAVE_VPRINTF) && !__STDC__ #include void -msg(str,va_alist) -char *str; -va_dcl +msg (str, va_alist) + char *str; + va_dcl { - va_list args; - - fflush(msg_file); - fprintf(stderr,"%s: ",tar); - if(f_sayblock) - fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block)); - va_start(args); - vfprintf(stderr,str,args); - va_end(args); - putc('\n',stderr); - fflush(stderr); + va_list args; + + fflush (msg_file); + fprintf (stderr, "%s: ", tar); + if (f_sayblock) + fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block)); + va_start (args); + vfprintf (stderr, str, args); + va_end (args); + putc ('\n', stderr); + fflush (stderr); } void -msg_perror(str,va_alist) -char *str; -va_dcl +msg_perror (str, va_alist) + char *str; + va_dcl { - va_list args; - int save_e; - - save_e=errno; - fflush(msg_file); - fprintf(stderr,"%s: ",tar); - if(f_sayblock) - fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block)); - va_start(args); - vfprintf(stderr,str,args); - va_end(args); - errno=save_e; - perror(" "); - fflush(stderr); + va_list args; + int save_e; + + save_e = errno; + fflush (msg_file); + fprintf (stderr, "%s: ", tar); + if (f_sayblock) + fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block)); + va_start (args); + vfprintf (stderr, str, args); + va_end (args); + errno = save_e; + perror (" "); + fflush (stderr); } + #endif /* HAVE_VPRINTF and not __STDC__ */ #if !defined(HAVE_VPRINTF) && defined(HAVE_DOPRNT) void -msg(str,args) -char *str; -int args; +msg (str, args) + char *str; + int args; { - fflush(msg_file); - fprintf(stderr,"%s: ",tar); - if(f_sayblock) - fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block)); - _doprnt(str, &args, stderr); - putc('\n',stderr); - fflush(stderr); + fflush (msg_file); + fprintf (stderr, "%s: ", tar); + if (f_sayblock) + fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block)); + _doprnt (str, &args, stderr); + putc ('\n', stderr); + fflush (stderr); } void -msg_perror(str,args) -char *str; +msg_perror (str, args) + char *str; { - int save_e; - - save_e=errno; - fflush(msg_file); - fprintf(stderr,"%s: ",tar); - if(f_sayblock) - fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block)); - _doprnt(str, &args, stderr); - errno=save_e; - perror(" "); - fflush(stderr); + int save_e; + + save_e = errno; + fflush (msg_file); + fprintf (stderr, "%s: ", tar); + if (f_sayblock) + fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block)); + _doprnt (str, &args, stderr); + errno = save_e; + perror (" "); + fflush (stderr); } + #endif /* !HAVE_VPRINTF and HAVE_DOPRNT */ #if !defined(HAVE_VPRINTF) && !defined(HAVE_DOPRNT) -void msg(str,a1,a2,a3,a4,a5,a6) -char *str; +void +msg (str, a1, a2, a3, a4, a5, a6) + char *str; { - fflush(msg_file); - fprintf(stderr,"%s: ",tar); - if(f_sayblock) - fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block)); - fprintf(stderr,str,a1,a2,a3,a4,a5,a6); - putc('\n',stderr); - fflush(stderr); + fflush (msg_file); + fprintf (stderr, "%s: ", tar); + if (f_sayblock) + fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block)); + fprintf (stderr, str, a1, a2, a3, a4, a5, a6); + putc ('\n', stderr); + fflush (stderr); } void -msg_perror(str,a1,a2,a3,a4,a5,a6) -char *str; +msg_perror (str, a1, a2, a3, a4, a5, a6) + char *str; { - int save_e; - - save_e=errno; - fflush(msg_file); - fprintf(stderr,"%s: ",tar); - if(f_sayblock) - fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block)); - fprintf(stderr,str,a1,a2,a3,a4,a5,a6); - fprintf(stderr,": "); - errno=save_e; - perror(" "); + int save_e; + + save_e = errno; + fflush (msg_file); + fprintf (stderr, "%s: ", tar); + if (f_sayblock) + fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block)); + fprintf (stderr, str, a1, a2, a3, a4, a5, a6); + fprintf (stderr, ": "); + errno = save_e; + perror (" "); } + #endif /* !HAVE_VPRINTF and !HAVE_DOPRNT */ diff --git a/src/version.c b/src/version.c index ce6c2f8..4454f62 100644 --- a/src/version.c +++ b/src/version.c @@ -1 +1 @@ -char version_string[] = "GNU tar version 1.11.1"; +char version_string[] = "GNU tar version 1.11.2"; -- 2.45.2