[BACK]Return to dir.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitsync / src

Diff for /libaitsync/src/dir.c between versions 1.2.2.1 and 1.3.2.5

version 1.2.2.1, 2011/05/09 15:02:52 version 1.3.2.5, 2012/11/13 14:18:45
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 58  find_tag(int const * __restrict tags, struct tagDirNam Line 58  find_tag(int const * __restrict tags, struct tagDirNam
         struct tagDirName *find = NULL;          struct tagDirName *find = NULL;
         register int i;          register int i;
   
        // search in index tags        /* search in index tags */
         if (tags[t] != -1 && l[tags[t]].tag == t) {          if (tags[t] != -1 && l[tags[t]].tag == t) {
                // search in sorted hashes                /* search in sorted hashes */
                 for (i = 0; l[tags[t] + i].tag == t; i++)                  for (i = 0; l[tags[t] + i].tag == t; i++)
                         if (l[tags[t] + i].hash == hash) {                          if (l[tags[t] + i].hash == hash) {
                                // finded & marked for delete!                                /* finded & marked for delete! */
                                 find = (struct tagDirName*) &l[tags[t] + i];                                  find = (struct tagDirName*) &l[tags[t] + i];
                                find->ch = '*';                                find->ch = DIFF_D0;
                                 break;                                  break;
                         }                          }
         }          }
Line 80  create_tags() Line 80  create_tags()
   
         tags = calloc(TABLESIZ, sizeof(int));          tags = calloc(TABLESIZ, sizeof(int));
         if (!tags) {          if (!tags) {
                SETERR;                LOGERR;
         } else          } else
                 memset(tags, -1, TABLESIZ * sizeof(int));                  memset(tags, -1, TABLESIZ * sizeof(int));
   
Line 100  create_diridx(const char *csDir, int lm, int *tags, st Line 100  create_diridx(const char *csDir, int lm, int *tags, st
   
         l = malloc(sizeof(struct tagDirName));          l = malloc(sizeof(struct tagDirName));
         if (!l) {          if (!l) {
                SETERR;                LOGERR;
                 *list = NULL;                  *list = NULL;
                 return -1;                  return -1;
         } else {          } else {
Line 110  create_diridx(const char *csDir, int lm, int *tags, st Line 110  create_diridx(const char *csDir, int lm, int *tags, st
   
         old = getcwd(NULL, 0);          old = getcwd(NULL, 0);
         if (chdir(csDir) == -1) {          if (chdir(csDir) == -1) {
                SETERR;                LOGERR;
                 free(old);                  free(old);
                 free(l);                  free(l);
                 *list = NULL;                  *list = NULL;
Line 118  create_diridx(const char *csDir, int lm, int *tags, st Line 118  create_diridx(const char *csDir, int lm, int *tags, st
         }          }
         dir = opendir(".");          dir = opendir(".");
         if (!dir) {          if (!dir) {
                SETERR;                LOGERR;
                 chdir(old);                  chdir(old);
                 free(old);                  free(old);
                 free(l);                  free(l);
Line 131  create_diridx(const char *csDir, int lm, int *tags, st Line 131  create_diridx(const char *csDir, int lm, int *tags, st
   
                 l = realloc(l, sizeof(struct tagDirName) * (n + 2));                  l = realloc(l, sizeof(struct tagDirName) * (n + 2));
                 if (!l) {                  if (!l) {
                        SETERR;                        LOGERR;
                         chdir(old);                          chdir(old);
                         free(old);                          free(old);
                         free(l);                          free(l);
Line 141  create_diridx(const char *csDir, int lm, int *tags, st Line 141  create_diridx(const char *csDir, int lm, int *tags, st
                 } else                  } else
                         memset(&l[n + 1], 0, sizeof(struct tagDirName));                          memset(&l[n + 1], 0, sizeof(struct tagDirName));
   
                l[n].ch = '<';                l[n].ch = DIFF_D1;
                l[n].tag = crcFletcher16((u_short*) d.d_name, d.d_namlen / 2 + d.d_namlen % 2);                l[n].tag = crcFletcher16((u_short*) d.d_name, 
                                 d.d_namlen / 2 + d.d_namlen % 2);
                 l[n].hash = crcAdler((u_char*) d.d_name, d.d_namlen);                  l[n].hash = crcAdler((u_char*) d.d_name, d.d_namlen);
                strlcpy(l[n].name, d.d_name, MAXPATHLEN);                strlcpy(l[n].name, d.d_name, sizeof l[n].name);
                 if (lm & 1) {                  if (lm & 1) {
                         if (lstat(d.d_name, &sb) != -1) {                          if (lstat(d.d_name, &sb) != -1) {
                                memset(szStr, 0, STRSIZ);                                memset(szStr, 0, sizeof szStr);
 #if defined(__OpenBSD__)  #if defined(__OpenBSD__)
                                strftime(szStr, STRSIZ, "%Y-%m-%d %H:%M:%S", localtime((time_t*) &sb.st_mtim));                                strftime(szStr, sizeof szStr, "%Y-%m-%d %H:%M:%S", 
                                                 localtime((time_t*) &sb.st_mtim));
 #else  #else
                                strftime(szStr, STRSIZ, "%Y-%m-%d %H:%M:%S", localtime((time_t*) &sb.st_mtime));                                strftime(szStr, sizeof szStr, "%Y-%m-%d %H:%M:%S", 
                                                 localtime((time_t*) &sb.st_mtime));
 #endif  #endif
                                 switch (d.d_type) {                                  switch (d.d_type) {
                                         case DT_FIFO:                                          case DT_FIFO:
                                                strlcpy(szType, "fifo", STRSIZ);                                                strlcpy(szType, "fifo", sizeof szType);
                                                 break;                                                  break;
                                         case DT_CHR:                                          case DT_CHR:
                                                strlcpy(szType, "char", STRSIZ);                                                strlcpy(szType, "char", sizeof szType);
                                                 break;                                                  break;
                                         case DT_DIR:                                          case DT_DIR:
                                                strlcpy(szType, "dir", STRSIZ);                                                strlcpy(szType, "dir", sizeof szType);
                                                 break;                                                  break;
                                         case DT_BLK:                                          case DT_BLK:
                                                strlcpy(szType, "block", STRSIZ);                                                strlcpy(szType, "block", sizeof szType);
                                                 break;                                                  break;
                                         case DT_REG:                                          case DT_REG:
                                                strlcpy(szType, "file", STRSIZ);                                                strlcpy(szType, "file", sizeof szType);
                                                 break;                                                  break;
                                         case DT_LNK:                                          case DT_LNK:
                                                strlcpy(szType, "link", STRSIZ);                                                strlcpy(szType, "link", sizeof szType);
                                                 break;                                                  break;
                                         case DT_SOCK:                                          case DT_SOCK:
                                                strlcpy(szType, "socket", STRSIZ);                                                strlcpy(szType, "socket", sizeof szType);
                                                 break;                                                  break;
 /* OpenBSD does not have this type */  /* OpenBSD does not have this type */
 #ifdef DT_WHT  #ifdef DT_WHT
                                         case DT_WHT:                                          case DT_WHT:
                                                strlcpy(szType, "wht", STRSIZ);                                                strlcpy(szType, "wht", sizeof szType);
                                                 break;                                                  break;
 #endif  #endif
                                         case DT_UNKNOWN:                                          case DT_UNKNOWN:
                                         default:                                          default:
                                                strlcpy(szType, "unknown", STRSIZ);                                                strlcpy(szType, "unknown", sizeof szType);
                                                 break;                                                  break;
                                 }                                  }
                                snprintf(l[n].extra, STRSIZ, "%s links=%d inode=%ld %d:%d perm=0%o size=%ld %s",                                 snprintf(l[n].extra, sizeof l[n].extra, 
                                                szType, sb.st_nlink, (int64_t) sb.st_ino, sb.st_uid, sb.st_gid,                                                 "%s links=%d inode=%ld %d:%d perm=0%o size=%ld %s", 
                                                sb.st_mode & 0x1fff, (int64_t) sb.st_size, szStr);                                                szType, sb.st_nlink, (long) sb.st_ino, 
                                                 sb.st_uid, sb.st_gid, sb.st_mode & 0x1fff, 
                                                 (long) sb.st_size, szStr);
                         }                          }
                 }                  }
   
Line 207  create_diridx(const char *csDir, int lm, int *tags, st Line 212  create_diridx(const char *csDir, int lm, int *tags, st
         return n;          return n;
 }  }
   
// ------------------------------------------------------/* ------------------------------------------------------ */
   
 /*  /*
 * sync_dirCSum() Calculate checksum of directory * sync_dirChkSum() - Calculate checksum of directory
  *
  * @csDir = Directory   * @csDir = Directory
 * @md = Message digest allocated memory, must be free after use! * @md = Message digest allocated memory, must be free() after use!
  * return: -1 error or !=-1 ok   * return: -1 error or !=-1 ok
  */   */
 int  int
sync_dirCSum(const char *csDir, u_char **md)sync_dirChkSum(const char *csDir, u_char **md)
 {  {
         DIR *dir;          DIR *dir;
         struct dirent d, *pd;          struct dirent d, *pd;
Line 225  sync_dirCSum(const char *csDir, u_char **md) Line 231  sync_dirCSum(const char *csDir, u_char **md)
   
         *md = malloc(MD5_DIGEST_LENGTH);          *md = malloc(MD5_DIGEST_LENGTH);
         if (!*md) {          if (!*md) {
                SETERR;                LOGERR;
                 return -1;                  return -1;
         } else          } else
                 memset(*md, 0, MD5_DIGEST_LENGTH);                  memset(*md, 0, MD5_DIGEST_LENGTH);
   
         dir = opendir(csDir);          dir = opendir(csDir);
         if (!dir) {          if (!dir) {
                SETERR;                LOGERR;
                 free(*md);                  free(*md);
                 return -1;                  return -1;
         }          }
Line 251  sync_dirCSum(const char *csDir, u_char **md) Line 257  sync_dirCSum(const char *csDir, u_char **md)
 }  }
   
 /*  /*
 * sync_dircmp() Compare directories * sync_dircmp() - Compare directories
  *
  * @csDir1 = Directory 1   * @csDir1 = Directory 1
  * @csDir2 = Directory 2   * @csDir2 = Directory 2
  * return: -1 error, 0 is equal or 1 different   * return: -1 error, 0 is equal or 1 different
Line 265  sync_dircmp(const char *csDir1, const char *csDir2) Line 272  sync_dircmp(const char *csDir1, const char *csDir2)
         if (!csDir1 || !csDir2)          if (!csDir1 || !csDir2)
                 return ret;                  return ret;
   
        if (sync_dirCSum(csDir1, &md[0]) == -1)        if (sync_dirChkSum(csDir1, &md[0]) == -1)
                 return ret;                  return ret;
        if (sync_dirCSum(csDir2, &md[1]) == -1) {        if (sync_dirChkSum(csDir2, &md[1]) == -1) {
                 free(md[0]);                  free(md[0]);
                 return ret;                  return ret;
         }          }
Line 283  sync_dircmp(const char *csDir1, const char *csDir2) Line 290  sync_dircmp(const char *csDir1, const char *csDir2)
 }  }
   
 /*  /*
 * sync_dircmpList() Compare directories or directory and file list * sync_dircmpList() - Compare directories or directory and file list
  *
  * @csDir1 = Directory 1   * @csDir1 = Directory 1
  * @csDir2 = Directory 2 or File list, if "-" get input from console   * @csDir2 = Directory 2 or File list, if "-" get input from console
 * @lm = Long mode options, 1 long output * @lm = Long mode options, !=NULL long output
 * @list = Output diff list, after use must be free! * @list = Output diff list, after use must be free()!
  * return: -1 error, 0 is equal or >0 count of returned list items   * return: -1 error, 0 is equal or >0 count of returned list items
  */   */
 int  int
Line 315  sync_dircmpList(const char *csDir1, const char *csDir2 Line 323  sync_dircmpList(const char *csDir1, const char *csDir2
         }          }
   
         if (lstat(csDir2, &sb) == -1) {          if (lstat(csDir2, &sb) == -1) {
                SETERR;                LOGERR;
                 free(tags);
                 free(l);                  free(l);
                 return -1;                  return -1;
         }          }
         if (S_ISDIR(sb.st_mode)) {          if (S_ISDIR(sb.st_mode)) {
                 old = getcwd(NULL, 0);                  old = getcwd(NULL, 0);
                 if (chdir(csDir2) == -1) {                  if (chdir(csDir2) == -1) {
                        SETERR;                        LOGERR;
                         chdir(old);                          chdir(old);
                         free(old);                          free(old);
                           free(tags);
                         free(l);                          free(l);
                         return -1;                          return -1;
                 }                  }
                 dir = opendir(".");                  dir = opendir(".");
                 if (!dir) {                  if (!dir) {
                        SETERR;                        LOGERR;
                         chdir(old);                          chdir(old);
                         free(old);                          free(old);
                           free(tags);
                         free(l);                          free(l);
                         return -1;                          return -1;
                 }                  }
Line 345  sync_dircmpList(const char *csDir1, const char *csDir2 Line 356  sync_dircmpList(const char *csDir1, const char *csDir2
                         }                          }
   
                         find = find_tag(tags, l, t, hash);                          find = find_tag(tags, l, t, hash);
                        // element not find in dir1, added                        /* element not find in dir1, added */
                         if (!find) {                          if (!find) {
                                 l = realloc(l, sizeof(struct tagDirName) * (n + 2));                                  l = realloc(l, sizeof(struct tagDirName) * (n + 2));
                                 if (!l) {                                  if (!l) {
                                        SETERR;                                        LOGERR;
                                         chdir(old);                                          chdir(old);
                                         free(old);                                          free(old);
                                         closedir(dir);                                          closedir(dir);
                                           free(tags);
                                         return -1;                                          return -1;
                                 } else                                  } else
                                         memset(&l[n + 1], 0, sizeof(struct tagDirName));                                          memset(&l[n + 1], 0, sizeof(struct tagDirName));
   
                                l[n].ch = '>';                                l[n].ch = DIFF_D2;
                                 l[n].tag = t;                                  l[n].tag = t;
                                 l[n].hash = hash;                                  l[n].hash = hash;
                                strlcpy(l[n].name, d.d_name, MAXPATHLEN);                                strlcpy(l[n].name, d.d_name, sizeof l[n].name);
                                 if (lm & 1) {                                  if (lm & 1) {
                                         if (lstat(d.d_name, &sb) != -1) {                                          if (lstat(d.d_name, &sb) != -1) {
                                                memset(szStr, 0, STRSIZ);                                                memset(szStr, 0, sizeof szStr);
 #if defined(__OpenBSD__)  #if defined(__OpenBSD__)
                                                strftime(szStr, STRSIZ, "%Y-%m-%d %H:%M:%S",                                                 strftime(szStr, sizeof szStr, "%Y-%m-%d %H:%M:%S", 
                                                                 localtime((time_t*) &sb.st_mtim));                                                                  localtime((time_t*) &sb.st_mtim));
 #else  #else
                                                strftime(szStr, STRSIZ, "%Y-%m-%d %H:%M:%S",                                                 strftime(szStr, sizeof szStr, "%Y-%m-%d %H:%M:%S", 
                                                                 localtime((time_t*) &sb.st_mtime));                                                                  localtime((time_t*) &sb.st_mtime));
 #endif  #endif
                                                 switch (d.d_type) {                                                  switch (d.d_type) {
                                                         case DT_FIFO:                                                          case DT_FIFO:
                                                                strlcpy(szType, "fifo", STRSIZ);                                                                strlcpy(szType, "fifo", sizeof szType);
                                                                 break;                                                                  break;
                                                         case DT_CHR:                                                          case DT_CHR:
                                                                strlcpy(szType, "char", STRSIZ);                                                                strlcpy(szType, "char", sizeof szType);
                                                                 break;                                                                  break;
                                                         case DT_DIR:                                                          case DT_DIR:
                                                                strlcpy(szType, "dir", STRSIZ);                                                                strlcpy(szType, "dir", sizeof szType);
                                                                 break;                                                                  break;
                                                         case DT_BLK:                                                          case DT_BLK:
                                                                strlcpy(szType, "block", STRSIZ);                                                                strlcpy(szType, "block", sizeof szType);
                                                                 break;                                                                  break;
                                                         case DT_REG:                                                          case DT_REG:
                                                                strlcpy(szType, "file", STRSIZ);                                                                strlcpy(szType, "file", sizeof szType);
                                                                 break;                                                                  break;
                                                         case DT_LNK:                                                          case DT_LNK:
                                                                strlcpy(szType, "link", STRSIZ);                                                                strlcpy(szType, "link", sizeof szType);
                                                                 break;                                                                  break;
                                                         case DT_SOCK:                                                          case DT_SOCK:
                                                                strlcpy(szType, "socket", STRSIZ);                                                                strlcpy(szType, "socket", sizeof szType);
                                                                 break;                                                                  break;
 /* OpenBSD does not have this type */  /* OpenBSD does not have this type */
 #ifdef DT_WHT  #ifdef DT_WHT
                                                         case DT_WHT:                                                          case DT_WHT:
                                                                strlcpy(szType, "wht", STRSIZ);                                                                strlcpy(szType, "wht", sizeof szType);
                                                                 break;                                                                  break;
 #endif  #endif
                                                         case DT_UNKNOWN:                                                          case DT_UNKNOWN:
                                                         default:                                                          default:
                                                                strlcpy(szType, "unknown", STRSIZ);                                                                strlcpy(szType, "unknown", sizeof szType);
                                                                 break;                                                                  break;
                                                 }                                                  }
                                                snprintf(l[n].extra, STRSIZ,                                                 snprintf(l[n].extra, sizeof l[n].extra, 
                                                                "%s links=%d inode=%ld %d:%d perm=0%o size=%ld %s",                                                                 "%s links=%d inode=%ld %d:%d perm=0%o "
                                                                szType, sb.st_nlink, (int64_t) sb.st_ino, sb.st_uid,                                                                 "size=%ld %s", szType, sb.st_nlink, 
                                                                sb.st_gid, sb.st_mode & 0x1fff, (int64_t) sb.st_size,                                                                 (long) sb.st_ino, sb.st_uid, sb.st_gid, 
                                                                 sb.st_mode & 0x1fff, (long) sb.st_size, 
                                                                 szStr);                                                                  szStr);
                                         }                                          }
                                 }                                  }
Line 422  sync_dircmpList(const char *csDir1, const char *csDir2 Line 435  sync_dircmpList(const char *csDir1, const char *csDir2
                 if (strcmp(csDir2, "-")) {                  if (strcmp(csDir2, "-")) {
                         f = fopen(csDir2, "r");                          f = fopen(csDir2, "r");
                         if (!f) {                          if (!f) {
                                SETERR;                                LOGERR;
                                 free(tags);
                                 free(l);                                  free(l);
                                 return -1;                                  return -1;
                         }                          }
                 }                  }
                while (fgets(szLine, STRSIZ, f)) {                while (fgets(szLine, sizeof szLine, f)) {
                         if (!*szLine || *szLine == '#')                          if (!*szLine || *szLine == '#')
                                 continue;                                  continue;
   
Line 444  sync_dircmpList(const char *csDir1, const char *csDir2 Line 458  sync_dircmpList(const char *csDir1, const char *csDir2
                         }                          }
   
                         find = find_tag(tags, l, t, hash);                          find = find_tag(tags, l, t, hash);
                        // element not find in dir1, added                        /* element not find in dir1, added */
                         if (!find) {                          if (!find) {
                                 l = realloc(l, sizeof(struct tagDirName) * (n + 2));                                  l = realloc(l, sizeof(struct tagDirName) * (n + 2));
                                 if (!l) {                                  if (!l) {
                                        SETERR;                                        LOGERR;
                                         if (strcmp(csDir2, "-"))                                          if (strcmp(csDir2, "-"))
                                                 fclose(f);                                                  fclose(f);
                                           free(tags);
                                         return -1;                                          return -1;
                                 } else                                  } else
                                         memset(&l[n + 1], 0, sizeof(struct tagDirName));                                          memset(&l[n + 1], 0, sizeof(struct tagDirName));
   
                                l[n].ch = '>';                                l[n].ch = DIFF_D2;
                                 l[n].tag = t;                                  l[n].tag = t;
                                 l[n].hash = hash;                                  l[n].hash = hash;
                                strlcpy(l[n].name, str, MAXPATHLEN);                                strlcpy(l[n].name, str, sizeof l[n].name);
                                 if (lm & 1 && (str = strtok_r(NULL, "\r\n", &pbrk)))                                  if (lm & 1 && (str = strtok_r(NULL, "\r\n", &pbrk)))
                                        strlcpy(l[n].extra, str, STRSIZ);                                        strlcpy(l[n].extra, str, sizeof l[n].extra);
   
                                 n++;                                  n++;
                         }                          }
Line 469  sync_dircmpList(const char *csDir1, const char *csDir2 Line 484  sync_dircmpList(const char *csDir1, const char *csDir2
                         fclose(f);                          fclose(f);
         }          }
   
        // delete equal elemets !!!        /* delete equal elemets !!! */
         for (i = cx = 0; i < n; i++)          for (i = cx = 0; i < n; i++)
                if (l[i].ch == '*') {                if (l[i].ch == DIFF_D0) {
                         memmove(&l[i], &l[i + 1], (n - i + 1) * sizeof(struct tagDirName));                          memmove(&l[i], &l[i + 1], (n - i + 1) * sizeof(struct tagDirName));
                         cx++;                          cx++;
                         i--;                          i--;
                 }                  }
         n -= cx;          n -= cx;
   
           free(tags);
         *list = l;          *list = l;
         return n;          return n;
 }  }
Removed from v.1.2.2.1  
changed lines
  Added in v.1.3.2.5

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>