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\" ", *cmd);
112 rprintf(FINFO, "%s ", *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 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",
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;
897 * Return a quoted string with the full pathname of the indicated filename.
898 * The string " (in MODNAME)" may also be appended. The returned pointer
899 * remains valid until the next time full_fname() is called.
901 char *full_fname(const char *fn)
903 static char *result = NULL;
914 for (p2 = p1; *p2 == '/'; p2++) {}
918 if (module_id >= 0) {
920 m2 = lp_name(module_id);
922 if (p1 == curr_dir) {
923 if (!lp_use_chroot(module_id)) {
924 char *p = lp_path(module_id);
925 if (*p != '/' || p[1])
932 asprintf(&result, "\"%s%s%s\"%s%s%s", p1, p2, fn, m1, m2, m3);
937 static char partial_fname[MAXPATHLEN];
939 char *partial_dir_fname(const char *fname)
941 char *t = partial_fname;
942 int sz = sizeof partial_fname;
945 if ((fn = strrchr(fname, '/')) != NULL) {
947 if (*partial_dir != '/') {
948 int len = fn - fname;
949 strncpy(t, fname, len); /* safe */
955 if ((int)pathjoin(t, sz, partial_dir, fn) >= sz)
957 if (server_filter_list.head) {
960 len = strlen(partial_dir);
962 if (check_filter(&server_filter_list, partial_fname, 1) < 0)
965 if (check_filter(&server_filter_list, partial_fname, 0) < 0)
969 return partial_fname;
972 /* If no --partial-dir option was specified, we don't need to do anything
973 * (the partial-dir is essentially '.'), so just return success. */
974 int handle_partial_dir(const char *fname, int create)
978 if (fname != partial_fname)
980 if (!create && *partial_dir == '/')
982 if (!(fn = strrchr(partial_fname, '/')))
989 int statret = do_lstat(dir, &st);
990 if (statret == 0 && !S_ISDIR(st.st_mode)) {
991 if (do_unlink(dir) < 0)
995 if (statret < 0 && do_mkdir(dir, 0700) < 0)
1005 * Determine if a symlink points outside the current directory tree.
1006 * This is considered "unsafe" because e.g. when mirroring somebody
1007 * else's machine it might allow them to establish a symlink to
1008 * /etc/passwd, and then read it through a web server.
1010 * Null symlinks and absolute symlinks are always unsafe.
1012 * Basically here we are concerned with symlinks whose target contains
1013 * "..", because this might cause us to walk back up out of the
1014 * transferred directory. We are not allowed to go back up and
1017 * @param dest Target of the symlink in question.
1019 * @param src Top source directory currently applicable. Basically this
1020 * is the first parameter to rsync in a simple invocation, but it's
1021 * modified by flist.c in slightly complex ways.
1023 * @retval True if unsafe
1024 * @retval False is unsafe
1028 int unsafe_symlink(const char *dest, const char *src)
1030 const char *name, *slash;
1033 /* all absolute and null symlinks are unsafe */
1034 if (!dest || !*dest || *dest == '/')
1037 /* find out what our safety margin is */
1038 for (name = src; (slash = strchr(name, '/')) != 0; name = slash+1) {
1039 if (strncmp(name, "../", 3) == 0) {
1041 } else if (strncmp(name, "./", 2) == 0) {
1047 if (strcmp(name, "..") == 0)
1050 for (name = dest; (slash = strchr(name, '/')) != 0; name = slash+1) {
1051 if (strncmp(name, "../", 3) == 0) {
1052 /* if at any point we go outside the current directory
1053 then stop - it is unsafe */
1056 } else if (strncmp(name, "./", 2) == 0) {
1062 if (strcmp(name, "..") == 0)
1068 /* Return the int64 number as a string. If the --human-readable option was
1069 * specified, we may output the number in K, M, or G units. We can return
1070 * up to 4 buffers at a time. */
1071 char *human_num(int64 num)
1073 static char bufs[4][128]; /* more than enough room */
1074 static unsigned int n;
1077 n = (n + 1) % (sizeof bufs / sizeof bufs[0]);
1079 if (human_readable) {
1081 int mult = human_readable == 1 ? 1024 : 1000;
1083 if (num > mult*mult*mult) {
1084 dnum = (double)num / (mult*mult*mult);
1086 } else if (num > mult*mult) {
1087 dnum = (double)num / (mult*mult);
1089 } else if (num > mult) {
1090 dnum = (double)num / mult;
1094 sprintf(bufs[n], "%.2f%c", dnum, units);
1099 s = bufs[n] + sizeof bufs[0] - 1;
1105 *--s = (num % 10) + '0';
1111 /* Return the double number as a string. If the --human-readable option was
1112 * specified, we may output the number in K, M, or G units. We use a buffer
1113 * from human_num() to return our result. */
1114 char *human_dnum(double dnum, int decimal_digits)
1116 char *buf = human_num(dnum);
1117 int len = strlen(buf);
1118 if (isdigit(*(uchar*)(buf+len-1))) {
1119 /* There's extra room in buf prior to the start of the num. */
1120 buf -= decimal_digits + 1;
1121 snprintf(buf, len + decimal_digits + 2, "%.*f", decimal_digits, dnum);
1127 * Return the date and time as a string
1129 char *timestring(time_t t)
1131 static char TimeBuf[200];
1132 struct tm *tm = localtime(&t);
1134 #ifdef HAVE_STRFTIME
1135 strftime(TimeBuf, sizeof TimeBuf - 1, "%Y/%m/%d %H:%M:%S", tm);
1137 strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
1140 if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
1141 TimeBuf[strlen(TimeBuf)-1] = 0;
1149 * Sleep for a specified number of milliseconds.
1151 * Always returns TRUE. (In the future it might return FALSE if
1157 struct timeval tval, t1, t2;
1159 gettimeofday(&t1, NULL);
1162 tval.tv_sec = (t-tdiff)/1000;
1163 tval.tv_usec = 1000*((t-tdiff)%1000);
1166 select(0,NULL,NULL, NULL, &tval);
1168 gettimeofday(&t2, NULL);
1169 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1170 (t2.tv_usec - t1.tv_usec)/1000;
1178 * Determine if two file modification times are equivalent (either
1179 * exact or in the modification timestamp window established by
1182 * @retval 0 if the times should be treated as the same
1184 * @retval +1 if the first is later
1186 * @retval -1 if the 2nd is later
1188 int cmp_modtime(time_t file1, time_t file2)
1190 if (file2 > file1) {
1191 if (file2 - file1 <= modify_window)
1195 if (file1 - file2 <= modify_window)
1205 This routine is a trick to immediately catch errors when debugging
1206 with insure. A xterm with a gdb is popped up when insure catches
1207 a error. It is Linux specific.
1209 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1215 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'",
1216 getpid(), getpid(), getpid());
1220 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1221 fn = dlsym(h, "_Insure_trap_error");
1224 ret = fn(a1, a2, a3, a4, a5, a6);
1235 #define MALLOC_MAX 0x40000000
1237 void *_new_array(unsigned int size, unsigned long num)
1239 if (num >= MALLOC_MAX/size)
1241 return malloc(size * num);
1244 void *_realloc_array(void *ptr, unsigned int size, unsigned long num)
1246 if (num >= MALLOC_MAX/size)
1248 /* No realloc should need this, but just in case... */
1250 return malloc(size * num);
1251 return realloc(ptr, size * num);
1254 /* Take a filename and filename length and return the most significant
1255 * filename suffix we can find. This ignores suffixes such as "~",
1256 * ".bak", ".orig", ".~1~", etc. */
1257 const char *find_filename_suffix(const char *fn, int fn_len, int *len_ptr)
1259 const char *suf, *s;
1263 /* One or more dots at the start aren't a suffix. */
1264 while (fn_len && *fn == '.') fn++, fn_len--;
1266 /* Ignore the ~ in a "foo~" filename. */
1267 if (fn_len > 1 && fn[fn_len-1] == '~')
1268 fn_len--, had_tilde = True;
1272 /* Assume we don't find an suffix. */
1276 /* Find the last significant suffix. */
1277 for (s = fn + fn_len; fn_len > 1; ) {
1278 while (*--s != '.' && s != fn) {}
1281 s_len = fn_len - (s - fn);
1284 if (strcmp(s+1, "bak") == 0
1285 || strcmp(s+1, "old") == 0)
1287 } else if (s_len == 5) {
1288 if (strcmp(s+1, "orig") == 0)
1290 } else if (s_len > 2 && had_tilde
1291 && s[1] == '~' && isdigit(*(uchar*)(s+2)))
1297 /* Determine if the suffix is all digits. */
1298 for (s++, s_len--; s_len > 0; s++, s_len--) {
1299 if (!isdigit(*(uchar*)s))
1302 /* An all-digit suffix may not be that signficant. */
1309 /* This is an implementation of the Levenshtein distance algorithm. It
1310 * was implemented to avoid needing a two-dimensional matrix (to save
1311 * memory). It was also tweaked to try to factor in the ASCII distance
1312 * between changed characters as a minor distance quantity. The normal
1313 * Levenshtein units of distance (each signifying a single change between
1314 * the two strings) are defined as a "UNIT". */
1316 #define UNIT (1 << 16)
1318 uint32 fuzzy_distance(const char *s1, int len1, const char *s2, int len2)
1320 uint32 a[MAXPATHLEN], diag, above, left, diag_inc, above_inc, left_inc;
1324 if (!len1 || !len2) {
1329 for (i1 = 0, cost = 0; i1 < len1; i1++)
1331 return (int32)len1 * UNIT + cost;
1334 for (i2 = 0; i2 < len2; i2++)
1335 a[i2] = (i2+1) * UNIT;
1337 for (i1 = 0; i1 < len1; i1++) {
1339 above = (i1+1) * UNIT;
1340 for (i2 = 0; i2 < len2; i2++) {
1342 if ((cost = *((uchar*)s1+i1) - *((uchar*)s2+i2)) != 0) {
1348 diag_inc = diag + cost;
1349 left_inc = left + UNIT + *((uchar*)s1+i1);
1350 above_inc = above + UNIT + *((uchar*)s2+i2);
1351 a[i2] = above = left < above
1352 ? (left_inc < diag_inc ? left_inc : diag_inc)
1353 : (above_inc < diag_inc ? above_inc : diag_inc);