Annotation of libaitsync/src/dir.c, revision 1.3.2.2

1.2       misho       1: /*************************************************************************
                      2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
                      3: *  by Michael Pounov <misho@openbsd-bg.org>
                      4: *
                      5: * $Author: misho $
1.3.2.2 ! misho       6: * $Id: dir.c,v 1.3.2.1 2012/11/13 10:30:44 misho Exp $
1.2       misho       7: *
                      8: **************************************************************************
                      9: The ELWIX and AITNET software is distributed under the following
                     10: terms:
                     11: 
                     12: All of the documentation and software included in the ELWIX and AITNET
                     13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
                     14: 
1.3       misho      15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
1.2       misho      16:        by Michael Pounov <misho@elwix.org>.  All rights reserved.
                     17: 
                     18: Redistribution and use in source and binary forms, with or without
                     19: modification, are permitted provided that the following conditions
                     20: are met:
                     21: 1. Redistributions of source code must retain the above copyright
                     22:    notice, this list of conditions and the following disclaimer.
                     23: 2. Redistributions in binary form must reproduce the above copyright
                     24:    notice, this list of conditions and the following disclaimer in the
                     25:    documentation and/or other materials provided with the distribution.
                     26: 3. All advertising materials mentioning features or use of this software
                     27:    must display the following acknowledgement:
                     28: This product includes software developed by Michael Pounov <misho@elwix.org>
                     29: ELWIX - Embedded LightWeight unIX and its contributors.
                     30: 4. Neither the name of AITNET nor the names of its contributors
                     31:    may be used to endorse or promote products derived from this software
                     32:    without specific prior written permission.
                     33: 
                     34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
                     35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     37: ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     44: SUCH DAMAGE.
                     45: */
                     46: #include "global.h"
                     47: 
                     48: 
                     49: static int
                     50: func_comp(struct tagDirName const *d1, struct tagDirName const *d2)
                     51: {
                     52:        return d1->tag - d2->tag;
                     53: }
                     54: 
                     55: static struct tagDirName *
                     56: find_tag(int const * __restrict tags, struct tagDirName const * __restrict l, u_short t, u_int hash)
                     57: {
                     58:        struct tagDirName *find = NULL;
                     59:        register int i;
                     60: 
1.3.2.2 ! misho      61:        /* search in index tags */
1.2       misho      62:        if (tags[t] != -1 && l[tags[t]].tag == t) {
1.3.2.2 ! misho      63:                /* search in sorted hashes */
1.2       misho      64:                for (i = 0; l[tags[t] + i].tag == t; i++)
                     65:                        if (l[tags[t] + i].hash == hash) {
1.3.2.2 ! misho      66:                                /* finded & marked for delete! */
1.2       misho      67:                                find = (struct tagDirName*) &l[tags[t] + i];
                     68:                                find->ch = '*';
                     69:                                break;
                     70:                        }
                     71:        }
                     72: 
                     73:        return find;
                     74: }
                     75: 
                     76: static int *
                     77: create_tags()
                     78: {
                     79:        int *tags;
                     80: 
                     81:        tags = calloc(TABLESIZ, sizeof(int));
                     82:        if (!tags) {
1.3.2.1   misho      83:                LOGERR;
1.2       misho      84:        } else
                     85:                memset(tags, -1, TABLESIZ * sizeof(int));
                     86: 
                     87:        return tags;
                     88: }
                     89: 
                     90: static int
                     91: create_diridx(const char *csDir, int lm, int *tags, struct tagDirName **list)
                     92: {
                     93:        struct tagDirName *l = *list;
                     94:        DIR *dir;
                     95:        struct dirent d, *pd;
                     96:        int n;
                     97:        char szStr[STRSIZ], szType[STRSIZ], *old;
                     98:        struct stat sb;
                     99:        register int i;
                    100: 
                    101:        l = malloc(sizeof(struct tagDirName));
                    102:        if (!l) {
1.3.2.1   misho     103:                LOGERR;
1.2       misho     104:                *list = NULL;
                    105:                return -1;
                    106:        } else {
                    107:                n = 0;
                    108:                memset(l, 0, sizeof(struct tagDirName));
                    109:        }
                    110: 
                    111:        old = getcwd(NULL, 0);
                    112:        if (chdir(csDir) == -1) {
1.3.2.1   misho     113:                LOGERR;
1.2       misho     114:                free(old);
                    115:                free(l);
                    116:                *list = NULL;
                    117:                return -1;
                    118:        }
                    119:        dir = opendir(".");
                    120:        if (!dir) {
1.3.2.1   misho     121:                LOGERR;
1.2       misho     122:                chdir(old);
                    123:                free(old);
                    124:                free(l);
                    125:                *list = NULL;
                    126:                return -1;
                    127:        }
                    128:        while (!readdir_r(dir, &d, &pd) && pd) {
                    129:                if (d.d_type == DT_DIR && (!strcmp(d.d_name, ".") || !strcmp(d.d_name, "..")))
                    130:                        continue;
                    131: 
                    132:                l = realloc(l, sizeof(struct tagDirName) * (n + 2));
                    133:                if (!l) {
1.3.2.1   misho     134:                        LOGERR;
1.2       misho     135:                        chdir(old);
                    136:                        free(old);
                    137:                        free(l);
                    138:                        *list = NULL;
                    139:                        closedir(dir);
                    140:                        return -1;
                    141:                } else
                    142:                        memset(&l[n + 1], 0, sizeof(struct tagDirName));
                    143: 
                    144:                l[n].ch = '<';
1.3.2.2 ! misho     145:                l[n].tag = crcFletcher16((u_short*) d.d_name, 
        !           146:                                d.d_namlen / 2 + d.d_namlen % 2);
1.2       misho     147:                l[n].hash = crcAdler((u_char*) d.d_name, d.d_namlen);
                    148:                strlcpy(l[n].name, d.d_name, MAXPATHLEN);
                    149:                if (lm & 1) {
                    150:                        if (lstat(d.d_name, &sb) != -1) {
                    151:                                memset(szStr, 0, STRSIZ);
                    152: #if defined(__OpenBSD__)
1.3.2.2 ! misho     153:                                strftime(szStr, STRSIZ, "%Y-%m-%d %H:%M:%S", 
        !           154:                                                localtime((time_t*) &sb.st_mtim));
1.2       misho     155: #else
1.3.2.2 ! misho     156:                                strftime(szStr, STRSIZ, "%Y-%m-%d %H:%M:%S", 
        !           157:                                                localtime((time_t*) &sb.st_mtime));
1.2       misho     158: #endif
                    159:                                switch (d.d_type) {
                    160:                                        case DT_FIFO:
                    161:                                                strlcpy(szType, "fifo", STRSIZ);
                    162:                                                break;
                    163:                                        case DT_CHR:
                    164:                                                strlcpy(szType, "char", STRSIZ);
                    165:                                                break;
                    166:                                        case DT_DIR:
                    167:                                                strlcpy(szType, "dir", STRSIZ);
                    168:                                                break;
                    169:                                        case DT_BLK:
                    170:                                                strlcpy(szType, "block", STRSIZ);
                    171:                                                break;
                    172:                                        case DT_REG:
                    173:                                                strlcpy(szType, "file", STRSIZ);
                    174:                                                break;
                    175:                                        case DT_LNK:
                    176:                                                strlcpy(szType, "link", STRSIZ);
                    177:                                                break;
                    178:                                        case DT_SOCK:
                    179:                                                strlcpy(szType, "socket", STRSIZ);
                    180:                                                break;
                    181: /* OpenBSD does not have this type */
                    182: #ifdef DT_WHT
                    183:                                        case DT_WHT:
                    184:                                                strlcpy(szType, "wht", STRSIZ);
                    185:                                                break;
                    186: #endif
                    187:                                        case DT_UNKNOWN:
                    188:                                        default:
                    189:                                                strlcpy(szType, "unknown", STRSIZ);
                    190:                                                break;
                    191:                                }
1.3.2.2 ! misho     192:                                snprintf(l[n].extra, STRSIZ, 
        !           193:                                                "%s links=%d inode=%ld %d:%d perm=0%o size=%ld %s", 
        !           194:                                                szType, sb.st_nlink, (long) sb.st_ino, 
        !           195:                                                sb.st_uid, sb.st_gid, sb.st_mode & 0x1fff, 
        !           196:                                                (long) sb.st_size, szStr);
1.2       misho     197:                        }
                    198:                }
                    199: 
                    200:                n++;
                    201:        }
                    202:        closedir(dir);
                    203: 
                    204:        qsort(l, n, sizeof(struct tagDirName), (int (*)(const void*, const void*)) func_comp);
                    205:        for (i = n - 1; i > -1; i--)
                    206:                tags[l[i].tag] = i;
                    207: 
                    208:        chdir(old);
                    209:        free(old);
                    210: 
                    211:        *list = l;
                    212:        return n;
                    213: }
                    214: 
1.3.2.2 ! misho     215: /* ------------------------------------------------------ */
1.2       misho     216: 
                    217: /*
1.3.2.2 ! misho     218:  * sync_dirChkSum() - Calculate checksum of directory
        !           219:  *
1.2       misho     220:  * @csDir = Directory
1.3.2.2 ! misho     221:  * @md = Message digest allocated memory, must be free() after use!
1.2       misho     222:  * return: -1 error or !=-1 ok
                    223:  */
                    224: int
1.3.2.2 ! misho     225: sync_dirChkSum(const char *csDir, u_char **md)
1.2       misho     226: {
                    227:        DIR *dir;
                    228:        struct dirent d, *pd;
                    229:        MD5_CTX ctx;
                    230:        register int ret = 0;
                    231: 
                    232:        *md = malloc(MD5_DIGEST_LENGTH);
                    233:        if (!*md) {
1.3.2.1   misho     234:                LOGERR;
1.2       misho     235:                return -1;
                    236:        } else
                    237:                memset(*md, 0, MD5_DIGEST_LENGTH);
                    238: 
                    239:        dir = opendir(csDir);
                    240:        if (!dir) {
1.3.2.1   misho     241:                LOGERR;
1.2       misho     242:                free(*md);
                    243:                return -1;
                    244:        }
                    245: 
                    246:        MD5_Init(&ctx);
                    247:        while (!readdir_r(dir, &d, &pd) && pd) {
                    248:                if (d.d_type == DT_DIR && (!strcmp(d.d_name, ".") || !strcmp(d.d_name, "..")))
                    249:                        continue;
                    250:                MD5_Update(&ctx, d.d_name, d.d_namlen);
                    251:                ret++;
                    252:        }
                    253:        MD5_Final(*md, &ctx);
                    254: 
                    255:        closedir(dir);
                    256:        return ret;
                    257: }
                    258: 
                    259: /*
1.3.2.2 ! misho     260:  * sync_dircmp() - Compare directories
        !           261:  *
1.2       misho     262:  * @csDir1 = Directory 1
                    263:  * @csDir2 = Directory 2
                    264:  * return: -1 error, 0 is equal or 1 different
                    265:  */
                    266: int
                    267: sync_dircmp(const char *csDir1, const char *csDir2)
                    268: {
                    269:        u_char *md[2] = { NULL, NULL };
                    270:        int ret = -1;
                    271: 
                    272:        if (!csDir1 || !csDir2)
                    273:                return ret;
                    274: 
1.3.2.2 ! misho     275:        if (sync_dirChkSum(csDir1, &md[0]) == -1)
1.2       misho     276:                return ret;
1.3.2.2 ! misho     277:        if (sync_dirChkSum(csDir2, &md[1]) == -1) {
1.2       misho     278:                free(md[0]);
                    279:                return ret;
                    280:        }
                    281: 
                    282:        if (!memcmp(md[0], md[1], MD5_DIGEST_LENGTH))
                    283:                ret = 0;
                    284:        else
                    285:                ret = 1;
                    286: 
                    287:        free(md[1]);
                    288:        free(md[0]);
                    289:        return ret;
                    290: }
                    291: 
                    292: /*
1.3.2.2 ! misho     293:  * sync_dircmpList() - Compare directories or directory and file list
        !           294:  *
1.2       misho     295:  * @csDir1 = Directory 1
                    296:  * @csDir2 = Directory 2 or File list, if "-" get input from console
1.3.2.2 ! misho     297:  * @lm = Long mode options, !=NULL long output
        !           298:  * @list = Output diff list, after use must be free()!
1.2       misho     299:  * return: -1 error, 0 is equal or >0 count of returned list items
                    300:  */
                    301: int
                    302: sync_dircmpList(const char *csDir1, const char *csDir2, int lm, struct tagDirName **list)
                    303: {
                    304:        struct tagDirName *l, *find;
                    305:        int n, cx;
                    306:        DIR *dir;
                    307:        FILE *f = stdin;
                    308:        struct dirent d, *pd;
                    309:        int *tags;
                    310:        register int i;
                    311:        u_short t;
                    312:        u_int hash;
                    313:        struct stat sb;
                    314:        char szLine[STRSIZ], szStr[STRSIZ], szType[STRSIZ], *str, *pbrk, *old;
                    315: 
                    316:        if (!csDir1 || !list || !(tags = create_tags()))
                    317:                return -1;
                    318: 
                    319:        n = create_diridx(csDir1, lm, tags, &l);
                    320:        if (n == -1 || !csDir2) {
                    321:                *list = l;
                    322:                return n;
                    323:        }
                    324: 
                    325:        if (lstat(csDir2, &sb) == -1) {
1.3.2.1   misho     326:                LOGERR;
1.2       misho     327:                free(l);
                    328:                return -1;
                    329:        }
                    330:        if (S_ISDIR(sb.st_mode)) {
                    331:                old = getcwd(NULL, 0);
                    332:                if (chdir(csDir2) == -1) {
1.3.2.1   misho     333:                        LOGERR;
1.2       misho     334:                        chdir(old);
                    335:                        free(old);
                    336:                        free(l);
                    337:                        return -1;
                    338:                }
                    339:                dir = opendir(".");
                    340:                if (!dir) {
1.3.2.1   misho     341:                        LOGERR;
1.2       misho     342:                        chdir(old);
                    343:                        free(old);
                    344:                        free(l);
                    345:                        return -1;
                    346:                }
                    347:                while (!readdir_r(dir, &d, &pd) && pd) {
                    348:                        if (d.d_type == DT_DIR && (!strcmp(d.d_name, ".") || !strcmp(d.d_name, "..")))
                    349:                                continue;
                    350:                        else {
                    351:                                t = crcFletcher16((u_short*) d.d_name, d.d_namlen / 2 + d.d_namlen % 2);
                    352:                                hash = crcAdler((u_char*) d.d_name, d.d_namlen);
                    353:                        }
                    354: 
                    355:                        find = find_tag(tags, l, t, hash);
1.3.2.2 ! misho     356:                        /* element not find in dir1, added */
1.2       misho     357:                        if (!find) {
                    358:                                l = realloc(l, sizeof(struct tagDirName) * (n + 2));
                    359:                                if (!l) {
1.3.2.1   misho     360:                                        LOGERR;
1.2       misho     361:                                        chdir(old);
                    362:                                        free(old);
                    363:                                        closedir(dir);
                    364:                                        return -1;
                    365:                                } else
                    366:                                        memset(&l[n + 1], 0, sizeof(struct tagDirName));
                    367: 
                    368:                                l[n].ch = '>';
                    369:                                l[n].tag = t;
                    370:                                l[n].hash = hash;
                    371:                                strlcpy(l[n].name, d.d_name, MAXPATHLEN);
                    372:                                if (lm & 1) {
                    373:                                        if (lstat(d.d_name, &sb) != -1) {
                    374:                                                memset(szStr, 0, STRSIZ);
                    375: #if defined(__OpenBSD__)
                    376:                                                strftime(szStr, STRSIZ, "%Y-%m-%d %H:%M:%S", 
                    377:                                                                localtime((time_t*) &sb.st_mtim));
                    378: #else
                    379:                                                strftime(szStr, STRSIZ, "%Y-%m-%d %H:%M:%S", 
                    380:                                                                localtime((time_t*) &sb.st_mtime));
                    381: #endif
                    382:                                                switch (d.d_type) {
                    383:                                                        case DT_FIFO:
                    384:                                                                strlcpy(szType, "fifo", STRSIZ);
                    385:                                                                break;
                    386:                                                        case DT_CHR:
                    387:                                                                strlcpy(szType, "char", STRSIZ);
                    388:                                                                break;
                    389:                                                        case DT_DIR:
                    390:                                                                strlcpy(szType, "dir", STRSIZ);
                    391:                                                                break;
                    392:                                                        case DT_BLK:
                    393:                                                                strlcpy(szType, "block", STRSIZ);
                    394:                                                                break;
                    395:                                                        case DT_REG:
                    396:                                                                strlcpy(szType, "file", STRSIZ);
                    397:                                                                break;
                    398:                                                        case DT_LNK:
                    399:                                                                strlcpy(szType, "link", STRSIZ);
                    400:                                                                break;
                    401:                                                        case DT_SOCK:
                    402:                                                                strlcpy(szType, "socket", STRSIZ);
                    403:                                                                break;
                    404: /* OpenBSD does not have this type */
                    405: #ifdef DT_WHT
                    406:                                                        case DT_WHT:
                    407:                                                                strlcpy(szType, "wht", STRSIZ);
                    408:                                                                break;
                    409: #endif
                    410:                                                        case DT_UNKNOWN:
                    411:                                                        default:
                    412:                                                                strlcpy(szType, "unknown", STRSIZ);
                    413:                                                                break;
                    414:                                                }
                    415:                                                snprintf(l[n].extra, STRSIZ, 
1.3.2.2 ! misho     416:                                                                "%s links=%d inode=%ld %d:%d perm=0%o "
        !           417:                                                                "size=%ld %s", szType, sb.st_nlink, 
        !           418:                                                                (long) sb.st_ino, sb.st_uid, sb.st_gid, 
        !           419:                                                                sb.st_mode & 0x1fff, (long) sb.st_size, 
1.3       misho     420:                                                                szStr);
1.2       misho     421:                                        }
                    422:                                }
                    423: 
                    424:                                n++;
                    425:                        }
                    426:                }
                    427:                closedir(dir);
                    428:                chdir(old);
                    429:                free(old);
                    430:        } else {
                    431:                if (strcmp(csDir2, "-")) {
                    432:                        f = fopen(csDir2, "r");
                    433:                        if (!f) {
1.3.2.1   misho     434:                                LOGERR;
1.2       misho     435:                                free(l);
                    436:                                return -1;
                    437:                        }
                    438:                }
                    439:                while (fgets(szLine, STRSIZ, f)) {
                    440:                        if (!*szLine || *szLine == '#')
                    441:                                continue;
                    442: 
                    443:                        str = strtok_r(szLine, " \t", &pbrk);
                    444:                        if (!str)
                    445:                                continue;
                    446:                        str = strtok_r(NULL, " \t", &pbrk);
                    447:                        if (!str)
                    448:                                continue;
                    449:                        else {
                    450:                                i = strlen(str);
                    451:                                t = crcFletcher16((u_short*) str, i / 2 + i % 2);
                    452:                                hash = crcAdler((u_char*) str, i);
                    453:                        }
                    454: 
                    455:                        find = find_tag(tags, l, t, hash);
1.3.2.2 ! misho     456:                        /* element not find in dir1, added */
1.2       misho     457:                        if (!find) {
                    458:                                l = realloc(l, sizeof(struct tagDirName) * (n + 2));
                    459:                                if (!l) {
1.3.2.1   misho     460:                                        LOGERR;
1.2       misho     461:                                        if (strcmp(csDir2, "-"))
                    462:                                                fclose(f);
                    463:                                        return -1;
                    464:                                } else
                    465:                                        memset(&l[n + 1], 0, sizeof(struct tagDirName));
                    466: 
                    467:                                l[n].ch = '>';
                    468:                                l[n].tag = t;
                    469:                                l[n].hash = hash;
                    470:                                strlcpy(l[n].name, str, MAXPATHLEN);
                    471:                                if (lm & 1 && (str = strtok_r(NULL, "\r\n", &pbrk)))
                    472:                                        strlcpy(l[n].extra, str, STRSIZ);
                    473: 
                    474:                                n++;
                    475:                        }
                    476:                }
                    477:                if (strcmp(csDir2, "-"))
                    478:                        fclose(f);
                    479:        }
                    480: 
1.3.2.2 ! misho     481:        /* delete equal elemets !!! */
1.2       misho     482:        for (i = cx = 0; i < n; i++)
                    483:                if (l[i].ch == '*') {
                    484:                        memmove(&l[i], &l[i + 1], (n - i + 1) * sizeof(struct tagDirName));
                    485:                        cx++;
                    486:                        i--;
                    487:                }
                    488:        n -= cx;
                    489: 
                    490:        *list = l;
                    491:        return n;
                    492: }

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