1 /* -*- c-file-style: "linux" -*-
3 * Copyright (C) 1996-2000 by Andrew Tridgell
4 * Copyright (C) Paul Mackerras 1996
5 * Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 * Utilities used in rsync
33 extern int modify_window;
34 extern int relative_paths;
35 extern int human_readable;
36 extern char *partial_dir;
37 extern struct filter_list_struct server_filter_list;
39 int sanitize_paths = 0;
44 * Set a fd into nonblocking mode
46 void set_nonblocking(int fd)
50 if ((val = fcntl(fd, F_GETFL, 0)) == -1)
52 if (!(val & NONBLOCK_FLAG)) {
54 fcntl(fd, F_SETFL, val);
59 * Set a fd into blocking mode
61 void set_blocking(int fd)
65 if ((val = fcntl(fd, F_GETFL, 0)) == -1)
67 if (val & NONBLOCK_FLAG) {
68 val &= ~NONBLOCK_FLAG;
69 fcntl(fd, F_SETFL, val);
75 * Create a file descriptor pair - like pipe() but use socketpair if
76 * possible (because of blocking issues on pipes).
78 * Always set non-blocking.
80 int fd_pair(int fd[2])
84 #ifdef HAVE_SOCKETPAIR
85 ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
91 set_nonblocking(fd[0]);
92 set_nonblocking(fd[1]);
99 void print_child_argv(char **cmd)
101 rprintf(FINFO, "opening connection using ");
102 for (; *cmd; cmd++) {
103 /* Look for characters that ought to be quoted. This
104 * is not a great quoting algorithm, but it's
105 * sufficient for a log message. */
106 if (strspn(*cmd, "abcdefghijklmnopqrstuvwxyz"
107 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
109 ",.-_=+@/") != strlen(*cmd)) {
110 rprintf(FINFO, "\"%s\" ", safe_fname(*cmd));
112 rprintf(FINFO, "%s ", safe_fname(*cmd));
115 rprintf(FINFO, "\n");
119 void out_of_memory(char *str)
121 rprintf(FERROR, "ERROR: out of memory in %s\n", str);
122 exit_cleanup(RERR_MALLOC);
125 void overflow_exit(char *str)
127 rprintf(FERROR, "ERROR: buffer overflow in %s\n", str);
128 exit_cleanup(RERR_MALLOC);
133 int set_modtime(char *fname, time_t modtime, mode_t mode)
135 #if !defined HAVE_LUTIMES || !defined HAVE_UTIMES
141 rprintf(FINFO, "set modtime of %s to (%ld) %s",
142 safe_fname(fname), (long)modtime,
143 asctime(localtime(&modtime)));
152 t[0].tv_sec = time(NULL);
154 t[1].tv_sec = modtime;
158 return lutimes(fname, t);
160 return utimes(fname, t);
161 #elif defined HAVE_UTIMBUF
163 tbuf.actime = time(NULL);
164 tbuf.modtime = modtime;
165 return utime(fname,&tbuf);
166 #elif defined HAVE_UTIME
170 return utime(fname,t);
172 #error No file-time-modification routine found!
179 Create any necessary directories in fname. Unfortunately we don't know
180 what perms to give the directory when this is called so we need to rely
183 int create_directory_path(char *fname, int base_umask)
187 while (*fname == '/')
189 while (strncmp(fname, "./", 2) == 0)
193 while ((p = strchr(p,'/')) != NULL) {
195 do_mkdir(fname, 0777 & ~base_umask);
204 * Write @p len bytes at @p ptr to descriptor @p desc, retrying if
207 * @retval len upon success
209 * @retval <0 write's (negative) error code
211 * Derived from GNU C's cccp.c.
213 int full_write(int desc, char *ptr, size_t len)
219 int written = write(desc, ptr, len);
225 total_written += written;
229 return total_written;
234 * Read @p len bytes at @p ptr from descriptor @p desc, retrying if
237 * @retval >0 the actual number of bytes read
241 * @retval <0 for an error.
243 * Derived from GNU C's cccp.c. */
244 static int safe_read(int desc, char *ptr, size_t len)
252 n_chars = read(desc, ptr, len);
253 } while (n_chars < 0 && errno == EINTR);
261 * This is used in conjunction with the --temp-dir, --backup, and
262 * --copy-dest options. */
263 int copy_file(char *source, char *dest, mode_t mode)
268 int len; /* Number of bytes read into `buf'. */
270 ifd = do_open(source, O_RDONLY, 0);
272 rsyserr(FERROR, errno, "open %s", full_fname(source));
276 if (robust_unlink(dest) && errno != ENOENT) {
277 rsyserr(FERROR, errno, "unlink %s", full_fname(dest));
281 ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
283 rsyserr(FERROR, errno, "open %s", full_fname(dest));
288 while ((len = safe_read(ifd, buf, sizeof buf)) > 0) {
289 if (full_write(ofd, buf, len) < 0) {
290 rsyserr(FERROR, errno, "write %s", full_fname(dest));
298 rsyserr(FERROR, errno, "read %s", full_fname(source));
304 if (close(ifd) < 0) {
305 rsyserr(FINFO, errno, "close failed on %s",
309 if (close(ofd) < 0) {
310 rsyserr(FERROR, errno, "close failed on %s",
318 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
319 #define MAX_RENAMES_DIGITS 3
320 #define MAX_RENAMES 1000
323 * Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
324 * rename to <path>/.rsyncNNN instead.
326 * Note that successive rsync runs will shuffle the filenames around a
327 * bit as long as the file is still busy; this is because this function
328 * does not know if the unlink call is due to a new file coming in, or
329 * --delete trying to remove old .rsyncNNN files, hence it renames it
332 int robust_unlink(char *fname)
335 return do_unlink(fname);
337 static int counter = 1;
339 char path[MAXPATHLEN];
341 rc = do_unlink(fname);
342 if (rc == 0 || errno != ETXTBSY)
345 if ((pos = strlcpy(path, fname, MAXPATHLEN)) >= MAXPATHLEN)
346 pos = MAXPATHLEN - 1;
348 while (pos > 0 && path[pos-1] != '/')
350 pos += strlcpy(path+pos, ".rsync", MAXPATHLEN-pos);
352 if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
357 /* start where the last one left off to reduce chance of clashes */
360 sprintf(&path[pos], "%03d", counter);
361 if (++counter >= MAX_RENAMES)
363 } while ((rc = access(path, 0)) == 0 && counter != start);
366 rprintf(FINFO,"renaming %s to %s because of text busy\n",
367 safe_fname(fname), safe_fname(path));
370 /* maybe we should return rename()'s exit status? Nah. */
371 if (do_rename(fname, path) != 0) {
379 /* Returns 0 on successful rename, 1 if we successfully copied the file
380 * across filesystems, -2 if copy_file() failed, and -1 on other errors. */
381 int robust_rename(char *from, char *to, int mode)
386 if (do_rename(from, to) == 0)
392 if (robust_unlink(to) != 0)
397 if (copy_file(from, to, mode) != 0)
409 static pid_t all_pids[10];
412 /** Fork and record the pid of the child. **/
415 pid_t newpid = fork();
417 if (newpid != 0 && newpid != -1) {
418 all_pids[num_pids++] = newpid;
426 * @todo It would be kind of nice to make sure that they are actually
427 * all our children before we kill them, because their pids may have
428 * been recycled by some other process. Perhaps when we wait for a
429 * child, we should remove it from this array. Alternatively we could
430 * perhaps use process groups, but I think that would not work on
431 * ancient Unix versions that don't support them.
433 void kill_all(int sig)
437 for (i = 0; i < num_pids; i++) {
438 /* Let's just be a little careful where we
439 * point that gun, hey? See kill(2) for the
440 * magic caused by negative values. */
441 pid_t p = all_pids[i];
453 /** Turn a user name into a uid */
454 int name_to_uid(char *name, uid_t *uid)
459 pass = getpwnam(name);
467 /** Turn a group name into a gid */
468 int name_to_gid(char *name, gid_t *gid)
473 grp = getgrnam(name);
482 /** Lock a byte range in a open file */
483 int lock_range(int fd, int offset, int len)
487 lock.l_type = F_WRLCK;
488 lock.l_whence = SEEK_SET;
489 lock.l_start = offset;
493 return fcntl(fd,F_SETLK,&lock) == 0;
496 static int filter_server_path(char *arg)
500 if (server_filter_list.head) {
501 for (s = arg; (s = strchr(s, '/')) != NULL; ) {
503 if (check_filter(&server_filter_list, arg, 1) < 0) {
504 /* We must leave arg truncated! */
513 static void glob_expand_one(char *s, char ***argv_ptr, int *argc_ptr,
516 char **argv = *argv_ptr;
517 int argc = *argc_ptr;
518 int maxargs = *maxargs_ptr;
519 #if !defined HAVE_GLOB || !defined HAVE_GLOB_H
520 if (argc == maxargs) {
522 if (!(argv = realloc_array(argv, char *, maxargs)))
523 out_of_memory("glob_expand_one");
525 *maxargs_ptr = maxargs;
529 s = argv[argc++] = strdup(s);
530 filter_server_path(s);
540 s = sanitize_path(NULL, s, "", 0);
544 memset(&globbuf, 0, sizeof globbuf);
545 if (!filter_server_path(s))
546 glob(s, 0, NULL, &globbuf);
547 if (MAX((int)globbuf.gl_pathc, 1) > maxargs - argc) {
548 maxargs += globbuf.gl_pathc + MAX_ARGS;
549 if (!(argv = realloc_array(argv, char *, maxargs)))
550 out_of_memory("glob_expand_one");
552 *maxargs_ptr = maxargs;
554 if (globbuf.gl_pathc == 0)
559 for (i = 0; i < (int)globbuf.gl_pathc; i++) {
560 if (!(argv[argc++] = strdup(globbuf.gl_pathv[i])))
561 out_of_memory("glob_expand_one");
569 /* This routine is only used in daemon mode. */
570 void glob_expand(char *base1, char ***argv_ptr, int *argc_ptr, int *maxargs_ptr)
572 char *s = (*argv_ptr)[*argc_ptr];
575 int base_len = strlen(base);
580 if (strncmp(s, base, base_len) == 0)
583 if (!(s = strdup(s)))
584 out_of_memory("glob_expand");
586 if (asprintf(&base," %s/", base1) <= 0)
587 out_of_memory("glob_expand");
590 for (q = s; *q; q = p + base_len) {
591 if ((p = strstr(q, base)) != NULL)
592 *p = '\0'; /* split it at this point */
593 glob_expand_one(q, argv_ptr, argc_ptr, maxargs_ptr);
603 * Convert a string to lower case
605 void strlower(char *s)
608 if (isupper(*(unsigned char *)s))
609 *s = tolower(*(unsigned char *)s);
614 /* Join strings p1 & p2 into "dest" with a guaranteed '/' between them. (If
615 * p1 ends with a '/', no extra '/' is inserted.) Returns the length of both
616 * strings + 1 (if '/' was inserted), regardless of whether the null-terminated
617 * string fits into destsize. */
618 size_t pathjoin(char *dest, size_t destsize, const char *p1, const char *p2)
620 size_t len = strlcpy(dest, p1, destsize);
621 if (len < destsize - 1) {
622 if (!len || dest[len-1] != '/')
624 if (len < destsize - 1)
625 len += strlcpy(dest + len, p2, destsize - len);
632 len += strlen(p2) + 1; /* Assume we'd insert a '/'. */
636 /* Join any number of strings together, putting them in "dest". The return
637 * value is the length of all the strings, regardless of whether the null-
638 * terminated whole fits in destsize. Your list of string pointers must end
639 * with a NULL to indicate the end of the list. */
640 size_t stringjoin(char *dest, size_t destsize, ...)
646 va_start(ap, destsize);
648 if (!(src = va_arg(ap, const char *)))
655 memcpy(dest, src, len);
666 int count_dir_elements(const char *p)
668 int cnt = 0, new_component = 1;
672 else if (new_component) {
680 /* Turns multiple adjacent slashes into a single slash, gets rid of "./"
681 * elements (but not a trailing dot dir), removes a trailing slash, and
682 * optionally collapses ".." elements (except for those at the start of the
683 * string). If the resulting name would be empty, change it into a ".". */
684 unsigned int clean_fname(char *name, BOOL collapse_dot_dot)
686 char *limit = name - 1, *t = name, *f = name;
692 if ((anchored = *f == '/') != 0)
695 /* discard extra slashes */
701 /* discard "." dirs (but NOT a trailing '.'!) */
706 /* collapse ".." dirs */
708 && f[1] == '.' && (f[2] == '/' || !f[2])) {
710 if (s == name && anchored) {
714 while (s > limit && *--s != '/') {}
715 if (s != t - 1 && (s < name || *s == '/')) {
723 while (*f && (*t++ = *f++) != '/') {}
726 if (t > name+anchored && t[-1] == '/')
735 /* Make path appear as if a chroot had occurred. This handles a leading
736 * "/" (either removing it or expanding it) and any leading or embedded
737 * ".." components that attempt to escape past the module's top dir.
739 * If dest is NULL, a buffer is allocated to hold the result. It is legal
740 * to call with the dest and the path (p) pointing to the same buffer, but
741 * rootdir will be ignored to avoid expansion of the string.
743 * The rootdir string contains a value to use in place of a leading slash.
744 * Specify NULL to get the default of lp_path(module_id).
746 * If depth is >= 0, it is a count of how many '..'s to allow at the start
747 * of the path. Use -1 to allow unlimited depth.
749 * We also clean the path in a manner similar to clean_fname() but with a
752 * Turns multiple adjacent slashes into a single slash, gets rid of "." dir
753 * elements (INCLUDING a trailing dot dir), PRESERVES a trailing slash, and
754 * ALWAYS collapses ".." elements (except for those at the start of the
755 * string up to "depth" deep). If the resulting name would be empty,
756 * change it into a ".". */
757 char *sanitize_path(char *dest, const char *p, const char *rootdir, int depth)
760 int rlen = 0, leave_one_dotdir = relative_paths;
763 int plen = strlen(p);
766 rootdir = lp_path(module_id);
767 rlen = strlen(rootdir);
772 if (rlen + plen + 1 >= MAXPATHLEN)
774 } else if (!(dest = new_array(char, rlen + plen + 1)))
775 out_of_memory("sanitize_path");
777 memcpy(dest, rootdir, rlen);
783 start = sanp = dest + rlen;
785 /* discard leading or extra slashes */
790 /* this loop iterates once per filename component in p.
791 * both p (and sanp if the original had a slash) should
792 * always be left pointing after a slash
794 if (*p == '.' && (p[1] == '/' || p[1] == '\0')) {
795 if (leave_one_dotdir && p[1])
796 leave_one_dotdir = 0;
798 /* skip "." component */
803 if (*p == '.' && p[1] == '.' && (p[2] == '/' || p[2] == '\0')) {
804 /* ".." component followed by slash or end */
805 if (depth <= 0 || sanp != start) {
808 /* back up sanp one level */
809 --sanp; /* now pointing at slash */
810 while (sanp > start && sanp[-1] != '/') {
811 /* skip back up to slash */
817 /* allow depth levels of .. at the beginning */
819 /* move the virtual beginning to leave the .. alone */
822 /* copy one component through next slash */
823 while (*p && (*sanp++ = *p++) != '/') {}
826 /* ended up with nothing, so put in "." component */
834 char curr_dir[MAXPATHLEN];
835 unsigned int curr_dir_len;
838 * Like chdir(), but it keeps track of the current directory (in the
839 * global "curr_dir"), and ensures that the path size doesn't overflow.
840 * Also cleans the path using the clean_fname() function.
842 int push_dir(char *dir)
844 static int initialised;
849 getcwd(curr_dir, sizeof curr_dir - 1);
850 curr_dir_len = strlen(curr_dir);
853 if (!dir) /* this call was probably just to initialize */
857 if (len == 1 && *dir == '.')
860 if ((*dir == '/' ? len : curr_dir_len + 1 + len) >= sizeof curr_dir)
867 memcpy(curr_dir, dir, len + 1);
870 curr_dir[curr_dir_len++] = '/';
871 memcpy(curr_dir + curr_dir_len, dir, len + 1);
875 curr_dir_len = clean_fname(curr_dir, 1);
881 * Reverse a push_dir() call. You must pass in an absolute path
882 * that was copied from a prior value of "curr_dir".
884 int pop_dir(char *dir)
889 curr_dir_len = strlcpy(curr_dir, dir, sizeof curr_dir);
890 if (curr_dir_len >= sizeof curr_dir)
891 curr_dir_len = sizeof curr_dir - 1;
896 /* Return the filename, turning any non-printable characters into escaped
897 * characters (e.g. \n -> \012, \ -> \\). This ensures that outputting it
898 * cannot generate an empty line nor corrupt the screen. This function can
899 * return only MAX_SAFE_NAMES values at a time! The returned value can be
900 * longer than MAXPATHLEN (because we may be trying to output an error about
901 * a too-long filename)! */
902 char *safe_fname(const char *fname)
904 #define MAX_SAFE_NAMES 4
905 static char fbuf[MAX_SAFE_NAMES][MAXPATHLEN*2];
907 int limit = sizeof fbuf / MAX_SAFE_NAMES - 1;
910 ndx = (ndx + 1) % MAX_SAFE_NAMES;
911 for (t = fbuf[ndx]; *fname; fname++) {
912 if (*fname == '\\') {
913 if ((limit -= 2) < 0)
917 } else if (!isprint(*(uchar*)fname)) {
918 if ((limit -= 4) < 0)
920 sprintf(t, "\\%03o", *(uchar*)fname);
934 * Return a quoted string with the full pathname of the indicated filename.
935 * The string " (in MODNAME)" may also be appended. The returned pointer
936 * remains valid until the next time full_fname() is called.
938 char *full_fname(const char *fn)
940 static char *result = NULL;
952 for (p2 = p1; *p2 == '/'; p2++) {}
956 if (module_id >= 0) {
958 m2 = lp_name(module_id);
960 if (p1 == curr_dir) {
961 if (!lp_use_chroot(module_id)) {
962 char *p = lp_path(module_id);
963 if (*p != '/' || p[1])
970 asprintf(&result, "\"%s%s%s\"%s%s%s", p1, p2, fn, m1, m2, m3);
975 static char partial_fname[MAXPATHLEN];
977 char *partial_dir_fname(const char *fname)
979 char *t = partial_fname;
980 int sz = sizeof partial_fname;
983 if ((fn = strrchr(fname, '/')) != NULL) {
985 if (*partial_dir != '/') {
986 int len = fn - fname;
987 strncpy(t, fname, len); /* safe */
993 if ((int)pathjoin(t, sz, partial_dir, fn) >= sz)
995 if (server_filter_list.head) {
998 len = strlen(partial_dir);
1000 if (check_filter(&server_filter_list, partial_fname, 1) < 0)
1003 if (check_filter(&server_filter_list, partial_fname, 0) < 0)
1007 return partial_fname;
1010 /* If no --partial-dir option was specified, we don't need to do anything
1011 * (the partial-dir is essentially '.'), so just return success. */
1012 int handle_partial_dir(const char *fname, int create)
1016 if (fname != partial_fname)
1018 if (!create && *partial_dir == '/')
1020 if (!(fn = strrchr(partial_fname, '/')))
1024 dir = partial_fname;
1027 int statret = do_lstat(dir, &st);
1028 if (statret == 0 && !S_ISDIR(st.st_mode)) {
1029 if (do_unlink(dir) < 0)
1033 if (statret < 0 && do_mkdir(dir, 0700) < 0)
1042 /** We need to supply our own strcmp function for file list comparisons
1043 to ensure that signed/unsigned usage is consistent between machines. */
1044 int u_strcmp(const char *cs1, const char *cs2)
1046 const uchar *s1 = (const uchar *)cs1;
1047 const uchar *s2 = (const uchar *)cs2;
1049 while (*s1 && *s2 && (*s1 == *s2)) {
1053 return (int)*s1 - (int)*s2;
1059 * Determine if a symlink points outside the current directory tree.
1060 * This is considered "unsafe" because e.g. when mirroring somebody
1061 * else's machine it might allow them to establish a symlink to
1062 * /etc/passwd, and then read it through a web server.
1064 * Null symlinks and absolute symlinks are always unsafe.
1066 * Basically here we are concerned with symlinks whose target contains
1067 * "..", because this might cause us to walk back up out of the
1068 * transferred directory. We are not allowed to go back up and
1071 * @param dest Target of the symlink in question.
1073 * @param src Top source directory currently applicable. Basically this
1074 * is the first parameter to rsync in a simple invocation, but it's
1075 * modified by flist.c in slightly complex ways.
1077 * @retval True if unsafe
1078 * @retval False is unsafe
1082 int unsafe_symlink(const char *dest, const char *src)
1084 const char *name, *slash;
1087 /* all absolute and null symlinks are unsafe */
1088 if (!dest || !*dest || *dest == '/')
1091 /* find out what our safety margin is */
1092 for (name = src; (slash = strchr(name, '/')) != 0; name = slash+1) {
1093 if (strncmp(name, "../", 3) == 0) {
1095 } else if (strncmp(name, "./", 2) == 0) {
1101 if (strcmp(name, "..") == 0)
1104 for (name = dest; (slash = strchr(name, '/')) != 0; name = slash+1) {
1105 if (strncmp(name, "../", 3) == 0) {
1106 /* if at any point we go outside the current directory
1107 then stop - it is unsafe */
1110 } else if (strncmp(name, "./", 2) == 0) {
1116 if (strcmp(name, "..") == 0)
1122 /* Return the int64 number as a string. If the --human-readable option was
1123 * specified, we may output the number in K, M, or G units. We can return
1124 * up to 4 buffers at a time. */
1125 char *human_num(int64 num)
1127 static char bufs[4][128]; /* more than enough room */
1128 static unsigned int n;
1131 n = (n + 1) % (sizeof bufs / sizeof bufs[0]);
1133 if (human_readable) {
1135 int mult = human_readable == 1 ? 1024 : 1000;
1137 if (num > mult*mult*mult) {
1138 dnum = (double)num / (mult*mult*mult);
1140 } else if (num > mult*mult) {
1141 dnum = (double)num / (mult*mult);
1143 } else if (num > mult) {
1144 dnum = (double)num / mult;
1148 sprintf(bufs[n], "%.2f%c", dnum, units);
1153 s = bufs[n] + sizeof bufs[0] - 1;
1159 *--s = (num % 10) + '0';
1165 /* Return the double number as a string. If the --human-readable option was
1166 * specified, we may output the number in K, M, or G units. We use a buffer
1167 * from human_num() to return our result. */
1168 char *human_dnum(double dnum, int decimal_digits)
1170 char *buf = human_num(dnum);
1171 int len = strlen(buf);
1172 if (isdigit(*(uchar*)(buf+len-1))) {
1173 /* There's extra room in buf prior to the start of the num. */
1174 buf -= decimal_digits + 1;
1175 snprintf(buf, len + decimal_digits + 2, "%.*f", decimal_digits, dnum);
1181 * Return the date and time as a string
1183 char *timestring(time_t t)
1185 static char TimeBuf[200];
1186 struct tm *tm = localtime(&t);
1188 #ifdef HAVE_STRFTIME
1189 strftime(TimeBuf, sizeof TimeBuf - 1, "%Y/%m/%d %H:%M:%S", tm);
1191 strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
1194 if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
1195 TimeBuf[strlen(TimeBuf)-1] = 0;
1203 * Sleep for a specified number of milliseconds.
1205 * Always returns TRUE. (In the future it might return FALSE if
1211 struct timeval tval, t1, t2;
1213 gettimeofday(&t1, NULL);
1216 tval.tv_sec = (t-tdiff)/1000;
1217 tval.tv_usec = 1000*((t-tdiff)%1000);
1220 select(0,NULL,NULL, NULL, &tval);
1222 gettimeofday(&t2, NULL);
1223 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1224 (t2.tv_usec - t1.tv_usec)/1000;
1232 * Determine if two file modification times are equivalent (either
1233 * exact or in the modification timestamp window established by
1236 * @retval 0 if the times should be treated as the same
1238 * @retval +1 if the first is later
1240 * @retval -1 if the 2nd is later
1242 int cmp_modtime(time_t file1, time_t file2)
1244 if (file2 > file1) {
1245 if (file2 - file1 <= modify_window)
1249 if (file1 - file2 <= modify_window)
1259 This routine is a trick to immediately catch errors when debugging
1260 with insure. A xterm with a gdb is popped up when insure catches
1261 a error. It is Linux specific.
1263 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1269 asprintf(&cmd, "/usr/X11R6/bin/xterm -display :0 -T Panic -n Panic -e /bin/sh -c 'cat /tmp/ierrs.*.%d ; gdb /proc/%d/exe %d'",
1270 getpid(), getpid(), getpid());
1274 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1275 fn = dlsym(h, "_Insure_trap_error");
1278 ret = fn(a1, a2, a3, a4, a5, a6);
1289 #define MALLOC_MAX 0x40000000
1291 void *_new_array(unsigned int size, unsigned long num)
1293 if (num >= MALLOC_MAX/size)
1295 return malloc(size * num);
1298 void *_realloc_array(void *ptr, unsigned int size, unsigned long num)
1300 if (num >= MALLOC_MAX/size)
1302 /* No realloc should need this, but just in case... */
1304 return malloc(size * num);
1305 return realloc(ptr, size * num);
1308 /* Take a filename and filename length and return the most significant
1309 * filename suffix we can find. This ignores suffixes such as "~",
1310 * ".bak", ".orig", ".~1~", etc. */
1311 const char *find_filename_suffix(const char *fn, int fn_len, int *len_ptr)
1313 const char *suf, *s;
1317 /* One or more dots at the start aren't a suffix. */
1318 while (fn_len && *fn == '.') fn++, fn_len--;
1320 /* Ignore the ~ in a "foo~" filename. */
1321 if (fn_len > 1 && fn[fn_len-1] == '~')
1322 fn_len--, had_tilde = True;
1326 /* Assume we don't find an suffix. */
1330 /* Find the last significant suffix. */
1331 for (s = fn + fn_len; fn_len > 1; ) {
1332 while (*--s != '.' && s != fn) {}
1335 s_len = fn_len - (s - fn);
1338 if (strcmp(s+1, "bak") == 0
1339 || strcmp(s+1, "old") == 0)
1341 } else if (s_len == 5) {
1342 if (strcmp(s+1, "orig") == 0)
1344 } else if (s_len > 2 && had_tilde
1345 && s[1] == '~' && isdigit(*(uchar*)(s+2)))
1351 /* Determine if the suffix is all digits. */
1352 for (s++, s_len--; s_len > 0; s++, s_len--) {
1353 if (!isdigit(*(uchar*)s))
1356 /* An all-digit suffix may not be that signficant. */
1363 /* This is an implementation of the Levenshtein distance algorithm. It
1364 * was implemented to avoid needing a two-dimensional matrix (to save
1365 * memory). It was also tweaked to try to factor in the ASCII distance
1366 * between changed characters as a minor distance quantity. The normal
1367 * Levenshtein units of distance (each signifying a single change between
1368 * the two strings) are defined as a "UNIT". */
1370 #define UNIT (1 << 16)
1372 uint32 fuzzy_distance(const char *s1, int len1, const char *s2, int len2)
1374 uint32 a[MAXPATHLEN], diag, above, left, diag_inc, above_inc, left_inc;
1378 if (!len1 || !len2) {
1383 for (i1 = 0, cost = 0; i1 < len1; i1++)
1385 return (int32)len1 * UNIT + cost;
1388 for (i2 = 0; i2 < len2; i2++)
1389 a[i2] = (i2+1) * UNIT;
1391 for (i1 = 0; i1 < len1; i1++) {
1393 above = (i1+1) * UNIT;
1394 for (i2 = 0; i2 < len2; i2++) {
1396 if ((cost = *((uchar*)s1+i1) - *((uchar*)s2+i2)) != 0) {
1402 diag_inc = diag + cost;
1403 left_inc = left + UNIT + *((uchar*)s1+i1);
1404 above_inc = above + UNIT + *((uchar*)s2+i2);
1405 a[i2] = above = left < above
1406 ? (left_inc < diag_inc ? left_inc : diag_inc)
1407 : (above_inc < diag_inc ? above_inc : diag_inc);