[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.1 and 1.5.4.1

version 1.1.2.1, 2010/07/13 15:04:43 version 1.5.4.1, 2016/08/18 09:53:02
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 - 2016
         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 41  create_tags() Line 78  create_tags()
 {  {
         int *tags;          int *tags;
   
        tags = calloc(TABLESIZ, sizeof(int));        tags = e_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 57  create_diridx(const char *csDir, int lm, int *tags, st Line 94  create_diridx(const char *csDir, int lm, int *tags, st
         DIR *dir;          DIR *dir;
         struct dirent d, *pd;          struct dirent d, *pd;
         int n;          int n;
        char szStr[STRSIZ], szType[STRSIZ];        char szStr[STRSIZ], szType[STRSIZ], *old;
         struct stat sb;          struct stat sb;
         register int i;          register int i;
   
        l = malloc(sizeof(struct tagDirName));        l = e_malloc(sizeof(struct tagDirName));
         if (!l) {          if (!l) {
                SETERR;                LOGERR;
                 *list = NULL;                  *list = NULL;
                 return -1;                  return -1;
         } else {          } else {
Line 71  create_diridx(const char *csDir, int lm, int *tags, st Line 108  create_diridx(const char *csDir, int lm, int *tags, st
                 memset(l, 0, sizeof(struct tagDirName));                  memset(l, 0, sizeof(struct tagDirName));
         }          }
   
           old = getcwd(NULL, 0);
         if (chdir(csDir) == -1) {          if (chdir(csDir) == -1) {
                SETERR;                LOGERR;
                free(l);                e_free(old);
                 e_free(l);
                 *list = NULL;                  *list = NULL;
                 return -1;                  return -1;
         }          }
         dir = opendir(".");          dir = opendir(".");
         if (!dir) {          if (!dir) {
                SETERR;                LOGERR;
                free(l);                chdir(old);
                 e_free(old);
                 e_free(l);
                 *list = NULL;                  *list = NULL;
                 return -1;                  return -1;
         }          }
Line 88  create_diridx(const char *csDir, int lm, int *tags, st Line 129  create_diridx(const char *csDir, int lm, int *tags, st
                 if (d.d_type == DT_DIR && (!strcmp(d.d_name, ".") || !strcmp(d.d_name, "..")))                  if (d.d_type == DT_DIR && (!strcmp(d.d_name, ".") || !strcmp(d.d_name, "..")))
                         continue;                          continue;
   
                l = realloc(l, sizeof(struct tagDirName) * (n + 2));                l = e_realloc(l, sizeof(struct tagDirName) * (n + 2));
                 if (!l) {                  if (!l) {
                        SETERR;                        LOGERR;
                        free(l);                        chdir(old);
                         e_free(old);
                         e_free(l);
                         *list = NULL;                          *list = NULL;
                         closedir(dir);                          closedir(dir);
                         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_D1;
                l[n].tag = crcFletcher16((u_short*) d.d_name, d.d_namlen / 2 + d.d_namlen % 2);#ifndef __linux__
                 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);#else
                 l[n].tag = crcFletcher16((u_short*) d.d_name, 
                                 strlen(d.d_name) / 2 + strlen(d.d_name) % 2);
                 l[n].hash = crcAdler((u_char*) d.d_name, strlen(d.d_name));
 #endif
                 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 */
   #ifdef DT_WHT
                                         case DT_WHT:                                          case DT_WHT:
                                                strlcpy(szType, "wht", STRSIZ);                                                strlcpy(szType, "wht", sizeof szType);
                                                 break;                                                  break;
   #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=%ld inode=%ld %d:%d perm=0%o size=%ld %s", 
                                                sb.st_mode & 0x1fff, sb.st_size, szStr);                                                szType, (long) sb.st_nlink, (long) sb.st_ino, 
                                                 sb.st_uid, sb.st_gid, sb.st_mode & 0x1fff, 
                                                 (long) sb.st_size, szStr);
                         }                          }
                 }                  }
   
Line 150  create_diridx(const char *csDir, int lm, int *tags, st Line 211  create_diridx(const char *csDir, int lm, int *tags, st
         for (i = n - 1; i > -1; i--)          for (i = n - 1; i > -1; i--)
                 tags[l[i].tag] = i;                  tags[l[i].tag] = i;
   
           chdir(old);
           e_free(old);
   
         *list = l;          *list = l;
         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 e_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;
         MD5_CTX ctx;          MD5_CTX ctx;
         register int ret = 0;          register int ret = 0;
   
        *md = malloc(MD5_DIGEST_LENGTH);        *md = e_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);                e_free(*md);
                 return -1;                  return -1;
         }          }
   
Line 188  sync_dirCSum(const char *csDir, u_char **md) Line 253  sync_dirCSum(const char *csDir, u_char **md)
         while (!readdir_r(dir, &d, &pd) && pd) {          while (!readdir_r(dir, &d, &pd) && pd) {
                 if (d.d_type == DT_DIR && (!strcmp(d.d_name, ".") || !strcmp(d.d_name, "..")))                  if (d.d_type == DT_DIR && (!strcmp(d.d_name, ".") || !strcmp(d.d_name, "..")))
                         continue;                          continue;
   #ifndef __linux__
                 MD5_Update(&ctx, d.d_name, d.d_namlen);                  MD5_Update(&ctx, d.d_name, d.d_namlen);
   #else
                   MD5_Update(&ctx, d.d_name, strlen(d.d_name));
   #endif
                 ret++;                  ret++;
         }          }
         MD5_Final(*md, &ctx);          MD5_Final(*md, &ctx);
Line 198  sync_dirCSum(const char *csDir, u_char **md) Line 267  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 212  sync_dircmp(const char *csDir1, const char *csDir2) Line 282  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]);                e_free(md[0]);
                 return ret;                  return ret;
         }          }
   
Line 224  sync_dircmp(const char *csDir1, const char *csDir2) Line 294  sync_dircmp(const char *csDir1, const char *csDir2)
         else          else
                 ret = 1;                  ret = 1;
   
        free(md[1]);        e_free(md[1]);
        free(md[0]);        e_free(md[0]);
         return ret;          return ret;
 }  }
   
 /*  /*
 * 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 e_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 250  sync_dircmpList(const char *csDir1, const char *csDir2 Line 321  sync_dircmpList(const char *csDir1, const char *csDir2
         u_short t;          u_short t;
         u_int hash;          u_int hash;
         struct stat sb;          struct stat sb;
        char szLine[STRSIZ], szStr[STRSIZ], szType[STRSIZ], *str, *pbrk;        char szLine[STRSIZ], szStr[STRSIZ], szType[STRSIZ], *str, *pbrk, *old;
   
         if (!csDir1 || !list || !(tags = create_tags()))          if (!csDir1 || !list || !(tags = create_tags()))
                 return -1;                  return -1;
Line 261  sync_dircmpList(const char *csDir1, const char *csDir2 Line 332  sync_dircmpList(const char *csDir1, const char *csDir2
                 return n;                  return n;
         }          }
   
        if (!lstat(csDir2, &sb) && S_ISDIR(sb.st_mode)) {        if (lstat(csDir2, &sb) == -1) {
                 LOGERR;
                 e_free(tags);
                 e_free(l);
                 return -1;
         }
         if (S_ISDIR(sb.st_mode)) {
                 old = getcwd(NULL, 0);
                 if (chdir(csDir2) == -1) {                  if (chdir(csDir2) == -1) {
                        SETERR;                        LOGERR;
                        free(l);                        chdir(old);
                         e_free(old);
                         e_free(tags);
                         e_free(l);
                         return -1;                          return -1;
                 }                  }
                 dir = opendir(".");                  dir = opendir(".");
                 if (!dir) {                  if (!dir) {
                        SETERR;                        LOGERR;
                        free(l);                        chdir(old);
                         e_free(old);
                         e_free(tags);
                         e_free(l);
                         return -1;                          return -1;
                 }                  }
                 while (!readdir_r(dir, &d, &pd) && pd) {                  while (!readdir_r(dir, &d, &pd) && pd) {
                         if (d.d_type == DT_DIR && (!strcmp(d.d_name, ".") || !strcmp(d.d_name, "..")))                          if (d.d_type == DT_DIR && (!strcmp(d.d_name, ".") || !strcmp(d.d_name, "..")))
                                 continue;                                  continue;
                         else {                          else {
   #ifndef __linux__
                                 t = crcFletcher16((u_short*) d.d_name, d.d_namlen / 2 + d.d_namlen % 2);                                  t = crcFletcher16((u_short*) d.d_name, d.d_namlen / 2 + d.d_namlen % 2);
                                 hash = crcAdler((u_char*) d.d_name, d.d_namlen);                                  hash = crcAdler((u_char*) d.d_name, d.d_namlen);
   #else
                                   t = crcFletcher16((u_short*) d.d_name, strlen(d.d_name) / 2 + strlen(d.d_name) % 2);
                                   hash = crcAdler((u_char*) d.d_name, strlen(d.d_name));
   #endif
                         }                          }
   
                         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 = e_realloc(l, sizeof(struct tagDirName) * (n + 2));
                                 if (!l) {                                  if (!l) {
                                        SETERR;                                        LOGERR;
                                         chdir(old);
                                         e_free(old);
                                         closedir(dir);                                          closedir(dir);
                                           e_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 */
   #ifdef DT_WHT
                                                         case DT_WHT:                                                          case DT_WHT:
                                                                strlcpy(szType, "wht", STRSIZ);                                                                strlcpy(szType, "wht", sizeof szType);
                                                                 break;                                                                  break;
   #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=%ld inode=%ld %d:%d perm=0%o "
                                                                szType, sb.st_nlink, sb.st_ino, sb.st_uid, sb.st_gid,                                                                 "size=%ld %s", szType, (long) 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 342  sync_dircmpList(const char *csDir1, const char *csDir2 Line 444  sync_dircmpList(const char *csDir1, const char *csDir2
                         }                          }
                 }                  }
                 closedir(dir);                  closedir(dir);
                   chdir(old);
                   e_free(old);
         } else {          } else {
                 if (strcmp(csDir2, "-")) {                  if (strcmp(csDir2, "-")) {
                         f = fopen(csDir2, "r");                          f = fopen(csDir2, "r");
                         if (!f) {                          if (!f) {
                                SETERR;                                LOGERR;
                                free(l);                                e_free(tags);
                                 e_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 368  sync_dircmpList(const char *csDir1, const char *csDir2 Line 473  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 = e_realloc(l, sizeof(struct tagDirName) * (n + 2));
                                 if (!l) {                                  if (!l) {
                                        SETERR;                                        LOGERR;
                                         if (strcmp(csDir2, "-"))                                          if (strcmp(csDir2, "-"))
                                                 fclose(f);                                                  fclose(f);
                                           e_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 393  sync_dircmpList(const char *csDir1, const char *csDir2 Line 499  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;
   
           e_free(tags);
         *list = l;          *list = l;
         return n;          return n;
 }  }
Removed from v.1.1.2.1  
changed lines
  Added in v.1.5.4.1

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