+
+/* sleep for a while via select */
+void u_sleep(int usec)
+{
+ struct timeval tv;
+
+ tv.tv_sec = 0;
+ tv.tv_usec = usec;
+ select(0, NULL, NULL, NULL, &tv);
+}
+
+
+static pid_t all_pids[10];
+static int num_pids;
+
+/* fork and record the pid of the child */
+pid_t do_fork(void)
+{
+ pid_t newpid = fork();
+
+ if (newpid) {
+ all_pids[num_pids++] = newpid;
+ }
+ return newpid;
+}
+
+/* kill all children */
+void kill_all(int sig)
+{
+ int i;
+ for (i=0;i<num_pids;i++) {
+ if (all_pids[i] != getpid())
+ kill(all_pids[i], sig);
+ }
+}
+
+/* like strncpy but does not 0 fill the buffer and always null
+ terminates (thus it can use maxlen+1 space in d) */
+void strlcpy(char *d, char *s, int maxlen)
+{
+ int len = strlen(s);
+ if (len > maxlen) len = maxlen;
+ memcpy(d, s, len);
+ d[len] = 0;
+}
+
+/* like strncat but does not 0 fill the buffer and always null
+ terminates (thus it can use maxlen+1 space in d) */
+void strlcat(char *d, char *s, int maxlen)
+{
+ int len1 = strlen(d);
+ int len2 = strlen(s);
+ if (len1+len2 > maxlen) {
+ len2 = maxlen-len1;
+ }
+ if (len2 > 0) {
+ memcpy(d+len1, s, len2);
+ d[len1+len2] = 0;
+ }
+}
+
+/* turn a user name into a uid */
+int name_to_uid(char *name, uid_t *uid)
+{
+ struct passwd *pass;
+ if (!name || !*name) return 0;
+ pass = getpwnam(name);
+ if (pass) {
+ *uid = pass->pw_uid;
+ return 1;
+ }
+ return 0;
+}
+
+/* turn a group name into a gid */
+int name_to_gid(char *name, gid_t *gid)
+{
+ struct group *grp;
+ if (!name || !*name) return 0;
+ grp = getgrnam(name);
+ if (grp) {
+ *gid = grp->gr_gid;
+ return 1;
+ }
+ return 0;
+}
+
+
+/****************************************************************************
+check if a process exists.
+****************************************************************************/
+int process_exists(int pid)
+{
+ return(kill(pid,0) == 0 || errno != ESRCH);
+}
+
+/* lock a byte range in a open file */
+int lock_range(int fd, int offset, int len)
+{
+ struct flock lock;
+
+ lock.l_type = F_WRLCK;
+ lock.l_whence = SEEK_SET;
+ lock.l_start = offset;
+ lock.l_len = len;
+ lock.l_pid = 0;
+
+ return fcntl(fd,F_SETLK,&lock) == 0;
+}
+
+
+static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
+{
+#ifndef HAVE_GLOB
+ if (!*s) s = ".";
+ argv[*argc] = strdup(s);
+ (*argc)++;
+ return;
+#else
+ glob_t globbuf;
+ int i;
+
+ if (!*s) s = ".";
+
+ argv[*argc] = strdup(s);
+
+ memset(&globbuf, 0, sizeof(globbuf));
+ glob(argv[*argc], 0, NULL, &globbuf);
+ if (globbuf.gl_pathc == 0) {
+ (*argc)++;
+ globfree(&globbuf);
+ return;
+ }
+ for (i=0; i<(maxargs - (*argc)) && i<globbuf.gl_pathc;i++) {
+ if (i == 0) free(argv[*argc]);
+ argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
+ if (!argv[(*argc) + i]) out_of_memory("glob_expand");
+ }
+ globfree(&globbuf);
+ (*argc) += i;
+#endif
+}
+
+void glob_expand(char *base1, char **argv, int *argc, int maxargs)
+{
+ char *s = argv[*argc];
+ char *p, *q;
+ char *base = base1;
+
+ if (!s || !*s) return;
+
+ if (strncmp(s, base, strlen(base)) == 0) {
+ s += strlen(base);
+ }
+
+ s = strdup(s);
+ if (!s) out_of_memory("glob_expand");
+
+ base = (char *)malloc(strlen(base1)+3);
+ if (!base) out_of_memory("glob_expand");
+
+ sprintf(base," %s/", base1);
+
+ q = s;
+ while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
+ /* split it at this point */
+ *p = 0;
+ glob_expand_one(q, argv, argc, maxargs);
+ q = p+strlen(base);
+ }
+
+ if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
+
+ free(s);
+ free(base);
+}
+
+/*******************************************************************
+ convert a string to lower case
+********************************************************************/
+void strlower(char *s)
+{
+ while (*s) {
+ if (isupper(*s)) *s = tolower(*s);
+ s++;
+ }
+}
+
+/* this is like vsnprintf but the 'n' limit does not include
+ the terminating null. So if you have a 1024 byte buffer then
+ pass 1023 for n */
+int vslprintf(char *str, int n, const char *format, va_list ap)
+{
+#ifdef HAVE_VSNPRINTF
+ int ret = vsnprintf(str, n, format, ap);
+ if (ret > n || ret < 0) {
+ str[n] = 0;
+ return -1;
+ }
+ str[ret] = 0;
+ return ret;
+#else
+ static char *buf;
+ static int len=MAXPATHLEN*8;
+ int ret;
+
+ /* this code is NOT a proper vsnprintf() implementation. It
+ relies on the fact that all calls to slprintf() in rsync
+ pass strings which have already been checked to be less
+ than MAXPATHLEN in length and never more than 2 strings are
+ concatenated. This means the above buffer is absolutely
+ ample and can never be overflowed.
+
+ In the future we would like to replace this with a proper
+ vsnprintf() implementation but right now we need a solution
+ that is secure and portable. This is it. */
+
+ if (!buf) {
+ buf = malloc(len);
+ if (!buf) {
+ /* can't call debug or we would recurse */
+ exit_cleanup(1);
+ }
+ }
+
+ vsprintf(buf, format, ap);
+ ret = strlen(buf);
+ if (ret > n) {
+ /* yikes! */
+ exit_cleanup(1);
+ }
+ buf[ret] = 0;
+
+ memcpy(str, buf, ret+1);
+
+ return ret;
+#endif
+}
+
+
+/* like snprintf but always null terminates */
+int slprintf(char *str, int n, char *format, ...)
+{
+ va_list ap;
+ int ret;
+
+ va_start(ap, format);
+ ret = vslprintf(str,n,format,ap);
+ va_end(ap);
+ return ret;
+}
+
+
+void *Realloc(void *p, int size)
+{
+ if (!p) return (void *)malloc(size);
+ return (void *)realloc(p, size);
+}
+
+
+void clean_fname(char *name)
+{
+ char *p;
+ int l;
+ int modified = 1;
+
+ if (!name) return;
+
+ while (modified) {
+ modified = 0;
+
+ if ((p=strstr(name,"/./"))) {
+ modified = 1;
+ while (*p) {
+ p[0] = p[2];
+ p++;
+ }
+ }
+
+ if ((p=strstr(name,"//"))) {
+ modified = 1;
+ while (*p) {
+ p[0] = p[1];
+ p++;
+ }
+ }
+
+ if (strncmp(p=name,"./",2) == 0) {
+ modified = 1;
+ do {
+ p[0] = p[2];
+ } while (*p++);
+ }
+
+ l = strlen(p=name);
+ if (l > 1 && p[l-1] == '/') {
+ modified = 1;
+ p[l-1] = 0;
+ }
+ }
+}
+
+
+static char curr_dir[MAXPATHLEN];
+
+/* like chdir() but can be reversed with pop_dir() if save is set. It
+ is also much faster as it remembers where we have been */
+char *push_dir(char *dir, int save)
+{
+ char *ret = curr_dir;
+ static int initialised;
+
+ if (!initialised) {
+ initialised = 1;
+ getcwd(curr_dir, sizeof(curr_dir)-1);
+ }
+
+ if (chdir(dir)) return NULL;
+
+ if (save) {
+ ret = strdup(curr_dir);
+ }
+
+ if (*dir == '/') {
+ strlcpy(curr_dir, dir, sizeof(curr_dir)-1);
+ } else {
+ strlcat(curr_dir,"/", sizeof(curr_dir)-1);
+ strlcat(curr_dir,dir, sizeof(curr_dir)-1);
+ }
+
+ clean_fname(curr_dir);
+
+ return ret;
+}
+
+/* reverse a push_dir call */
+int pop_dir(char *dir)
+{
+ int ret;
+
+ ret = chdir(dir);
+ if (ret) {
+ free(dir);
+ return ret;
+ }
+
+ strlcpy(curr_dir, dir, sizeof(curr_dir)-1);
+
+ free(dir);
+
+ return 0;
+}