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 char *partial_dir;
36 extern struct filter_list_struct server_filter_list;
38 int sanitize_paths = 0;
43 * Set a fd into nonblocking mode
45 void set_nonblocking(int fd)
49 if ((val = fcntl(fd, F_GETFL, 0)) == -1)
51 if (!(val & NONBLOCK_FLAG)) {
53 fcntl(fd, F_SETFL, val);
58 * Set a fd into blocking mode
60 void set_blocking(int fd)
64 if ((val = fcntl(fd, F_GETFL, 0)) == -1)
66 if (val & NONBLOCK_FLAG) {
67 val &= ~NONBLOCK_FLAG;
68 fcntl(fd, F_SETFL, val);
74 * Create a file descriptor pair - like pipe() but use socketpair if
75 * possible (because of blocking issues on pipes).
77 * Always set non-blocking.
79 int fd_pair(int fd[2])
83 #ifdef HAVE_SOCKETPAIR
84 ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
90 set_nonblocking(fd[0]);
91 set_nonblocking(fd[1]);
98 void print_child_argv(char **cmd)
100 rprintf(FINFO, "opening connection using ");
101 for (; *cmd; cmd++) {
102 /* Look for characters that ought to be quoted. This
103 * is not a great quoting algorithm, but it's
104 * sufficient for a log message. */
105 if (strspn(*cmd, "abcdefghijklmnopqrstuvwxyz"
106 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
108 ",.-_=+@/") != strlen(*cmd)) {
109 rprintf(FINFO, "\"%s\" ", safe_fname(*cmd));
111 rprintf(FINFO, "%s ", safe_fname(*cmd));
114 rprintf(FINFO, "\n");
118 void out_of_memory(char *str)
120 rprintf(FERROR, "ERROR: out of memory in %s\n", str);
121 exit_cleanup(RERR_MALLOC);
124 void overflow_exit(char *str)
126 rprintf(FERROR, "ERROR: buffer overflow in %s\n", str);
127 exit_cleanup(RERR_MALLOC);
132 int set_modtime(char *fname, time_t modtime, mode_t mode)
134 #if !defined HAVE_LUTIMES || !defined HAVE_UTIMES
140 rprintf(FINFO, "set modtime of %s to (%ld) %s",
141 safe_fname(fname), (long)modtime,
142 asctime(localtime(&modtime)));
151 t[0].tv_sec = time(NULL);
153 t[1].tv_sec = modtime;
157 return lutimes(fname, t);
159 return utimes(fname, t);
160 #elif defined HAVE_UTIMBUF
162 tbuf.actime = time(NULL);
163 tbuf.modtime = modtime;
164 return utime(fname,&tbuf);
165 #elif defined HAVE_UTIME
169 return utime(fname,t);
171 #error No file-time-modification routine found!
178 Create any necessary directories in fname. Unfortunately we don't know
179 what perms to give the directory when this is called so we need to rely
182 int create_directory_path(char *fname, int base_umask)
186 while (*fname == '/')
188 while (strncmp(fname, "./", 2) == 0)
192 while ((p = strchr(p,'/')) != NULL) {
194 do_mkdir(fname, 0777 & ~base_umask);
203 * Write @p len bytes at @p ptr to descriptor @p desc, retrying if
206 * @retval len upon success
208 * @retval <0 write's (negative) error code
210 * Derived from GNU C's cccp.c.
212 int full_write(int desc, char *ptr, size_t len)
218 int written = write(desc, ptr, len);
224 total_written += written;
228 return total_written;
233 * Read @p len bytes at @p ptr from descriptor @p desc, retrying if
236 * @retval >0 the actual number of bytes read
240 * @retval <0 for an error.
242 * Derived from GNU C's cccp.c. */
243 static int safe_read(int desc, char *ptr, size_t len)
251 n_chars = read(desc, ptr, len);
252 } while (n_chars < 0 && errno == EINTR);
260 * This is used in conjunction with the --temp-dir, --backup, and
261 * --copy-dest options. */
262 int copy_file(char *source, char *dest, mode_t mode)
267 int len; /* Number of bytes read into `buf'. */
269 ifd = do_open(source, O_RDONLY, 0);
271 rsyserr(FERROR, errno, "open %s", full_fname(source));
275 if (robust_unlink(dest) && errno != ENOENT) {
276 rsyserr(FERROR, errno, "unlink %s", full_fname(dest));
280 ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
282 rsyserr(FERROR, errno, "open %s", full_fname(dest));
287 while ((len = safe_read(ifd, buf, sizeof buf)) > 0) {
288 if (full_write(ofd, buf, len) < 0) {
289 rsyserr(FERROR, errno, "write %s", full_fname(dest));
297 rsyserr(FERROR, errno, "read %s", full_fname(source));
303 if (close(ifd) < 0) {
304 rsyserr(FINFO, errno, "close failed on %s",
308 if (close(ofd) < 0) {
309 rsyserr(FERROR, errno, "close failed on %s",
317 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
318 #define MAX_RENAMES_DIGITS 3
319 #define MAX_RENAMES 1000
322 * Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
323 * rename to <path>/.rsyncNNN instead.
325 * Note that successive rsync runs will shuffle the filenames around a
326 * bit as long as the file is still busy; this is because this function
327 * does not know if the unlink call is due to a new file coming in, or
328 * --delete trying to remove old .rsyncNNN files, hence it renames it
331 int robust_unlink(char *fname)
334 return do_unlink(fname);
336 static int counter = 1;
338 char path[MAXPATHLEN];
340 rc = do_unlink(fname);
341 if (rc == 0 || errno != ETXTBSY)
344 if ((pos = strlcpy(path, fname, MAXPATHLEN)) >= MAXPATHLEN)
345 pos = MAXPATHLEN - 1;
347 while (pos > 0 && path[pos-1] != '/')
349 pos += strlcpy(path+pos, ".rsync", MAXPATHLEN-pos);
351 if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
356 /* start where the last one left off to reduce chance of clashes */
359 sprintf(&path[pos], "%03d", counter);
360 if (++counter >= MAX_RENAMES)
362 } while ((rc = access(path, 0)) == 0 && counter != start);
365 rprintf(FINFO,"renaming %s to %s because of text busy\n",
366 safe_fname(fname), safe_fname(path));
369 /* maybe we should return rename()'s exit status? Nah. */
370 if (do_rename(fname, path) != 0) {
378 /* Returns 0 on successful rename, 1 if we successfully copied the file
379 * across filesystems, -2 if copy_file() failed, and -1 on other errors. */
380 int robust_rename(char *from, char *to, int mode)
385 if (do_rename(from, to) == 0)
391 if (robust_unlink(to) != 0)
396 if (copy_file(from, to, mode) != 0)
408 static pid_t all_pids[10];
411 /** Fork and record the pid of the child. **/
414 pid_t newpid = fork();
416 if (newpid != 0 && newpid != -1) {
417 all_pids[num_pids++] = newpid;
425 * @todo It would be kind of nice to make sure that they are actually
426 * all our children before we kill them, because their pids may have
427 * been recycled by some other process. Perhaps when we wait for a
428 * child, we should remove it from this array. Alternatively we could
429 * perhaps use process groups, but I think that would not work on
430 * ancient Unix versions that don't support them.
432 void kill_all(int sig)
436 for (i = 0; i < num_pids; i++) {
437 /* Let's just be a little careful where we
438 * point that gun, hey? See kill(2) for the
439 * magic caused by negative values. */
440 pid_t p = all_pids[i];
452 /** Turn a user name into a uid */
453 int name_to_uid(char *name, uid_t *uid)
458 pass = getpwnam(name);
466 /** Turn a group name into a gid */
467 int name_to_gid(char *name, gid_t *gid)
472 grp = getgrnam(name);
481 /** Lock a byte range in a open file */
482 int lock_range(int fd, int offset, int len)
486 lock.l_type = F_WRLCK;
487 lock.l_whence = SEEK_SET;
488 lock.l_start = offset;
492 return fcntl(fd,F_SETLK,&lock) == 0;
495 static int filter_server_path(char *arg)
499 if (server_filter_list.head) {
500 for (s = arg; (s = strchr(s, '/')) != NULL; ) {
502 if (check_filter(&server_filter_list, arg, 1) < 0) {
503 /* We must leave arg truncated! */
512 static void glob_expand_one(char *s, char ***argv_ptr, int *argc_ptr,
515 char **argv = *argv_ptr;
516 int argc = *argc_ptr;
517 int maxargs = *maxargs_ptr;
518 #if !defined HAVE_GLOB || !defined HAVE_GLOB_H
519 if (argc == maxargs) {
521 if (!(argv = realloc_array(argv, char *, maxargs)))
522 out_of_memory("glob_expand_one");
524 *maxargs_ptr = maxargs;
528 s = argv[argc++] = strdup(s);
529 filter_server_path(s);
539 s = sanitize_path(NULL, s, "", 0);
543 memset(&globbuf, 0, sizeof globbuf);
544 if (!filter_server_path(s))
545 glob(s, 0, NULL, &globbuf);
546 if (MAX((int)globbuf.gl_pathc, 1) > maxargs - argc) {
547 maxargs += globbuf.gl_pathc + MAX_ARGS;
548 if (!(argv = realloc_array(argv, char *, maxargs)))
549 out_of_memory("glob_expand_one");
551 *maxargs_ptr = maxargs;
553 if (globbuf.gl_pathc == 0)
558 for (i = 0; i < (int)globbuf.gl_pathc; i++) {
559 if (!(argv[argc++] = strdup(globbuf.gl_pathv[i])))
560 out_of_memory("glob_expand_one");
568 /* This routine is only used in daemon mode. */
569 void glob_expand(char *base1, char ***argv_ptr, int *argc_ptr, int *maxargs_ptr)
571 char *s = (*argv_ptr)[*argc_ptr];
574 int base_len = strlen(base);
579 if (strncmp(s, base, base_len) == 0)
582 if (!(s = strdup(s)))
583 out_of_memory("glob_expand");
585 if (asprintf(&base," %s/", base1) <= 0)
586 out_of_memory("glob_expand");
589 for (q = s; *q; q = p + base_len) {
590 if ((p = strstr(q, base)) != NULL)
591 *p = '\0'; /* split it at this point */
592 glob_expand_one(q, argv_ptr, argc_ptr, maxargs_ptr);
602 * Convert a string to lower case
604 void strlower(char *s)
607 if (isupper(*(unsigned char *)s))
608 *s = tolower(*(unsigned char *)s);
613 /* Join strings p1 & p2 into "dest" with a guaranteed '/' between them. (If
614 * p1 ends with a '/', no extra '/' is inserted.) Returns the length of both
615 * strings + 1 (if '/' was inserted), regardless of whether the null-terminated
616 * string fits into destsize. */
617 size_t pathjoin(char *dest, size_t destsize, const char *p1, const char *p2)
619 size_t len = strlcpy(dest, p1, destsize);
620 if (len < destsize - 1) {
621 if (!len || dest[len-1] != '/')
623 if (len < destsize - 1)
624 len += strlcpy(dest + len, p2, destsize - len);
631 len += strlen(p2) + 1; /* Assume we'd insert a '/'. */
635 /* Join any number of strings together, putting them in "dest". The return
636 * value is the length of all the strings, regardless of whether the null-
637 * terminated whole fits in destsize. Your list of string pointers must end
638 * with a NULL to indicate the end of the list. */
639 size_t stringjoin(char *dest, size_t destsize, ...)
645 va_start(ap, destsize);
647 if (!(src = va_arg(ap, const char *)))
654 memcpy(dest, src, len);
665 int count_dir_elements(const char *p)
667 int cnt = 0, new_component = 1;
671 else if (new_component) {
679 /* Turns multiple adjacent slashes into a single slash, gets rid of "./"
680 * elements (but not a trailing dot dir), removes a trailing slash, and
681 * optionally collapses ".." elements (except for those at the start of the
682 * string). If the resulting name would be empty, change it into a ".". */
683 unsigned int clean_fname(char *name, BOOL collapse_dot_dot)
685 char *limit = name - 1, *t = name, *f = name;
691 if ((anchored = *f == '/') != 0)
694 /* discard extra slashes */
700 /* discard "." dirs (but NOT a trailing '.'!) */
705 /* collapse ".." dirs */
707 && f[1] == '.' && (f[2] == '/' || !f[2])) {
709 if (s == name && anchored) {
713 while (s > limit && *--s != '/') {}
714 if (s != t - 1 && (s < name || *s == '/')) {
722 while (*f && (*t++ = *f++) != '/') {}
725 if (t > name+anchored && t[-1] == '/')
734 /* Make path appear as if a chroot had occurred. This handles a leading
735 * "/" (either removing it or expanding it) and any leading or embedded
736 * ".." components that attempt to escape past the module's top dir.
738 * If dest is NULL, a buffer is allocated to hold the result. It is legal
739 * to call with the dest and the path (p) pointing to the same buffer, but
740 * rootdir will be ignored to avoid expansion of the string.
742 * The rootdir string contains a value to use in place of a leading slash.
743 * Specify NULL to get the default of lp_path(module_id).
745 * If depth is >= 0, it is a count of how many '..'s to allow at the start
746 * of the path. Use -1 to allow unlimited depth.
748 * We also clean the path in a manner similar to clean_fname() but with a
751 * Turns multiple adjacent slashes into a single slash, gets rid of "." dir
752 * elements (INCLUDING a trailing dot dir), PRESERVES a trailing slash, and
753 * ALWAYS collapses ".." elements (except for those at the start of the
754 * string up to "depth" deep). If the resulting name would be empty,
755 * change it into a ".". */
756 char *sanitize_path(char *dest, const char *p, const char *rootdir, int depth)
759 int rlen = 0, leave_one_dotdir = relative_paths;
762 int plen = strlen(p);
765 rootdir = lp_path(module_id);
766 rlen = strlen(rootdir);
771 if (rlen + plen + 1 >= MAXPATHLEN)
773 } else if (!(dest = new_array(char, rlen + plen + 1)))
774 out_of_memory("sanitize_path");
776 memcpy(dest, rootdir, rlen);
782 start = sanp = dest + rlen;
784 /* discard leading or extra slashes */
789 /* this loop iterates once per filename component in p.
790 * both p (and sanp if the original had a slash) should
791 * always be left pointing after a slash
793 if (*p == '.' && (p[1] == '/' || p[1] == '\0')) {
794 if (leave_one_dotdir && p[1])
795 leave_one_dotdir = 0;
797 /* skip "." component */
802 if (*p == '.' && p[1] == '.' && (p[2] == '/' || p[2] == '\0')) {
803 /* ".." component followed by slash or end */
804 if (depth <= 0 || sanp != start) {
807 /* back up sanp one level */
808 --sanp; /* now pointing at slash */
809 while (sanp > start && sanp[-1] != '/') {
810 /* skip back up to slash */
816 /* allow depth levels of .. at the beginning */
818 /* move the virtual beginning to leave the .. alone */
821 /* copy one component through next slash */
822 while (*p && (*sanp++ = *p++) != '/') {}
825 /* ended up with nothing, so put in "." component */
833 char curr_dir[MAXPATHLEN];
834 unsigned int curr_dir_len;
837 * Like chdir(), but it keeps track of the current directory (in the
838 * global "curr_dir"), and ensures that the path size doesn't overflow.
839 * Also cleans the path using the clean_fname() function.
841 int push_dir(char *dir)
843 static int initialised;
848 getcwd(curr_dir, sizeof curr_dir - 1);
849 curr_dir_len = strlen(curr_dir);
852 if (!dir) /* this call was probably just to initialize */
856 if (len == 1 && *dir == '.')
859 if ((*dir == '/' ? len : curr_dir_len + 1 + len) >= sizeof curr_dir)
866 memcpy(curr_dir, dir, len + 1);
869 curr_dir[curr_dir_len++] = '/';
870 memcpy(curr_dir + curr_dir_len, dir, len + 1);
874 curr_dir_len = clean_fname(curr_dir, 1);
880 * Reverse a push_dir() call. You must pass in an absolute path
881 * that was copied from a prior value of "curr_dir".
883 int pop_dir(char *dir)
888 curr_dir_len = strlcpy(curr_dir, dir, sizeof curr_dir);
889 if (curr_dir_len >= sizeof curr_dir)
890 curr_dir_len = sizeof curr_dir - 1;
895 /* Return the filename, turning any non-printable characters into escaped
896 * characters (e.g. \n -> \012, \ -> \\). This ensures that outputting it
897 * cannot generate an empty line nor corrupt the screen. This function can
898 * return only MAX_SAFE_NAMES values at a time! The returned value can be
899 * longer than MAXPATHLEN (because we may be trying to output an error about
900 * a too-long filename)! */
901 char *safe_fname(const char *fname)
903 #define MAX_SAFE_NAMES 4
904 static char fbuf[MAX_SAFE_NAMES][MAXPATHLEN*2];
906 int limit = sizeof fbuf / MAX_SAFE_NAMES - 1;
909 ndx = (ndx + 1) % MAX_SAFE_NAMES;
910 for (t = fbuf[ndx]; *fname; fname++) {
911 if (*fname == '\\') {
912 if ((limit -= 2) < 0)
916 } else if (!isprint(*(uchar*)fname)) {
917 if ((limit -= 4) < 0)
919 sprintf(t, "\\%03o", *(uchar*)fname);
933 * Return a quoted string with the full pathname of the indicated filename.
934 * The string " (in MODNAME)" may also be appended. The returned pointer
935 * remains valid until the next time full_fname() is called.
937 char *full_fname(const char *fn)
939 static char *result = NULL;
951 for (p2 = p1; *p2 == '/'; p2++) {}
955 if (module_id >= 0) {
957 m2 = lp_name(module_id);
959 if (p1 == curr_dir) {
960 if (!lp_use_chroot(module_id)) {
961 char *p = lp_path(module_id);
962 if (*p != '/' || p[1])
969 asprintf(&result, "\"%s%s%s\"%s%s%s", p1, p2, fn, m1, m2, m3);
974 static char partial_fname[MAXPATHLEN];
976 char *partial_dir_fname(const char *fname)
978 char *t = partial_fname;
979 int sz = sizeof partial_fname;
982 if ((fn = strrchr(fname, '/')) != NULL) {
984 if (*partial_dir != '/') {
985 int len = fn - fname;
986 strncpy(t, fname, len); /* safe */
992 if ((int)pathjoin(t, sz, partial_dir, fn) >= sz)
994 if (server_filter_list.head) {
997 len = strlen(partial_dir);
999 if (check_filter(&server_filter_list, partial_fname, 1) < 0)
1002 if (check_filter(&server_filter_list, partial_fname, 0) < 0)
1006 return partial_fname;
1009 /* If no --partial-dir option was specified, we don't need to do anything
1010 * (the partial-dir is essentially '.'), so just return success. */
1011 int handle_partial_dir(const char *fname, int create)
1015 if (fname != partial_fname)
1017 if (!create && *partial_dir == '/')
1019 if (!(fn = strrchr(partial_fname, '/')))
1023 dir = partial_fname;
1026 int statret = do_lstat(dir, &st);
1027 if (statret == 0 && !S_ISDIR(st.st_mode)) {
1028 if (do_unlink(dir) < 0)
1032 if (statret < 0 && do_mkdir(dir, 0700) < 0)
1041 /** We need to supply our own strcmp function for file list comparisons
1042 to ensure that signed/unsigned usage is consistent between machines. */
1043 int u_strcmp(const char *cs1, const char *cs2)
1045 const uchar *s1 = (const uchar *)cs1;
1046 const uchar *s2 = (const uchar *)cs2;
1048 while (*s1 && *s2 && (*s1 == *s2)) {
1052 return (int)*s1 - (int)*s2;
1058 * Determine if a symlink points outside the current directory tree.
1059 * This is considered "unsafe" because e.g. when mirroring somebody
1060 * else's machine it might allow them to establish a symlink to
1061 * /etc/passwd, and then read it through a web server.
1063 * Null symlinks and absolute symlinks are always unsafe.
1065 * Basically here we are concerned with symlinks whose target contains
1066 * "..", because this might cause us to walk back up out of the
1067 * transferred directory. We are not allowed to go back up and
1070 * @param dest Target of the symlink in question.
1072 * @param src Top source directory currently applicable. Basically this
1073 * is the first parameter to rsync in a simple invocation, but it's
1074 * modified by flist.c in slightly complex ways.
1076 * @retval True if unsafe
1077 * @retval False is unsafe
1081 int unsafe_symlink(const char *dest, const char *src)
1083 const char *name, *slash;
1086 /* all absolute and null symlinks are unsafe */
1087 if (!dest || !*dest || *dest == '/')
1090 /* find out what our safety margin is */
1091 for (name = src; (slash = strchr(name, '/')) != 0; name = slash+1) {
1092 if (strncmp(name, "../", 3) == 0) {
1094 } else if (strncmp(name, "./", 2) == 0) {
1100 if (strcmp(name, "..") == 0)
1103 for (name = dest; (slash = strchr(name, '/')) != 0; name = slash+1) {
1104 if (strncmp(name, "../", 3) == 0) {
1105 /* if at any point we go outside the current directory
1106 then stop - it is unsafe */
1109 } else if (strncmp(name, "./", 2) == 0) {
1115 if (strcmp(name, "..") == 0)
1123 * Return the date and time as a string
1125 char *timestring(time_t t)
1127 static char TimeBuf[200];
1128 struct tm *tm = localtime(&t);
1130 #ifdef HAVE_STRFTIME
1131 strftime(TimeBuf, sizeof TimeBuf - 1, "%Y/%m/%d %H:%M:%S", tm);
1133 strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
1136 if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
1137 TimeBuf[strlen(TimeBuf)-1] = 0;
1145 * Sleep for a specified number of milliseconds.
1147 * Always returns TRUE. (In the future it might return FALSE if
1153 struct timeval tval, t1, t2;
1155 gettimeofday(&t1, NULL);
1158 tval.tv_sec = (t-tdiff)/1000;
1159 tval.tv_usec = 1000*((t-tdiff)%1000);
1162 select(0,NULL,NULL, NULL, &tval);
1164 gettimeofday(&t2, NULL);
1165 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1166 (t2.tv_usec - t1.tv_usec)/1000;
1174 * Determine if two file modification times are equivalent (either
1175 * exact or in the modification timestamp window established by
1178 * @retval 0 if the times should be treated as the same
1180 * @retval +1 if the first is later
1182 * @retval -1 if the 2nd is later
1184 int cmp_modtime(time_t file1, time_t file2)
1186 if (file2 > file1) {
1187 if (file2 - file1 <= modify_window)
1191 if (file1 - file2 <= modify_window)
1201 This routine is a trick to immediately catch errors when debugging
1202 with insure. A xterm with a gdb is popped up when insure catches
1203 a error. It is Linux specific.
1205 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1211 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'",
1212 getpid(), getpid(), getpid());
1216 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1217 fn = dlsym(h, "_Insure_trap_error");
1220 ret = fn(a1, a2, a3, a4, a5, a6);
1231 #define MALLOC_MAX 0x40000000
1233 void *_new_array(unsigned int size, unsigned long num)
1235 if (num >= MALLOC_MAX/size)
1237 return malloc(size * num);
1240 void *_realloc_array(void *ptr, unsigned int size, unsigned long num)
1242 if (num >= MALLOC_MAX/size)
1244 /* No realloc should need this, but just in case... */
1246 return malloc(size * num);
1247 return realloc(ptr, size * num);
1250 /* Take a filename and filename length and return the most significant
1251 * filename suffix we can find. This ignores suffixes such as "~",
1252 * ".bak", ".orig", ".~1~", etc. */
1253 const char *find_filename_suffix(const char *fn, int fn_len, int *len_ptr)
1255 const char *suf, *s;
1259 /* One or more dots at the start aren't a suffix. */
1260 while (fn_len && *fn == '.') fn++, fn_len--;
1262 /* Ignore the ~ in a "foo~" filename. */
1263 if (fn_len > 1 && fn[fn_len-1] == '~')
1264 fn_len--, had_tilde = True;
1268 /* Assume we don't find an suffix. */
1272 /* Find the last significant suffix. */
1273 for (s = fn + fn_len; fn_len > 1; ) {
1274 while (*--s != '.' && s != fn) {}
1277 s_len = fn_len - (s - fn);
1280 if (strcmp(s+1, "bak") == 0
1281 || strcmp(s+1, "old") == 0)
1283 } else if (s_len == 5) {
1284 if (strcmp(s+1, "orig") == 0)
1286 } else if (s_len > 2 && had_tilde
1287 && s[1] == '~' && isdigit(*(uchar*)(s+2)))
1293 /* Determine if the suffix is all digits. */
1294 for (s++, s_len--; s_len > 0; s++, s_len--) {
1295 if (!isdigit(*(uchar*)s))
1298 /* An all-digit suffix may not be that signficant. */
1305 /* This is an implementation of the Levenshtein distance algorithm. It
1306 * was implemented to avoid needing a two-dimensional matrix (to save
1307 * memory). It was also tweaked to try to factor in the ASCII distance
1308 * between changed characters as a minor distance quantity. The normal
1309 * Levenshtein units of distance (each signifying a single change between
1310 * the two strings) are defined as a "UNIT". */
1312 #define UNIT (1 << 16)
1314 uint32 fuzzy_distance(const char *s1, int len1, const char *s2, int len2)
1316 uint32 a[MAXPATHLEN], diag, above, left, diag_inc, above_inc, left_inc;
1320 if (!len1 || !len2) {
1325 for (i1 = 0, cost = 0; i1 < len1; i1++)
1327 return (int32)len1 * UNIT + cost;
1330 for (i2 = 0; i2 < len2; i2++)
1331 a[i2] = (i2+1) * UNIT;
1333 for (i1 = 0; i1 < len1; i1++) {
1335 above = (i1+1) * UNIT;
1336 for (i2 = 0; i2 < len2; i2++) {
1338 if ((cost = *((uchar*)s1+i1) - *((uchar*)s2+i2)) != 0) {
1344 diag_inc = diag + cost;
1345 left_inc = left + UNIT + *((uchar*)s1+i1);
1346 above_inc = above + UNIT + *((uchar*)s2+i2);
1347 a[i2] = above = left < above
1348 ? (left_inc < diag_inc ? left_inc : diag_inc)
1349 : (above_inc < diag_inc ? above_inc : diag_inc);