[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.3 and 1.3.2.3

version 1.3, 2012/07/22 22:09:47 version 1.3.2.3, 2012/11/13 13:53:14
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 = '*';
                                 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 142  create_diridx(const char *csDir, int lm, int *tags, st Line 142  create_diridx(const char *csDir, int lm, int *tags, st
                         memset(&l[n + 1], 0, sizeof(struct tagDirName));                          memset(&l[n + 1], 0, sizeof(struct tagDirName));
   
                 l[n].ch = '<';                  l[n].ch = '<';
                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, (long) 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, (long) 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(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(l);                          free(l);
Line 330  sync_dircmpList(const char *csDir1, const char *csDir2 Line 338  sync_dircmpList(const char *csDir1, const char *csDir2
                 }                  }
                 dir = opendir(".");                  dir = opendir(".");
                 if (!dir) {                  if (!dir) {
                        SETERR;                        LOGERR;
                         chdir(old);                          chdir(old);
                         free(old);                          free(old);
                         free(l);                          free(l);
Line 345  sync_dircmpList(const char *csDir1, const char *csDir2 Line 353  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);
Line 360  sync_dircmpList(const char *csDir1, const char *csDir2 Line 368  sync_dircmpList(const char *csDir1, const char *csDir2
                                 l[n].ch = '>';                                  l[n].ch = '>';
                                 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, (long) sb.st_ino, sb.st_uid,                                                                 "size=%ld %s", szType, sb.st_nlink, 
                                                                sb.st_gid, sb.st_mode & 0x1fff, (long) 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 431  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(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 453  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);
                                         return -1;                                          return -1;
Line 458  sync_dircmpList(const char *csDir1, const char *csDir2 Line 467  sync_dircmpList(const char *csDir1, const char *csDir2
                                 l[n].ch = '>';                                  l[n].ch = '>';
                                 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 478  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 == '*') {
                         memmove(&l[i], &l[i + 1], (n - i + 1) * sizeof(struct tagDirName));                          memmove(&l[i], &l[i + 1], (n - i + 1) * sizeof(struct tagDirName));
Removed from v.1.3  
changed lines
  Added in v.1.3.2.3

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