From 86d2ec4f33295b8acb63773762c6f47f4238315a Mon Sep 17 00:00:00 2001 From: =?utf8?q?Fran=C3=A7ois=20Pinard?= Date: Wed, 16 Nov 1994 02:43:44 +0000 Subject: [PATCH] Initial revision --- src/port.c | 1445 +++++++++++++++++++++++++--------------------------- 1 file changed, 682 insertions(+), 763 deletions(-) diff --git a/src/port.c b/src/port.c index aab6039..f07c8dc 100644 --- a/src/port.c +++ b/src/port.c @@ -1,5 +1,5 @@ /* Supporting routines which may sometimes be missing. - Copyright (C) 1988, 1992 Free Software Foundation + Copyright (C) 1988 Free Software Foundation This file is part of GNU Tar. @@ -46,32 +46,38 @@ extern long baserec; #ifdef __MSDOS__ char TTY_NAME[] = "con"; +#define MKNOD_MISSING +#define UTILS_MISSING +#define VALLOC_MISSING + #else /* not __MSDOS__ */ -char TTY_NAME[] = "/dev/tty"; +char TTY_NAME[] ="/dev/tty"; + +#define UTILS_MISSING +#define CK_PIPE_MISSING #endif /* not __MSDOS__ */ /* End of system-dependent #ifdefs */ -#ifndef HAVE_VALLOC +#ifdef VALLOC_MISSING /* * valloc() does a malloc() on a page boundary. On some systems, * this can make large block I/O more efficient. */ char * valloc (size) - unsigned size; + unsigned size; { - return (malloc (size)); + return (malloc (size)); } +#endif -#endif /* !HAVE_VALLOC */ - -#ifndef HAVE_MKDIR +#ifdef MKDIR_MISSING /* - * 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 @@ -89,93 +95,85 @@ 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 */ + + default: /* Parent process */ + while (cpid != wait(&status)) ; /* Wait for kid to finish */ + } - if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0) - { - errno = EIO; /* We don't know why, but */ - return -1; /* /bin/mkdir failed */ - } + if (WTERMSIG(status) != 0 || WEXITSTATUS(status) != 0) { + errno = EIO; /* We don't know why, but */ + return -1; /* /bin/mkdir failed */ + } - return 0; + return 0; } int -rmdir (dpath) - char *dpath; +rmdir(dpath) + char *dpath; { - int cpid, status; - struct stat statbuf; - - if (stat (dpath, &statbuf) != 0) - { - /* Stat just set errno. We don't have to */ - return -1; - } + int cpid, status; + struct stat statbuf; - switch (cpid = fork ()) - { + if (stat(dpath,&statbuf) != 0) { + /* Stat just set errno. We don't have to */ + return -1; + } - case -1: /* Error in fork() */ - return (-1); /* Errno is set already */ + switch (cpid = fork()) { - case 0: /* Child process */ - execl ("/bin/rmdir", "rmdir", dpath, (char *) 0); - _exit (-1); /* Can't exec /bin/mkdir */ + case -1: /* Error in fork() */ + return(-1); /* Errno is set already */ - 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 */ + + default: /* Parent process */ + while (cpid != wait(&status)) ; /* Wait for kid to finish */ + } - if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0) - { - errno = EIO; /* We don't know why, but */ - return -1; /* /bin/mkdir failed */ - } + if (WTERMSIG(status) != 0 || WEXITSTATUS(status) != 0) { + errno = EIO; /* We don't know why, but */ + return -1; /* /bin/mkdir failed */ + } - return 0; + return 0; } +#endif -#endif /* !HAVE_MKDIR */ - -#ifndef HAVE_RENAME +#ifdef RENAME_MISSING /* Rename file FROM to file TO. Return 0 if successful, -1 if not. */ @@ -186,49 +184,37 @@ rename (from, to) { struct stat from_stats; - if (stat (from, &from_stats)) - return -1; - - if (unlink (to) && errno != ENOENT) - return -1; - - if (link (from, to)) - return -1; - - if (unlink (from) && errno != ENOENT) + if (stat (from, &from_stats) == 0) { - unlink (to); - return -1; + if (unlink (to) && errno != ENOENT) + return -1; + if (link (from, to) == 0 && (unlink (from) == 0 || errno == ENOENT)) + return 0; } - - return 0; + return -1; } +#endif -#endif /* !HAVE_RENAME */ - -#ifdef minix +#ifdef BZERO_MISSING /* 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; } /* @@ -243,75 +229,66 @@ 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. @@ -323,35 +300,33 @@ 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 */ +#endif #ifdef EMUL_OPEN3 @@ -386,32 +361,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. @@ -419,156 +394,136 @@ open3 (path, 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 -#endif /* EMUL_OPEN3 */ - -#ifndef HAVE_MKNOD +#ifdef MKNOD_MISSING #ifdef __MSDOS__ 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 /* MKNOD_MISSING */ #ifdef __TURBOC__ #include @@ -577,8 +532,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 @@ -617,203 +572,194 @@ utime (char *filename, struct utimbuf *utb) _close (fd); return status; } +#endif -#endif /* __TURBOC__ */ - +#ifdef UTILS_MISSING /* 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; + 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; } - 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; + 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 @@ -825,83 +771,67 @@ ck_close (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; + 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; + } + } } - 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; - } + if(copying) { + *to_there='\0'; + return copy_buf; } - } - if (copying) - { - *to_there = '\0'; - return copy_buf; - } - return (char *) 0; + return (char *)0; } @@ -913,138 +843,134 @@ quote_copy_string (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; } +#endif -void -ck_pipe (pipes) - int *pipes; +#ifdef CK_PIPE_MISSING +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); + } } +#endif + +#ifdef STRSTR_MISSING -#ifndef HAVE_STRSTR /* * strstr - find first occurrence of wanted in s */ 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 -#endif /* !HAVE_STRSTR */ - -#ifndef HAVE_FTRUNCATE +#ifdef FTRUNCATE_MISSING #ifdef F_CHSIZE int @@ -1054,24 +980,23 @@ ftruncate (fd, length) { return fcntl (fd, F_CHSIZE, length); } - -#else /* !F_CHSIZE */ +#else #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. @@ -1079,176 +1004,170 @@ ftruncate (fd, length) * 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 */ +#else 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 */ +#endif +#endif +#endif extern FILE *msg_file; -#if defined (HAVE_VPRINTF) && __STDC__ +#if !defined (VPRINTF_MISSING) && defined (__STDC__) #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 /* not VPRINTF_MISSING or __STDC__ */ -#endif /* HAVE_VPRINTF and __STDC__ */ - -#if defined(HAVE_VPRINTF) && !__STDC__ +#if !defined(VPRINTF_MISSING) && !defined(__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 /* not VPRINTF_MISSING and not __STDC__ */ -#endif /* HAVE_VPRINTF and not __STDC__ */ - -#if !defined(HAVE_VPRINTF) && defined(HAVE_DOPRNT) +#if defined(VPRINTF_MISSING) && !defined(DOPRNT_MISSING) 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 /* VPRINTF_MISSING and not DOPRNT_MISSING */ -#endif /* !HAVE_VPRINTF and HAVE_DOPRNT */ - -#if !defined(HAVE_VPRINTF) && !defined(HAVE_DOPRNT) -void -msg (str, a1, a2, a3, a4, a5, a6) - char *str; +#if defined(VPRINTF_MISSING) && defined(DOPRNT_MISSING) +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 */ +#endif /* VPRINTF_MISSING and DOPRNT_MISSING */ -- 2.45.2