[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.1.2.3 and 1.4.6.1

version 1.1.2.3, 2011/03/16 17:17:44 version 1.4.6.1, 2014/02/04 16:39:00
Line 5 Line 5
 * $Author$  * $Author$
 * $Id$  * $Id$
 *  *
*************************************************************************/**************************************************************************
 The ELWIX and AITNET software is distributed under the following
 terms:
 
 All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
 
 Copyright 2004 - 2014
         by Michael Pounov <misho@elwix.org>.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:
 1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
 3. All advertising materials mentioning features or use of this software
    must display the following acknowledgement:
 This product includes software developed by Michael Pounov <misho@elwix.org>
 ELWIX - Embedded LightWeight unIX and its contributors.
 4. Neither the name of AITNET nor the names of its contributors
    may be used to endorse or promote products derived from this software
    without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGE.
 */
 #include "global.h"  #include "global.h"
   
   
Line 21  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 43  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 63  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 73  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 81  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 94  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 104  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);
                                strftime(szStr, STRSIZ, "%Y-%m-%d %H:%M:%S", localtime((time_t*) &sb.st_mtim));#if defined(__OpenBSD__)
                                 strftime(szStr, sizeof szStr, "%Y-%m-%d %H:%M:%S", 
                                                 localtime((time_t*) &sb.st_mtim));
 #else
                                 strftime(szStr, sizeof szStr, "%Y-%m-%d %H:%M:%S", 
                                                 localtime((time_t*) &sb.st_mtime));
 #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=%u %d:%d perm=0%o size=%llu %s",                                 snprintf(l[n].extra, sizeof l[n].extra, 
                                                szType, sb.st_nlink, 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, 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 166  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 184  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 210  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 224  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 242  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 274  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 304  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);
                                                strftime(szStr, STRSIZ, "%Y-%m-%d %H:%M:%S", #if defined(__OpenBSD__)
                                                 strftime(szStr, sizeof szStr, "%Y-%m-%d %H:%M:%S", 
                                                                 localtime((time_t*) &sb.st_mtim));                                                                  localtime((time_t*) &sb.st_mtim));
   #else
                                                   strftime(szStr, sizeof szStr, "%Y-%m-%d %H:%M:%S", 
                                                                   localtime((time_t*) &sb.st_mtime));
   #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=%u %d:%d perm=0%o size=%llu %s",                                                                 "%s links=%d inode=%ld %d:%d perm=0%o "
                                                                szType, sb.st_nlink, sb.st_ino, sb.st_uid, sb.st_gid,                                                                 "size=%ld %s", szType, sb.st_nlink, 
                                                                sb.st_mode & 0x1fff, sb.st_size, szStr);                                                                (long) sb.st_ino, sb.st_uid, sb.st_gid, 
                                                                 sb.st_mode & 0x1fff, (long) sb.st_size, 
                                                                 szStr);
                                         }                                          }
                                 }                                  }
   
Line 375  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 397  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 422  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.1.2.3  
changed lines
  Added in v.1.4.6.1

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