@@ -1,3 +1,7 @@

+Thu Jun 15 13:57:38 CEST 2006 (tk)

+----------------------------------

+  * sigtool/sigtool.c: major cleanup

+

 Mon Jun 12 14:24:35 BST 2006 (njh)

 ----------------------------------

   * libclamav/message.c:	Better detection of binhex encoded EICAR

@@ -40,363 +40,341 @@

 #include <sys/wait.h>

 #include <dirent.h>

-#include "options.h"

-#include "others.h"

-#include "strings.h"

-#include "md5.h"

-#include "cvd.h"

-#include "str.h"

-#include "memory.h"

-#include "output.h"

-#include "cfgparser.h"

-#include "misc.h"

 #include "vba.h"

-#include "../clamscan/others.h"

-#include "../libclamav/others.h"

-#include "../libclamav/str.h"

-#include "../libclamav/ole2_extract.h"

-#include "../libclamav/htmlnorm.h"

-

-#ifndef	O_BINARY

-#define	O_BINARY	0

-#endif

-

-void help(void);

-char *getdsig(const char *host, const char *user, const char *data);

-void cvdinfo(struct optstruct *opt);

-int build(struct optstruct *opt);

-int unpack(struct optstruct *opt);

-int listdb(const char *filename);

-int listdir(const char *dirname);

-void listsigs(struct optstruct *opt);

+#include "shared/options.h"

+#include "shared/memory.h"

+#include "shared/output.h"

+#include "shared/cfgparser.h"

+#include "shared/misc.h"

-int main(int argc, char **argv)

-{

-        struct optstruct *opt;

-	const char *short_options = "hvVb:i:u:l::";

-	static struct option long_options[] = {

-	    {"help", 0, 0, 'h'},

-	    {"quiet", 0, 0, 0},

-	    {"debug", 0, 0, 0},

-	    {"verbose", 0, 0, 'v'},

-	    {"stdout", 0, 0, 0},

-	    {"version", 0, 0, 'V'},

-	    {"tempdir", 1, 0, 0},

-	    {"hex-dump", 0, 0, 0},

-	    {"md5", 0, 0, 0},

-	    {"html-normalise", 1, 0, 0},

-	    {"build", 1, 0, 'b'},

-	    {"server", 1, 0, 0},

-	    {"unpack", 1, 0, 'u'},

-	    {"unpack-current", 1, 0, 0},

-	    {"info", 1, 0, 'i'},

-	    {"list-sigs", 2, 0, 'l'},

-	    {"vba", 1, 0 ,0},

-	    {"vba-hex", 1, 0, 0},

-	    {0, 0, 0, 0}

-    	};

-

-

-    opt = opt_parse(argc, argv, short_options, long_options, NULL);

-    if(!opt) {

-	mprintf("!Can't parse the command line\n");

-	return 1;

-    }

-

-    if(opt_check(opt, "quiet"))

-	mprintf_quiet = 1;

+#include "libclamav/cvd.h"

+#include "libclamav/others.h"

+#include "libclamav/str.h"

+#include "libclamav/ole2_extract.h"

+#include "libclamav/htmlnorm.h"

-    if(opt_check(opt, "stdout"))

-	mprintf_stdout = 1;

-    if(opt_check(opt, "debug"))

-	cl_debug();

+static int hexdump(void)

+{

+	char buffer[FILEBUFF], *pt;

+	int bytes;

-    if(opt_check(opt, "version")) {

-	print_version();

-	opt_free(opt);

-	exit(0);

-    }

-    if(opt_check(opt, "help")) {

-	opt_free(opt);

-    	help();

+    while((bytes = read(0, buffer, FILEBUFF)) > 0) {

+	pt = cli_str2hex(buffer, bytes);

+	if(write(1, pt, 2 * bytes) == -1) {

+	    logg("!hexdump: Can't write to stdout\n");

+	    free(pt);

+	    return -1;

+	}

+	free(pt);

     }

-    if(opt_check(opt, "hex-dump")) {

-	    char buffer[FILEBUFF];

-	    int bytes;

-	    char *pt;

+    if(bytes == -1)

+	return -1;

-	while((bytes = read(0, buffer, FILEBUFF)) > 0) {

-	    pt = cli_str2hex(buffer, bytes);

-	    write(1, pt, 2 * bytes);

-	    free(pt);

-	}

+    return 0;

+}

-    } else if(opt_check(opt, "md5")) {

-	    char *md5, *filename;

-	    int i;

-	    struct stat sb;

+static int md5sig(struct optstruct *opt)

+{

+	char *md5, *filename;

+	int i;

+	struct stat sb;

-	mprintf_stdout = 1;

-	if(opt->filename) {

-

-	    for(i = 0; (filename = cli_strtok(opt->filename, i, "\t")); i++) {

-		if(stat(filename, &sb) == -1) {

-		    logg("!Can't access file %s\n", filename);

-		    perror(filename);

-		} else {

-		    if((sb.st_mode & S_IFMT) == S_IFREG) {

-			if((md5 = cli_md5file(filename))) {

-			    logg("%s:%d:%s\n", md5, sb.st_size, filename);

-			    free(md5);

-			} else

-			    logg("!Can't generate MD5 checksum for %s\n", filename);

+    if(opt->filename) {

+	for(i = 0; (filename = cli_strtok(opt->filename, i, "\t")); i++) {

+	    if(stat(filename, &sb) == -1) {

+		logg("!md5sig: Can't access file %s\n", filename);

+		perror("md5sig");

+		free(filename);

+		return -1;

+	    } else {

+		if((sb.st_mode & S_IFMT) == S_IFREG) {

+		    if((md5 = cli_md5file(filename))) {

+			logg("%s:%d:%s\n", md5, sb.st_size, filename);

+			free(md5);

+		    } else {

+			logg("!md5sig: Can't generate MD5 checksum for %s\n", filename);

+			free(filename);

+			return -1;

 		    }

 		}

-

-		free(filename);

 	    }

-	} else {

-

-	    md5 = cli_md5stream(stdin, NULL);

-	    logg("%s\n", md5);

-	    free(md5);

-	}

-

-    } else if(opt_check(opt, "html-normalise")) {

-	    int fd;

-

-	if((fd = open(opt_arg(opt, "html-normalise"), O_RDONLY)) == -1) {

-	    logg("Can't open file %s\n", opt_arg(opt, "html-normalise"));

-	    opt_free(opt);

-	    exit(1);

+	    free(filename);

 	}

-	html_normalise_fd(fd, ".", NULL);

-

-	close(fd);

-

-    } else if(opt_check(opt, "build")) {

-	if(!opt_check(opt, "server")) {

-	    logg("!--server is required in this mode\n");

-	    opt_free(opt);

-	    exit(10);

+    } else { /* stream */

+	md5 = cli_md5stream(stdin, NULL);

+	if(!md5) {

+	    logg("!md5sig: Can't generate MD5 checksum for input stream\n");

+	    return -1;

 	}

+	logg("%s\n", md5);

+	free(md5);

+    }

-	build(opt);

+    return 0;

+}

-    } else if(opt_check(opt, "unpack")) {

+static int htmlnorm(struct optstruct *opt)

+{

+	int fd;

-	unpack(opt);

-    } else if(opt_check(opt, "unpack-current")) {

+    if((fd = open(opt_arg(opt, "html-normalise"), O_RDONLY)) == -1) {

+	logg("!htmlnorm: Can't open file %s\n", opt_arg(opt, "html-normalise"));

+	return -1;

+    }

-	unpack(opt);

+    html_normalise_fd(fd, ".", NULL);

+    close(fd);

-    } else if(opt_check(opt, "info")) {

+    return 0;

+}

-	cvdinfo(opt);

+static unsigned int countlines(const char *filename)

+{

+	FILE *fd;

+	char buff[1024];

+	unsigned int lines = 0;

-    } else if(opt_check(opt, "list-sigs")) {

-	listsigs(opt);

+    if((fd = fopen(filename, "r")) == NULL)

+	return 0;

-    } else if(opt_check(opt, "vba") || opt_check(opt, "vba-hex")) {

-            int fd, hex_output=0;

-	    char *dir;

+    while(fgets(buff, sizeof(buff), fd)) {

+	if(buff[0] == '#') continue;

+	lines++;

+    }

+    fclose(fd);

+    return lines;

+}

-	if (opt_check(opt, "vba-hex"))

-		hex_output = 1;

- 

-        /* generate the temporary directory */

-        dir = cli_gentemp(NULL);

-        if(mkdir(dir, 0700)) {

-            logg("vba dump: Can't create temporary directory %s\n", dir);

-	    free(dir);

-	    opt_free(opt);

-            return 1;

-        }

-

-        if((fd = open(opt_arg(opt, "vba"), O_RDONLY)) == -1) {

-	    if((fd = open(opt_arg(opt, "vba-hex"), O_RDONLY)) == -1) {

-        	logg("Can't open file %s\n", opt_arg(opt, "vba"));

-		opt_free(opt);

-        	exit(1);

-	    }

-        }

+static char *getdsig(const char *host, const char *user, const char *data)

+{

+	char buff[256], cmd[128], *pass, *pt;

+        struct sockaddr_in server;

+	int sockd, bread, len;

-        if(cli_ole2_extract(fd, dir, NULL)) {

-            cli_rmdirs(dir);

-            free(dir);

-	    close(fd);

-	    opt_free(opt);

-            return 1;

-        }

-	close(fd);

-        sigtool_vba_scandir(dir, hex_output);

-        cli_rmdirs(dir);

-        free(dir);

+#ifdef PF_INET

+    if((sockd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {

+#else

+    if((sockd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

+#endif

+	perror("socket()");

+	logg("!getdsig: Can't create socket\n");

+	return NULL;

+    }

-    } else {

+    server.sin_family = AF_INET;

+    server.sin_addr.s_addr = inet_addr(host);

+    server.sin_port = htons(33101);

-	help();

+    if(connect(sockd, (struct sockaddr *) &server, sizeof(struct sockaddr_in)) < 0) {

+        close(sockd);

+	perror("connect()");

+	logg("!getdsig: Can't connect to ClamAV Signing Service at %s\n", host);

+	return NULL;

     }

-}

-

-static int countlines(const char *filename)

-{

-	FILE *fd;

-	char buff[65536];

-	int lines = 0;

+    memset(cmd, 0, sizeof(cmd));

+    pass = getpass("Password:");

+    snprintf(cmd, sizeof(cmd) - 16, "ClamSign:%s:%s:", user, pass);

+    len = strlen(cmd);

+    pt = cmd + len;

+    memcpy(pt, data, 16);

+    len += 16;

+    if(write(sockd, cmd, len) < 0) {

+	logg("!getdsig: Can't write to socket\n");

+	close(sockd);

+	memset(cmd, 0, len);

+	memset(pass, 0, strlen(pass));

+	return NULL;

+    }

-    if((fd = fopen(filename, "r")) == NULL)

-	return 0;

+    memset(cmd, 0, len);

+    memset(pass, 0, strlen(pass));

+    memset(buff, 0, sizeof(buff));

-    while(fgets(buff, sizeof(buff), fd)) {

-	if(buff[0] == '#') continue;

-	lines++;

+    if((bread = read(sockd, buff, sizeof(buff))) > 0) {

+	if(!strstr(buff, "Signature:")) {

+	    logg("!getdsig: Error generating digital signature\n");

+	    logg("!getdsig: Answer from remote server: %s\n", buff);

+	    close(sockd);

+	    return NULL;

+	} else {

+	    logg("Signature received (length = %d)\n", strlen(buff) - 10);

+	}

     }

-    fclose(fd);

-    return lines;

+    close(sockd);

+    pt = buff;

+    pt += 10;

+    return strdup(pt);

 }

-int build(struct optstruct *opt)

+static int build(struct optstruct *opt)

 {

-	int ret, no = 0, realno = 0, bytes, itmp;

+	int ret, itmp;

+	size_t bytes;

+	unsigned int sigs = 0, lines = 0;

 	struct stat foo;

-	char buffer[FILEBUFF], *tarfile = NULL, *gzfile = NULL, header[513],

+	char buffer[FILEBUFF], *tarfile, *gzfile, header[513],

 	     smbuff[30], *pt, *dbdir;

         struct cl_node *root = NULL;

-	FILE *tar, *cvd, *fd;

+	FILE *tar, *cvd;

 	gzFile *gz;

 	time_t timet;

 	struct tm *brokent;

 	struct cl_cvd *oldcvd = NULL;

-    if(stat("COPYING", &foo) == -1) {

-	logg("COPYING file not found in current working directory.\n");

-	opt_free(opt);

-	exit(1);

+    if(!opt_check(opt, "server")) {

+	logg("!build: --server is required for --build\n");

+	return -1;

     }

-    if(stat("main.db", &foo) == -1 && stat("daily.db", &foo) == -1 && stat("main.hdb", &foo) == -1 && stat("daily.hdb", &foo) == -1 && stat("main.ndb", &foo) == -1 && stat("daily.ndb", &foo) == -1 && stat("main.zmd", &foo) == -1 && stat("main.rmd", &foo) == -1 && stat("daily.zmd", &foo) == -1 && stat("daily.rmd", &foo) == -1) {

-	logg("Virus database not found in current working directory.\n");

-	opt_free(opt);

-	exit(1);

+    if(stat("COPYING", &foo) == -1) {

+	logg("!build: COPYING file not found in current working directory.\n");

+	return -1;

     }

-    cl_debug(); /* enable debug messages */

-

-    if((ret = cl_loaddbdir(".", &root, &no))) {

-	logg("!Can't load database: %s\n", cl_strerror(ret));

-	opt_free(opt);

-	exit(1);

+    if(stat("main.db", &foo) == -1 && stat("daily.db", &foo) == -1 &&

+       stat("main.hdb", &foo) == -1 && stat("daily.hdb", &foo) == -1 &&

+       stat("main.ndb", &foo) == -1 && stat("daily.ndb", &foo) == -1 &&

+       stat("main.zmd", &foo) == -1 && stat("daily.zmd", &foo) == -1 &&

+       stat("main.rmd", &foo) == -1 && stat("daily.rmd", &foo) == -1)

+    {

+	logg("!build: No virus database file  found in current directory\n");

+	return -1;

     }

-    cl_free(root);

+    cl_debug(); /* enable debug messages in libclamav */

-    logg("Database properly parsed.\n");

+    if((ret = cl_loaddbdir(".", &root, &sigs))) {

+	logg("!build: Can't load database: %s\n", cl_strerror(ret));

+	return -1;

+    } else {

+	cl_free(root);

+    }

-    if(!no) {

-	logg("^There are no signatures in the database(s).\n");

+    if(!sigs) {

+	logg("!build: There are no signatures in database files\n");

     } else {

-	logg("Signatures: %d\n", no);

-	realno = countlines("main.db") + countlines("daily.db") + countlines("main.hdb") + countlines("daily.hdb") + countlines("main.ndb") + countlines("daily.ndb") + countlines("main.zmd") + countlines("daily.zmd") + countlines("main.rmd") + countlines("daily.rmd") + countlines("main.fp") + countlines("daily.fp");

-	if(realno != no) {

-	    logg("!Signatures in database: %d. Loaded: %d.\n", realno, no);

-	    logg("Please check the current directory and remove unnecessary databases\n");

-	    logg("or install the latest ClamAV version.\n");

-	    opt_free(opt);

-	    exit(1);

+	logg("Signatures: %d\n", sigs);

+	lines = countlines("main.db") + countlines("daily.db") +

+		countlines("main.hdb") + countlines("daily.hdb") +

+		countlines("main.ndb") + countlines("daily.ndb") +

+		countlines("main.zmd") + countlines("daily.zmd") +

+		countlines("main.rmd") + countlines("daily.rmd") +

+		countlines("main.fp") + countlines("daily.fp");

+

+	if(lines != sigs) {

+	    logg("!build: Signatures in database: %d, loaded by libclamav: %d\n", lines, sigs);

+	    logg("!build: Please check the current directory and remove unnecessary databases\n");

+	    logg("!build: or install the latest ClamAV version.\n");

+	    return -1;

 	}

     }

-    tarfile = cli_gentemp(".");

+    if(!(tarfile = cli_gentemp("."))) {

+	logg("!build: Can't generate temporary name for tarfile\n");

+	return -1;

+    }

     switch(fork()) {

 	case -1:

-	    logg("!Can't fork.\n");

-	    opt_free(opt);

-	    exit(1);

+	    logg("!build: Can't fork.\n");

+	    free(tarfile);

+	    return -1;

 	case 0:

 	    {

-		char *args[] = { "tar", "-cvf", NULL, "COPYING", "main.db", "daily.db", "Notes", "viruses.db3", "main.hdb", "daily.hdb", "main.ndb", "daily.ndb", "main.zmd", "daily.zmd", "main.rmd", "daily.rmd", "main.fp", "daily.fp", NULL };

+		char *args[] = { "tar", "-cvf", NULL, "COPYING", "main.db",

+				 "daily.db", "main.hdb", "daily.hdb",

+				 "main.ndb", "daily.ndb", "main.zmd",

+				 "daily.zmd", "main.rmd", "daily.rmd",

+				 "main.fp", "daily.fp", NULL };

 		args[2] = tarfile;

 		execv("/bin/tar", args);

-		logg("!Can't execute tar\n");

+		logg("!build: Can't execute tar\n");

 		perror("tar");

-		opt_free(opt);

-		exit(1);

+		free(tarfile);

+		return -1;

 	    }

 	default:

 	    wait(NULL);

     }

     if(stat(tarfile, &foo) == -1) {

-	logg("!Can't generate tar file.\n");

-	opt_free(opt);

-	exit(1);

+	logg("!build: Tar archive was not created\n");

+	free(tarfile);

+	return -1;

     }

     if((tar = fopen(tarfile, "rb")) == NULL) {

-	logg("!Can't open file %s\n", tarfile);

-	opt_free(opt);

-	exit(1);

+	logg("!build: Can't open file %s\n", tarfile);

+	free(tarfile);

+	return -1;

+    }

+

+    if(!(gzfile = cli_gentemp("."))) {

+	logg("!build: Can't generate temporary name for gzfile\n");

+	free(tarfile);

+	fclose(tar);

+	return -1;

     }

-    gzfile = cli_gentemp(".");

     if((gz = gzopen(gzfile, "wb")) == NULL) {

-	logg("!Can't open file %s to write.\n", gzfile);

-	opt_free(opt);

-	exit(1);

+	logg("!build: Can't open file %s to write.\n", gzfile);

+	free(tarfile);

+	fclose(tar);

+	free(gzfile);

+	return -1;

     }

-    while((bytes = fread(buffer, 1, FILEBUFF, tar)) > 0)

-	gzwrite(gz, buffer, bytes);

+    while((bytes = fread(buffer, 1, FILEBUFF, tar)) > 0) {

+	if(!gzwrite(gz, buffer, bytes)) {

+	    logg("!build: Can't gzwrite to %s\n", gzfile);

+	    fclose(tar);

+	    gzclose(gz);

+	    free(tarfile);

+	    free(gzfile);

+	    return -1;

+	}

+    }

     fclose(tar);

+    gzclose(gz);

     unlink(tarfile);

     free(tarfile);

-    gzclose(gz);

-

-

-    /* try to read cvd header of old database */

+    /* try to read cvd header of current database */

     dbdir = freshdbdir();

-    sprintf(buffer, "%s/%s", dbdir, opt_arg(opt, "build"));

+    snprintf(buffer, sizeof(buffer), "%s/%s", dbdir, opt_arg(opt, "build"));

     free(dbdir);

-    if((oldcvd = cl_cvdhead(buffer)) == NULL)

-	logg("^CAN'T READ CVD HEADER OF CURRENT DATABASE %s\n", buffer);

-

-    /* generate header */

-

-    /* magic string */

+    if((oldcvd = cl_cvdhead(buffer)) == NULL) {

+	logg("^build: CAN'T READ CVD HEADER OF CURRENT DATABASE %s\n", buffer);

+	sleep(3);

+    }

+    /* build header */

     strcpy(header, "ClamAV-VDB:");

     /* time */

-

     time(&timet);

     brokent = localtime(&timet);

     setlocale(LC_TIME, "C");

-    strftime(smbuff, 30, "%d %b %Y %H-%M %z", brokent);

+    strftime(smbuff, sizeof(smbuff), "%d %b %Y %H-%M %z", brokent);

     strcat(header, smbuff);

-    /* version number */

-

-    /* ... increment version number by one */

-

+    /* increment version number by one */

     if(oldcvd) {

 	sprintf(smbuff, ":%d:", oldcvd->version + 1);

     } else {

@@ -408,7 +386,7 @@ int build(struct optstruct *opt)

     strcat(header, smbuff);

     /* number of signatures */

-    sprintf(smbuff, "%d:", no);

+    sprintf(smbuff, "%d:", sigs);

     strcat(header, smbuff);

     /* functionality level */

@@ -416,28 +394,52 @@ int build(struct optstruct *opt)

     strcat(header, smbuff);

     /* MD5 */

-    pt = cli_md5file(gzfile);

+    if(!(pt = cli_md5file(gzfile))) {

+	logg("!build: Can't generate MD5 checksum for gzfile\n");

+	unlink(gzfile);

+	free(gzfile);

+	return -1;

+    }

     strcat(header, pt);

     free(pt);

     strcat(header, ":");

     /* ask for builder name */

     fflush(stdin);

-    logg("Builder id: ");

-    fscanf(stdin, "%s", smbuff);

+    logg("Builder name: ");

+    if(fgets(smbuff, sizeof(smbuff), stdin)) {

+	cli_chomp(smbuff);

+    } else {

+	logg("!build: Can't get builder name\n");

+	unlink(gzfile);

+	free(gzfile);

+	return -1;

+    }

     /* digital signature */

-    fd = fopen(gzfile, "rb");

-    pt = cli_md5stream(fd, buffer);

-    fclose(fd);

+    if(!(tar = fopen(gzfile, "rb"))) {

+	logg("!build: Can't open file %s for reading\n", gzfile);

+	unlink(gzfile);

+	free(gzfile);

+	return -1;

+    }

+

+    if(!(pt = cli_md5stream(tar, (unsigned char *) buffer))) {

+	logg("!build: Can't generate MD5 checksum for %s\n", gzfile);

+	unlink(gzfile);

+	free(gzfile);

+	return -1;

+    }

     free(pt);

+    rewind(tar);

+

     if(!(pt = getdsig(opt_arg(opt, "server"), smbuff, buffer))) {

-	logg("No digital signature - no CVD file...\n");

+	logg("!build: Can't get digital signature from remote server\n");

 	unlink(gzfile);

-	opt_free(opt);

-	exit(1);

+	free(gzfile);

+	fclose(tar);

+	return -1;

     }

-

     strcat(header, pt);

     free(pt);

     strcat(header, ":");

@@ -449,194 +451,191 @@ int build(struct optstruct *opt)

     sprintf(header + strlen(header), ":%d", (int) timet);

     /* fill up with spaces */

-

-    while(strlen(header) < 512)

+    while(strlen(header) < sizeof(header) - 1)

 	strcat(header, " ");

     /* build the final database */

-

     pt = opt_arg(opt, "build");

-    if((cvd = fopen(pt, "wb")) == NULL) {

-	logg("!Can't write the final database %s\n", pt);

+    if(!(cvd = fopen(pt, "wb"))) {

+	logg("!build: Can't create final database %s\n", pt);

 	unlink(gzfile);

-	opt_free(opt);

-	exit(1);

+	free(gzfile);

+	fclose(tar);

+	return -1;

     }

-    fwrite(header, 1, 512, cvd);

-

-    if((tar = fopen(gzfile, "rb")) == NULL) {

-	logg("!Can't open file %s for reading.\n", gzfile);

-	opt_free(opt);

-	exit(1);

+    if(fwrite(header, 1, 512, cvd) != 512) {

+	logg("!build: Can't write to %s\n", pt);

+	fclose(cvd);

+	fclose(tar);

+	unlink(pt);

+	unlink(gzfile);

+	free(gzfile);

+	return -1;

     }

-    while((bytes = fread(buffer, 1, FILEBUFF, tar)) > 0)

-	fwrite(buffer, 1, bytes, cvd);

+    while((bytes = fread(buffer, 1, FILEBUFF, tar)) > 0) {

+	if(fwrite(buffer, 1, bytes, cvd) != bytes) {

+	    fclose(tar);

+	    fclose(cvd);

+	    unlink(pt);

+	    logg("!build: Can't write to %s\n", gzfile);

+	    unlink(gzfile);

+	    free(gzfile);

+	    return -1;

+	}

+    }

     fclose(tar);

     fclose(cvd);

-

-    unlink(gzfile);

+    if(unlink(gzfile) == -1) {

+	logg("^build: Can't unlink %s\n", gzfile);

+	return -1;

+    }

     free(gzfile);

-    logg("Database %s created.\n", pt);

+    logg("Database %s created\n", pt);

+

+    return 0;

+}

+

+static int unpack(struct optstruct *opt)

+{

+	char *name, *dbdir;

+

+

+    if(opt_check(opt, "unpack-current")) {

+	dbdir = freshdbdir();

+	name = mcalloc(strlen(dbdir) + strlen(opt_arg(opt, "unpack-current")) + 2, sizeof(char));

+	sprintf(name, "%s/%s", dbdir, opt_arg(opt, "unpack-current"));

+	free(dbdir);

+    } else

+	name = strdup(opt_arg(opt, "unpack"));

-    /* try to load final cvd */

+    if(cvd_unpack(name, ".") == -1) {

+	logg("!unpack: Can't unpack CVD file %s\n", name);

+	free(name);

+	return -1;

+    }

+

+    free(name);

     return 0;

 }

-void cvdinfo(struct optstruct *opt)

+static int cvdinfo(struct optstruct *opt)

 {

 	struct cl_cvd *cvd;

 	char *pt;

 	int ret;

+

     pt = opt_arg(opt, "info");

     if((cvd = cl_cvdhead(pt)) == NULL) {

-	logg("!Can't read/parse CVD header from %s\n", pt);

-	opt_free(opt);

-	exit(1);

+	logg("!cvdinfo: Can't read/parse CVD header of %s\n", pt);

+	return -1;

     }

+    pt = strchr(cvd->time, '-');

+    *pt = ':';

     logg("Build time: %s\n", cvd->time);

     logg("Version: %d\n", cvd->version);

     logg("Signatures: %d\n", cvd->sigs);

     logg("Functionality level: %d\n", cvd->fl);

     logg("Builder: %s\n", cvd->builder);

     logg("MD5: %s\n", cvd->md5);

-

     logg("Digital signature: %s\n", cvd->dsig);

 #ifndef HAVE_GMP

-    logg("Digital signature support not compiled in.\n");

+    logg("^Digital signature support not compiled in.\n");

 #endif

+    pt = opt_arg(opt, "info");

     if((ret = cl_cvdverify(pt)))

-	logg("!Verification: %s\n", cl_strerror(ret));

+	logg("!cvdinfo: Verification: %s\n", cl_strerror(ret));

     else

 	logg("Verification OK.\n");

-    /* free */

+    cl_cvdfree(cvd);

+    return 0;

 }

-char *getdsig(const char *host, const char *user, const char *data)

-{

-	char buff[300], cmd[100], *pass, *pt;

-        struct sockaddr_in server;

-	int sockd, bread, len;

-

+static int listdb(const char *filename);

-#ifdef PF_INET

-    if((sockd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {

-#else

-    if((sockd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

-#endif

-	perror("socket()");

-	logg("!Can't create the socket.\n");

-	return NULL;

-    }

+static int listdir(const char *dirname)

+{

+	DIR *dd;

+	struct dirent *dent;

+	char *dbfile;

-    server.sin_family = AF_INET;

-    server.sin_addr.s_addr = inet_addr(host);

-    server.sin_port = htons(33101);

-    if(connect(sockd, (struct sockaddr *) &server, sizeof(struct sockaddr_in)) < 0) {

-        close(sockd);

-	perror("connect()");

-	logg("!Can't connect to ClamAV Signing Service at %s.\n", host);

-	return NULL;

+    if((dd = opendir(dirname)) == NULL) {

+        logg("!listdir: Can't open directory %s\n", dirname);

+        return -1;

     }

-    memset(cmd, 0, sizeof(cmd));

-    pass = getpass("Password:");

-    sprintf(cmd, "ClamSign:%s:%s:", user, pass);

-    len = strlen(cmd);

-    pt = cmd;

-    pt += len;

-    memcpy(pt, data, 16);

-    len += 16;

+    while((dent = readdir(dd))) {

+#ifndef C_INTERIX

+	if(dent->d_ino)

+#endif

+	{

+	    if(strcmp(dent->d_name, ".") && strcmp(dent->d_name, "..") &&

+	    (cli_strbcasestr(dent->d_name, ".db")  ||

+	     cli_strbcasestr(dent->d_name, ".hdb") ||

+	     cli_strbcasestr(dent->d_name, ".ndb") ||

+	     cli_strbcasestr(dent->d_name, ".zmd") ||

+	     cli_strbcasestr(dent->d_name, ".rmd") ||

+	     cli_strbcasestr(dent->d_name, ".cvd"))) {

-    if(write(sockd, cmd, len) < 0) {

-	logg("!Can't write to the socket.\n");

-	close(sockd);

-	memset(cmd, 0, len);

-	memset(pass, 0, strlen(pass));

-	return NULL;

-    }

+		dbfile = (char *) mcalloc(strlen(dent->d_name) + strlen(dirname) + 2, sizeof(char));

-    memset(cmd, 0, len);

-    memset(pass, 0, strlen(pass));

+		if(!dbfile) {