← Back to branch summary

~yolanda.robla/ubuntu/saucy/clamav/dep-8-tests

« back to all changes in this revision

Viewing changes to libclamav/readdb.c

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2009-11-02 23:27:19 UTC
  • mfrom: (0.35.9 sid)
  • Revision ID: james.westby@ubuntu.com-20091102232719-61ay35095dhbuxfm
Tags: 0.95.3+dfsg-1ubuntu1
* Merge from debian unstable, remaining changes:
  - Drop build-dep on electric-fence (in Universe)
  - Build-dep on libltdl3-dev instead of libltdl-dev for updating earlier
    releases more easily
  - Add apparmor profiles for clamd and freshclam along with maintainer
    script changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/readdb.c
39
39
#endif
40
40
#include <fcntl.h>
41
41
#include <zlib.h>
 
42
#include <errno.h>
42
43
 
43
44
#include "clamav.h"
44
45
#include "cvd.h"
82
83
};
83
84
 
84
85
struct cli_ignored {
85
 
    struct hashset hs;
 
86
    struct cli_hashset hs;
86
87
    struct cli_ignsig *list;
87
88
};
88
89
 
370
371
    if(!ignored || !dbname || !signame)
371
372
        return 0;
372
373
 
373
 
    if(hashset_contains(&ignored->hs, line)) {
 
374
    if(cli_hashset_contains(&ignored->hs, line)) {
374
375
        pt = ignored->list;
375
376
        while(pt) {
376
377
            if(pt->line == line && !strcmp(pt->dbname, dbname) && !strcmp(pt->signame, signame)) {
583
584
 
584
585
        if(tokens_count > 4) { /* min version */
585
586
            pt = tokens[4];
586
 
            if(!isdigit(*pt)) {
 
587
 
 
588
            if(!cli_isnumber(pt)) {
587
589
                ret = CL_EMALFDB;
588
590
                break;
589
591
            }
595
597
 
596
598
            if(tokens_count == 6) { /* max version */
597
599
                pt = tokens[5];
598
 
                if(!isdigit(*pt)) {
 
600
                if(!cli_isnumber(pt)) {
599
601
                    ret = CL_EMALFDB;
600
602
                    break;
601
603
                }
606
608
            }
607
609
        }
608
610
 
609
 
        if(!(pt = tokens[1]) || !isdigit(*pt)) {
 
611
        if(!(pt = tokens[1]) || (strcmp(pt, "*") && !cli_isnumber(pt))) {
610
612
            ret = CL_EMALFDB;
611
613
            break;
612
614
        }
717
719
 
718
720
        switch(apt->type) {
719
721
            case CLI_TDB_UINT:
 
722
                if(!cli_isnumber(pt)) {
 
723
                    cli_errmsg("lsigattribs: Invalid argument for %s\n", tokens[i]);
 
724
                    return -1;
 
725
                }
720
726
                off[i] = cnt = tdb->cnt[CLI_TDB_UINT]++;
721
727
                tdb->val = (uint32_t *) mpool_realloc2(tdb->mempool, tdb->val, tdb->cnt[CLI_TDB_UINT] * sizeof(uint32_t));
722
728
                if(!tdb->val) {
739
745
                    tdb->cnt[CLI_TDB_RANGE] = 0;
740
746
                    return -1;
741
747
                }
 
748
                if(!cli_isnumber(pt) || !cli_isnumber(pt2)) {
 
749
                    cli_errmsg("lsigattribs: Invalid argument for %s\n", tokens[i]);
 
750
                    return -1;
 
751
                }
742
752
                tdb->range[cnt] = atoi(pt);
743
753
                tdb->range[cnt + 1] = atoi(pt2);
744
754
                break;
945
955
        root->ac_lsigtable = newtable;
946
956
 
947
957
        for(i = 0; i < subsigs; i++) {
948
 
            if(i >= tokens_count) {
 
958
            if(i + 3 >= tokens_count) {
949
959
                cli_errmsg("cli_loadldb: Missing subsignature id %u\n", i);
950
960
                ret = CL_EMALFDB;
951
961
                break;
1056
1066
            break;
1057
1067
        }
1058
1068
 
 
1069
        if(!cli_isnumber(tokens[0])) {
 
1070
            cli_errmsg("cli_loadftm: Invalid value for the first field\n");
 
1071
            ret = CL_EMALFDB;
 
1072
            break;
 
1073
        }
 
1074
 
1059
1075
        if(atoi(tokens[0]) == 1) { /* A-C */
1060
1076
            if((ret = cli_parse_add(engine->root[0], tokens[3], tokens[2], rtype, type, strcmp(tokens[1], "*") ? tokens[1] : NULL, 0, NULL, options)))
1061
1077
                break;
1062
1078
 
1063
1079
        } else if(atoi(tokens[0]) == 0) { /* memcmp() */
 
1080
            if(!cli_isnumber(tokens[1])) {
 
1081
                cli_errmsg("cli_loadftm: Invalid offset\n");
 
1082
                ret = CL_EMALFDB;
 
1083
                break;
 
1084
            }
1064
1085
            new = (struct cli_ftype *) mpool_malloc(engine->mempool, sizeof(struct cli_ftype));
1065
1086
            if(!new) {
1066
1087
                ret = CL_EMEM;
1119
1140
 
1120
1141
    if(!engine->ignored) {
1121
1142
        engine->ignored = (struct cli_ignored *) cli_calloc(sizeof(struct cli_ignored), 1);
1122
 
        if(!engine->ignored || hashset_init(&engine->ignored->hs, 64, 50))
 
1143
        if(!engine->ignored || cli_hashset_init(&engine->ignored->hs, 64, 50))
1123
1144
            return CL_EMEM;
1124
1145
    }
1125
1146
 
1132
1153
            break;
1133
1154
        }
1134
1155
 
 
1156
        if(!cli_isnumber(tokens[1])) {
 
1157
            cli_errmsg("cli_loadign: Invalid entry for line number\n");
 
1158
            ret = CL_EMALFDB;
 
1159
            break;
 
1160
        }
 
1161
 
1135
1162
        new = (struct cli_ignsig *) mpool_calloc(engine->mempool, 1, sizeof(struct cli_ignsig));
1136
1163
        if(!new) {
1137
1164
            ret = CL_EMEM;
1148
1175
 
1149
1176
        new->line = atoi(tokens[1]);
1150
1177
 
1151
 
        if((ret = hashset_addkey(&engine->ignored->hs, new->line)))
 
1178
        if((ret = cli_hashset_addkey(&engine->ignored->hs, new->line)))
1152
1179
            break;
1153
1180
 
1154
1181
        new->signame = cli_mpool_strdup(engine->mempool, tokens[2]);
1184
1211
            mpool_free(engine->mempool, pt->signame);
1185
1212
            mpool_free(engine->mempool,pt);
1186
1213
        }
1187
 
        hashset_destroy(&ignored->hs);
 
1214
        cli_hashset_destroy(&ignored->hs);
1188
1215
        free(engine->ignored);
1189
1216
        engine->ignored = NULL;
1190
1217
    }
1242
1269
        const char *pt;
1243
1270
        int ret = CL_SUCCESS;
1244
1271
        unsigned int size_field = 1, md5_field = 0, line = 0, sigs = 0, tokens_count;
1245
 
        uint32_t size;
1246
1272
        struct cli_bm_patt *new;
1247
1273
        struct cli_matcher *db = NULL;
1248
1274
 
1260
1286
            ret = CL_EMALFDB;
1261
1287
            break;
1262
1288
        }
 
1289
        if(!cli_isnumber(tokens[size_field])) {
 
1290
            cli_errmsg("cli_loadmd5: Invalid value for the size field\n");
 
1291
            ret = CL_EMALFDB;
 
1292
            break;
 
1293
        }
1263
1294
 
1264
1295
        pt = tokens[2]; /* virname */
1265
1296
        if(engine->pua_cats && (options & CL_DB_PUA_MODE) && (options & (CL_DB_PUA_INCLUDE | CL_DB_PUA_EXCLUDE)))
1284
1315
        }
1285
1316
        new->length = 16;
1286
1317
 
1287
 
        size = atoi(tokens[size_field]);
 
1318
        new->filesize = atoi(tokens[size_field]);
1288
1319
 
1289
1320
        new->virname = cli_mpool_virname(engine->mempool, (char *) tokens[2], options & CL_DB_OFFICIAL);
1290
1321
        if(!new->virname) {
1314
1345
 
1315
1346
        if(mode == MD5_MDB) { /* section MD5 */
1316
1347
            if(!db->md5_sizes_hs.capacity) {
1317
 
                    hashset_init(&db->md5_sizes_hs, 65536, 80);
 
1348
                    cli_hashset_init(&db->md5_sizes_hs, 65536, 80);
1318
1349
            }
1319
 
            hashset_addkey(&db->md5_sizes_hs, size);
 
1350
            cli_hashset_addkey(&db->md5_sizes_hs, new->filesize);
1320
1351
        }
1321
1352
 
1322
1353
        sigs++;
1360
1391
            break;
1361
1392
        }
1362
1393
 
 
1394
        if(strcmp(tokens[1], "*") && !cli_isnumber(tokens[1])) {
 
1395
            cli_errmsg("cli_loadmd: Invalid value for the 'encrypted' field\n");
 
1396
            ret = CL_EMALFDB;
 
1397
            break;
 
1398
        }
 
1399
        if(strcmp(tokens[3], "*") && !cli_isnumber(tokens[3])) {
 
1400
            cli_errmsg("cli_loadmd: Invalid value for the 'original size' field\n");
 
1401
            ret = CL_EMALFDB;
 
1402
            break;
 
1403
        }
 
1404
        if(strcmp(tokens[4], "*") && !cli_isnumber(tokens[4])) {
 
1405
            cli_errmsg("cli_loadmd: Invalid value for the 'compressed size' field\n");
 
1406
            ret = CL_EMALFDB;
 
1407
            break;
 
1408
        }
 
1409
        if(strcmp(tokens[6], "*") && !cli_isnumber(tokens[6])) {
 
1410
            cli_errmsg("cli_loadmd: Invalid value for the 'compression method' field\n");
 
1411
            ret = CL_EMALFDB;
 
1412
            break;
 
1413
        }
 
1414
        if(strcmp(tokens[7], "*") && !cli_isnumber(tokens[7])) {
 
1415
            cli_errmsg("cli_loadmd: Invalid value for the 'file number' field\n");
 
1416
            ret = CL_EMALFDB;
 
1417
            break;
 
1418
        }
 
1419
        if(strcmp(tokens[8], "*") && !cli_isnumber(tokens[8])) {
 
1420
            cli_errmsg("cli_loadmd: Invalid value for the 'max depth' field\n");
 
1421
            ret = CL_EMALFDB;
 
1422
            break;
 
1423
        }
 
1424
 
1363
1425
        new = (struct cli_meta_node *) mpool_calloc(engine->mempool, 1, sizeof(struct cli_meta_node));
1364
1426
        if(!new) {
1365
1427
            ret = CL_EMEM;
1467
1529
 
1468
1530
 
1469
1531
    if(!dbio && (fs = fopen(filename, "rb")) == NULL) {
 
1532
        if(options & CL_DB_DIRECTORY) { /* bb#1624 */
 
1533
            if(access(filename, R_OK)) {
 
1534
                if(errno == ENOENT) {
 
1535
                    cli_dbgmsg("Detected race condition, ignoring old file %s\n", filename);
 
1536
                    return CL_SUCCESS;
 
1537
                }
 
1538
            }
 
1539
        }
1470
1540
        cli_errmsg("cli_load(): Can't open file %s\n", filename);
1471
1541
        return CL_EOPEN;
1472
1542
    }
1711
1781
            break;
1712
1782
 
1713
1783
        case S_IFDIR:
1714
 
            ret = cli_loaddbdir(path, engine, signo, dboptions);
 
1784
            ret = cli_loaddbdir(path, engine, signo, dboptions | CL_DB_DIRECTORY);
1715
1785
            break;
1716
1786
 
1717
1787
        default:
1983
2053
        cli_bm_free(root);
1984
2054
        mpool_free(engine->mempool, root->soff);
1985
2055
        if(root->md5_sizes_hs.capacity) {
1986
 
                hashset_destroy(&root->md5_sizes_hs);
 
2056
                cli_hashset_destroy(&root->md5_sizes_hs);
1987
2057
        }
1988
2058
        mpool_free(engine->mempool, root);
1989
2059
    }
2044
2114
                uint32_t *mpoolht;
2045
2115
                unsigned int mpoolhtsz = root->md5_sizes_hs.count * sizeof(*mpoolht);
2046
2116
                root->soff = mpool_malloc(root->mempool, mpoolhtsz);
2047
 
                root->soff_len = hashset_toarray(&root->md5_sizes_hs, &mpoolht);
 
2117
                root->soff_len = cli_hashset_toarray(&root->md5_sizes_hs, &mpoolht);
2048
2118
                memcpy(root->soff, mpoolht, mpoolhtsz);
2049
2119
                free(mpoolht);
2050
2120
                }
2051
2121
#else
2052
 
                root->soff_len = hashset_toarray(&root->md5_sizes_hs, &root->soff);
 
2122
                root->soff_len = cli_hashset_toarray(&root->md5_sizes_hs, &root->soff);
2053
2123
#endif
2054
 
                hashset_destroy(&root->md5_sizes_hs);
 
2124
                cli_hashset_destroy(&root->md5_sizes_hs);
2055
2125
                qsort(root->soff, root->soff_len, sizeof(uint32_t), scomp);
2056
2126
        }
2057
2127
}