/*

  *  Copyright (C) 2006 Sensory Networks, Inc.
  *	      (C) 2007 Tomasz Kojm <tkojm@clamav.net>
  *	      Written by Tomasz Kojm

  *
  *  This program is free software; you can redistribute it and/or modify

  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.

  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  *  MA 02110-1301, USA.
  */
 
 
 #if HAVE_CONFIG_H
 #include "clamav-config.h"
 #endif
 
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
 #include <sys/types.h>
 #include <sys/stat.h>

 #ifdef HAVE_UNISTD_H

 #include <unistd.h>

 #endif

 #include "clamav.h"

 #include "shared/misc.h"

 #include "shared/output.h"

 #include "shared/cdiff.h"

 
 #include "libclamav/str.h"
 #include "libclamav/others.h"
 #include "libclamav/cvd.h"

 #include "libclamav/default.h"

 
 #include "zlib.h"

 #include "libclamav/dsig.h"
 

 #include <openssl/evp.h>
 

 #define PSS_NSTR "14783905874077467090262228516557917570254599638376203532031989214105552847269687489771975792123442185817287694951949800908791527542017115600501303394778618535864845235700041590056318230102449612217458549016089313306591388590790796515819654102320725712300822356348724011232654837503241736177907784198700834440681124727060540035754699658105895050096576226753008596881698828185652424901921668758326578462003247906470982092298106789657211905488986281078346361469524484829559560886227198091995498440676639639830463593211386055065360288422394053998134458623712540683294034953818412458362198117811990006021989844180721010947"
 #define PSS_ESTR "100002053"
 #define PSS_NBITS 2048
 #define PSS_DIGEST_LENGTH 32

 /* the line size can be changed from within .cdiff */
 #define CDIFF_LINE_SIZE CLI_DEFAULT_LSIG_BUFSIZE + 32
 

 struct cdiff_node {
     unsigned int lineno;
     char *str, *str2;
     struct cdiff_node *next;
 };
 
 struct cdiff_ctx {
     char *open_db;
     struct cdiff_node *add_start, *add_last;
     struct cdiff_node *del_start;

     struct cdiff_node *xchg_start, *xchg_last;

 };
 
 struct cdiff_cmd {

     const char *name;

     unsigned short argc;

     int (*handler)(const char *, struct cdiff_ctx *, char *, unsigned int);

 };
 

 static int cdiff_cmd_open(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen);
 static int cdiff_cmd_add(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen);
 static int cdiff_cmd_del(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen);
 static int cdiff_cmd_xchg(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen);
 static int cdiff_cmd_close(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen);
 static int cdiff_cmd_move(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen);
 static int cdiff_cmd_unlink(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen);

 
 static struct cdiff_cmd commands[] = {
     /* OPEN db_name */
     { "OPEN", 1, &cdiff_cmd_open },
 
     /* ADD newsig */
     { "ADD", 1, &cdiff_cmd_add },
 
     /* DEL line_no some_first_bytes */
     { "DEL", 2, &cdiff_cmd_del },
 
     /* XCHG line_no some_first_bytes_of_old_line new_line */
     { "XCHG", 3, &cdiff_cmd_xchg },
 
     /* CLOSE */
     { "CLOSE", 0, &cdiff_cmd_close },
 
     /* MOVE src_db dst_db start_line first_16b end_line first_16b */

     { "MOVE", 6, &cdiff_cmd_move },

     /* UNLINK db_name */
     { "UNLINK", 1, &cdiff_cmd_unlink },
 

     { NULL, 0, NULL }
 };
 

 static void cdiff_ctx_free(struct cdiff_ctx *ctx)

 {
 	struct cdiff_node *pt;
 
 
     if(ctx->open_db) {
 	free(ctx->open_db);
 	ctx->open_db = NULL;
     }
 
     while(ctx->add_start) {
 	free(ctx->add_start->str);
 	pt = ctx->add_start;
 	ctx->add_start = ctx->add_start->next;
 	free(pt);
     }

     ctx->add_last = NULL;

 
     while(ctx->del_start) {
 	free(ctx->del_start->str);
 	pt = ctx->del_start;
 	ctx->del_start = ctx->del_start->next;
 	free(pt);
     }
 
     while(ctx->xchg_start) {
 	free(ctx->xchg_start->str);
 	free(ctx->xchg_start->str2);
 	pt = ctx->xchg_start;
 	ctx->xchg_start = ctx->xchg_start->next;
 	free(pt);
     }
 }
 

 static char *cdiff_token(const char *line, unsigned int token, unsigned int last)

 {
 	unsigned int counter = 0, i, j;
 	char *buffer;
 
 
     for(i = 0; line[i] && counter != token; i++)
 	if(line[i] == ' ')
 	    counter++;
 
     if(!line[i])
 	return NULL;
 

     if(last)
 	return strdup(&line[i]);
 

     for(j = i; line[j]; j++)
 	if(line[j] == ' ')
 	    break;
 
     if(i == j)
 	return NULL;
 

     buffer = malloc(j - i + 1);

     if(!buffer)
 	return NULL;
 
     strncpy(buffer, line + i, j - i);
     buffer[j - i] = '\0';
 
     return buffer;
 }
 

 static int cdiff_cmd_open(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen)

 {
 	char *db;
 	unsigned int i;
 

     UNUSEDPARAM(lbuf);
     UNUSEDPARAM(lbuflen);

     if(!(db = cdiff_token(cmdstr, 1, 1))) {

 	logg("!cdiff_cmd_open: Can't get first argument\n");
 	return -1;
     }
 
     if(ctx->open_db) {
 	logg("!cdiff_cmd_open: %s not closed before opening %s\n", ctx->open_db, db);
 	free(db);
 	return -1;
     }
 
     for(i = 0; i < strlen(db); i++) {
 	if((db[i] != '.' && !isalnum(db[i])) || strchr("/\\", db[i])) {
 	    logg("!cdiff_cmd_open: Forbidden characters found in database name\n");
 	    free(db);
 	    return -1;
 	}
     }
 
     ctx->open_db = db;
     return 0;
 }
 

 static int cdiff_cmd_add(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen)

 {
 	char *sig;
 	struct cdiff_node *new;
 

     UNUSEDPARAM(lbuf);
     UNUSEDPARAM(lbuflen);

     if(!(sig = cdiff_token(cmdstr, 1, 1))) {

 	logg("!cdiff_cmd_add: Can't get first argument\n");
 	return -1;
     }
 

     new = (struct cdiff_node *) calloc(1, sizeof(struct cdiff_node));

     if(!new) {
 	logg("!cdiff_cmd_add: Can't allocate memory for cdiff_node\n");
 	free(sig);
 	return -1;
     }
     new->str = sig;
 
     if(!ctx->add_last) {
 	ctx->add_start = ctx->add_last = new;
     } else { 
 	ctx->add_last->next = new;
 	ctx->add_last = new;
     }
 
     return 0;
 }
 

 static int cdiff_cmd_del(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen)

 {
 	char *arg;
 	struct cdiff_node *pt, *last, *new;
 	unsigned int lineno;
 

     UNUSEDPARAM(lbuf);
     UNUSEDPARAM(lbuflen);
 

     if(!(arg = cdiff_token(cmdstr, 1, 0))) {

 	logg("!cdiff_cmd_del: Can't get first argument\n");
 	return -1;
     }
     lineno = (unsigned int) atoi(arg);
     free(arg);
 

     if(!(arg = cdiff_token(cmdstr, 2, 1))) {

 	logg("!cdiff_cmd_del: Can't get second argument\n");
 	return -1;
     }
 

     new = (struct cdiff_node *) calloc(1, sizeof(struct cdiff_node));

     if(!new) {
 	logg("!cdiff_cmd_del: Can't allocate memory for cdiff_node\n");
 	free(arg);
 	return -1;
     }
     new->str = arg;
     new->lineno = lineno;
 
     if(!ctx->del_start) {
 
 	ctx->del_start = new;
 
     } else { 
 
 	if(lineno < ctx->del_start->lineno) {
 	    new->next = ctx->del_start;
 	    ctx->del_start = new;
 
 	} else {
 	    pt = ctx->del_start;
 
 	    while(pt) {
 		last = pt;
 		if((pt->lineno < lineno) && (!pt->next || lineno < pt->next->lineno))
 		    break;
 
 		pt = pt->next;
 	    }
 
 	    new->next = last->next;
 	    last->next = new;
 	}
     }
 
     return 0;
 }
 

 static int cdiff_cmd_xchg(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen)

 {
 	char *arg, *arg2;

 	struct cdiff_node *new;

 	unsigned int lineno;
 

     UNUSEDPARAM(lbuf);
     UNUSEDPARAM(lbuflen);
 

     if(!(arg = cdiff_token(cmdstr, 1, 0))) {

 	logg("!cdiff_cmd_xchg: Can't get first argument\n");
 	return -1;
     }
     lineno = (unsigned int) atoi(arg);
     free(arg);
 

     if(!(arg = cdiff_token(cmdstr, 2, 0))) {

 	logg("!cdiff_cmd_xchg: Can't get second argument\n");
 	return -1;
     }
 

     if(!(arg2 = cdiff_token(cmdstr, 3, 1))) {

 	free(arg);
 	logg("!cdiff_cmd_xchg: Can't get second argument\n");
 	return -1;
     }
 

     new = (struct cdiff_node *) calloc(1, sizeof(struct cdiff_node));

     if(!new) {
 	logg("!cdiff_cmd_xchg: Can't allocate memory for cdiff_node\n");
 	free(arg);
 	free(arg2);
 	return -1;
     }
     new->str = arg;
     new->str2 = arg2;
     new->lineno = lineno;
 

     if(!ctx->xchg_start)

 	ctx->xchg_start = new;

     else
 	ctx->xchg_last->next = new;

     ctx->xchg_last = new;

     return 0;
 }
 

 static int cdiff_cmd_close(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen)

 {
 	struct cdiff_node *add, *del, *xchg;
 	unsigned int lines = 0;

 	char *tmp;

 	FILE *fh, *tmpfh;
 

     UNUSEDPARAM(cmdstr);
 

 
     if(!ctx->open_db) {
 	logg("!cdiff_cmd_close: No database to close\n");
 	return -1;
     }
 
     add = ctx->add_start;
     del = ctx->del_start;
     xchg = ctx->xchg_start;
 
     if(del || xchg) {
 

 	if(!(fh = fopen(ctx->open_db, "rb"))) {

 	    logg("!cdiff_cmd_close: Can't open file %s for reading\n", ctx->open_db);
 	    return -1;
 	}
 
 	if(!(tmp = cli_gentemp("."))) {
 	    logg("!cdiff_cmd_close: Can't generate temporary name\n");
 	    fclose(fh);
 	    return -1;
 	}
 

 	if(!(tmpfh = fopen(tmp, "wb"))) {

 	    logg("!cdiff_cmd_close: Can't open file %s for writing\n", tmp);

 	    fclose(fh);
 	    free(tmp);
 	    return -1;
 	}
 

 	while(fgets(lbuf, lbuflen, fh)) {

 	    lines++;
 
 	    if(del && del->lineno == lines) {

 		if(strncmp(lbuf, del->str, strlen(del->str))) {

 		    fclose(fh);
 		    fclose(tmpfh);
 		    unlink(tmp);
 		    free(tmp);

 		    logg("!cdiff_cmd_close: Can't apply DEL at line %d of %s\n", lines, ctx->open_db);

 		    return -1;
 		}
 		del = del->next;
 		continue;
 	    }
 
 	    if(xchg && xchg->lineno == lines) {

 		if(strncmp(lbuf, xchg->str, strlen(xchg->str))) {

 		    fclose(fh);
 		    fclose(tmpfh);
 		    unlink(tmp);
 		    free(tmp);

 		    logg("!cdiff_cmd_close: Can't apply XCHG at line %d of %s\n", lines, ctx->open_db);

 		    return -1;
 		}
 
 		if(fputs(xchg->str2, tmpfh) == EOF || fputc('\n', tmpfh) == EOF) {
 		    fclose(fh);
 		    fclose(tmpfh);
 		    unlink(tmp);
 		    logg("!cdiff_cmd_close: Can't write to %s\n", tmp);
 		    free(tmp);
 		    return -1;
 		}
 		xchg = xchg->next;
 		continue;
 	    }
 

 	    if(fputs(lbuf, tmpfh) == EOF) {

 		fclose(fh);
 		fclose(tmpfh);
 		unlink(tmp);
 		logg("!cdiff_cmd_close: Can't write to %s\n", tmp);
 		free(tmp);
 		return -1;
 	    }
 	}
 
 	fclose(fh);
 	fclose(tmpfh);
 
 	if(del || xchg) {
 	    logg("!cdiff_cmd_close: Not all DEL/XCHG have been executed\n");
 	    unlink(tmp);
 	    free(tmp);
 	    return -1;
 	}
 
 	if(unlink(ctx->open_db) == -1) {
 	    logg("!cdiff_cmd_close: Can't unlink %s\n", ctx->open_db);
 	    unlink(tmp);
 	    free(tmp);
 	    return -1;
 	}
 
 	if(rename(tmp, ctx->open_db) == -1) {
 	    logg("!cdiff_cmd_close: Can't rename %s to %s\n", tmp, ctx->open_db);
 	    unlink(tmp);
 	    free(tmp);
 	    return -1;
 	}
 
 	free(tmp);
     }
 
     if(add) {
 

 	if(!(fh = fopen(ctx->open_db, "ab"))) {

 	    logg("!cdiff_cmd_close: Can't open file %s for appending\n", ctx->open_db);
 	    return -1;
 	}
 
 	while(add) {
 	    if(fputs(add->str, fh) == EOF || fputc('\n', fh) == EOF) {
 		fclose(fh);
 		logg("!cdiff_cmd_close: Can't write to %s\n", ctx->open_db);
 		return -1;
 	    }
 	    add = add->next;
 	}

 
 	fclose(fh);

     }
 
     cdiff_ctx_free(ctx);
 
     return 0;
 }
 

 static int cdiff_cmd_move(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen)

 {
 	unsigned int lines = 0, start_line, end_line;

 	char *arg, *srcdb, *dstdb, *tmpdb, *start_str, *end_str;

 	FILE *src, *dst, *tmp;
 
 
     if(ctx->open_db) {
 	logg("!cdiff_cmd_move: Database %s is still open\n", ctx->open_db);
 	return -1;
     }
 
     if(!(arg = cdiff_token(cmdstr, 3, 0))) {
 	logg("!cdiff_cmd_move: Can't get third argument\n");
 	return -1;
     }
     start_line = atoi(arg);
     free(arg);
 
     if(!(arg = cdiff_token(cmdstr, 5, 0))) {
 	logg("!cdiff_cmd_move: Can't get fifth argument\n");
 	return -1;
     }
     end_line = atoi(arg);
     free(arg);
 
     if(end_line < start_line) {
 	logg("!cdiff_cmd_move: end_line < start_line\n");
 	return -1;
     }
 
     if(!(start_str = cdiff_token(cmdstr, 4, 0))) {
 	logg("!cdiff_cmd_move: Can't get fourth argument\n");
 	return -1;
     }
 
     if(!(end_str = cdiff_token(cmdstr, 6, 0))) {
 	logg("!cdiff_cmd_move: Can't get sixth argument\n");
 	free(start_str);
 	return -1;
     }
 
     if(!(srcdb = cdiff_token(cmdstr, 1, 0))) {
 	logg("!cdiff_cmd_move: Can't get first argument\n");
 	free(start_str);
 	free(end_str);
 	return -1;
     }
 

     if(!(src = fopen(srcdb, "rb"))) {

 	logg("!cdiff_cmd_move: Can't open %s for reading\n", srcdb);
 	free(start_str);
 	free(end_str);
 	free(srcdb);
 	return -1;
     }
 
     if(!(dstdb = cdiff_token(cmdstr, 2, 0))) {
 	logg("!cdiff_cmd_move: Can't get second argument\n");
 	free(start_str);
 	free(end_str);
 	free(srcdb);
 	fclose(src);
 	return -1;
     }
 

     if(!(dst = fopen(dstdb, "ab"))) {

 	logg("!cdiff_cmd_move: Can't open %s for appending\n", dstdb);
 	free(start_str);
 	free(end_str);
 	free(srcdb);
 	fclose(src);
 	free(dstdb);
 	return -1;
     }
 
     if(!(tmpdb = cli_gentemp("."))) {
 	logg("!cdiff_cmd_move: Can't generate temporary name\n");
 	free(start_str);
 	free(end_str);
 	free(srcdb);
 	fclose(src);
 	free(dstdb);
 	fclose(dst);
 	return -1;
     }
 

     if(!(tmp = fopen(tmpdb, "wb"))) {

 	logg("!cdiff_cmd_move: Can't open file %s for writing\n", tmpdb);
 	free(start_str);
 	free(end_str);
 	free(srcdb);
 	fclose(src);
 	free(dstdb);
 	fclose(dst);
 	free(tmpdb);
 	return -1;
     }
 

     while(fgets(lbuf, lbuflen, src)) {

 	lines++;
 
 	if(lines == start_line) {

 	    if(strncmp(lbuf, start_str, strlen(start_str))) {

 		free(start_str);
 		free(end_str);
 		free(srcdb);
 		fclose(src);
 		free(dstdb);
 		fclose(dst);
 		fclose(tmp);
 		unlink(tmpdb);
 		free(tmpdb);
 		logg("!cdiff_cmd_close: Can't apply MOVE due to conflict at line %d\n", lines);
 		return -1;
 	    }
 
 	    do {

 		if(fputs(lbuf, dst) == EOF) {

 		    free(start_str);
 		    free(end_str);
 		    free(srcdb);
 		    fclose(src);
 		    fclose(dst);
 		    fclose(tmp);
 		    unlink(tmpdb);
 		    free(tmpdb);
 		    logg("!cdiff_cmd_move: Can't write to %s\n", dstdb);
 		    free(dstdb);
 		    return -1;
 		}

 	    } while((lines < end_line) && fgets(lbuf, lbuflen, src) && lines++);

 
 	    fclose(dst);

 	    dst = NULL;

 	    free(dstdb);
 	    free(start_str);
 

 	    if(strncmp(lbuf, end_str, strlen(end_str))) {

 		free(end_str);
 		free(srcdb);
 		fclose(src);
 		fclose(tmp);
 		unlink(tmpdb);
 		free(tmpdb);
 		logg("!cdiff_cmd_close: Can't apply MOVE due to conflict at line %d\n", lines);
 		return -1;
 	    }
 
 	    free(end_str);
 	    continue;
 	}
 

 	if(fputs(lbuf, tmp) == EOF) {

 	    if(dst) {
 		fclose(dst);
 		free(dstdb);
 		free(start_str);
 		free(end_str);
 	    }

 	    free(srcdb);
 	    fclose(src);
 	    fclose(tmp);
 	    unlink(tmpdb);
 	    logg("!cdiff_cmd_move: Can't write to %s\n", tmpdb);
 	    free(tmpdb);
 	    return -1;
 	}
     }
 
     fclose(src);
     fclose(tmp);
 

     if(dst) {

 	fclose(dst);
 	free(start_str);
 	free(end_str);
 	unlink(tmpdb);
 	free(tmpdb);
 	logg("!cdiff_cmd_move: No data was moved from %s to %s\n", srcdb, dstdb);
 	free(srcdb);
 	free(dstdb);
 	return -1;
     }
 
     if(unlink(srcdb) == -1) {
 	logg("!cdiff_cmd_move: Can't unlink %s\n", srcdb);
 	free(srcdb);
 	unlink(tmpdb);
 	free(tmpdb);
 	return -1;
     }
 
     if(rename(tmpdb, srcdb) == -1) {
 	logg("!cdiff_cmd_move: Can't rename %s to %s\n", tmpdb, srcdb);
 	free(srcdb);
 	unlink(tmpdb);
 	free(tmpdb);
 	return -1;
     }
 
     free(srcdb);
     free(tmpdb);
 
     return 0;
 }
 

 static int cdiff_cmd_unlink(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen)

 {
 	char *db;
 	unsigned int i;
 

     UNUSEDPARAM(lbuf);
     UNUSEDPARAM(lbuflen);

 
     if(ctx->open_db) {
 	logg("!cdiff_cmd_unlink: Database %s is still open\n", ctx->open_db);
 	return -1;
     }
 
     if(!(db = cdiff_token(cmdstr, 1, 1))) {
 	logg("!cdiff_cmd_unlink: Can't get first argument\n");
 	return -1;
     }
 
     for(i = 0; i < strlen(db); i++) {
 	if((db[i] != '.' && !isalnum(db[i])) || strchr("/\\", db[i])) {
 	    logg("!cdiff_cmd_unlink: Forbidden characters found in database name\n");
 	    free(db);
 	    return -1;
 	}
     }
 
     if(unlink(db) == -1) {
 	logg("!cdiff_cmd_unlink: Can't unlink %s\n", db);
 	free(db);
 	return -1;
     }
 
     free(db);
     return 0;
 }
 

 static int cdiff_execute(const char *cmdstr, struct cdiff_ctx *ctx, char *lbuf, unsigned int lbuflen)

 {
 	char *cmd_name, *tmp;

 	int (*cmd_handler)(const char *, struct cdiff_ctx *, char *, unsigned int) = NULL;

 	unsigned int i;
 
 
     cmd_name = cdiff_token(cmdstr, 0, 0);
     if(!cmd_name) {
 	logg("!cdiff_apply: Problem parsing line\n");
 	return -1;
     }
 
     for(i = 0; commands[i].name; i++) {
 	if(!strcmp(commands[i].name, cmd_name)) {
 	    cmd_handler = commands[i].handler;
 	    break;
 	}
     }
 
     if(!cmd_handler) {
 	logg("!cdiff_apply: Unknown command %s\n", cmd_name);
 	free(cmd_name);
 	return -1;
     }
 
     if(!(tmp = cdiff_token(cmdstr, commands[i].argc, 1))) {
 	logg("!cdiff_apply: Not enough arguments for %s\n", cmd_name);
 	free(cmd_name);
 	return -1;
     }
     free(tmp);
 

     if(cmd_handler(cmdstr, ctx, lbuf, lbuflen)) {

 	logg("!cdiff_apply: Can't execute command %s\n", cmd_name);
 	free(cmd_name);
 	return -1;
     }
 
     free(cmd_name);
     return 0;
 }
 
 int cdiff_apply(int fd, unsigned short mode)

 {
 	struct cdiff_ctx ctx;
 	FILE *fh;

 	gzFile gzh;

 	char *line, *lbuf, buff[FILEBUFF], *dsig = NULL;

 	unsigned int lines = 0, cmds = 0;

 	unsigned int difflen, diffremain, line_size = CDIFF_LINE_SIZE;

 	int end, i, n;

 	struct stat sb;
 	int desc;

 	EVP_MD_CTX *sha256ctx;

 	unsigned char digest[32];
 	int sum, bread;

 #define DSIGBUFF 350

     memset(&ctx, 0, sizeof(ctx));

 
     if((desc = dup(fd)) == -1) {
 	logg("!cdiff_apply: Can't duplicate descriptor %d\n", fd);
 	return -1;
     }
 

     if(!(line = malloc(line_size))) {
 	logg("!cdiff_apply: Can't allocate memory for 'line'\n");
 	close(desc);
 	return -1;
     }
 
     if(!(lbuf = malloc(line_size))) {
 	logg("!cdiff_apply: Can't allocate memory for 'lbuf'\n");
 	close(desc);
 	free(line);
 	return -1;
     }
 

     if(mode == 1) { /* .cdiff */

 	if(lseek(desc, -DSIGBUFF, SEEK_END) == -1) {
 	    logg("!cdiff_apply: lseek(desc, %d, SEEK_END) failed\n", -DSIGBUFF);
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}

 	memset(line, 0, line_size);

 	if(read(desc, line, DSIGBUFF) != DSIGBUFF) {
 	    logg("!cdiff_apply: Can't read %d bytes\n", DSIGBUFF);
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}

 	for(i = DSIGBUFF - 1; i >= 0; i--) {
 	    if(line[i] == ':') {
 		dsig = &line[i + 1];
 		break;
 	    }
 	}

 	if(!dsig) {
 	    logg("!cdiff_apply: No digital signature in cdiff file\n");
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}
 
 	if(fstat(desc, &sb) == -1) {
 	    logg("!cdiff_apply: Can't fstat file\n");
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}
 
 	end = sb.st_size - (DSIGBUFF - i);
 	if(end < 0) {
 	    logg("!cdiff_apply: compressed data end offset < 0\n");
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}
 

 	if(lseek(desc, 0, SEEK_SET) == -1) {
 	    logg("!cdiff_apply: lseek(desc, 0, SEEK_SET) failed\n");
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}
 

     sha256ctx = EVP_MD_CTX_create();
     if (!(sha256ctx)) {
         close(desc);
         free(line);
         free(lbuf);
         return -1;
     }
 
 	EVP_DigestInit_ex(sha256ctx, EVP_sha256(), NULL);

 	sum = 0;
 	while((bread = read(desc, buff, FILEBUFF)) > 0) {
 	    if(sum + bread >= end) {

 		EVP_DigestUpdate(sha256ctx, (unsigned char *) buff, end - sum);

 		break;

 	    } else {

 		EVP_DigestUpdate(sha256ctx, (unsigned char *) buff, bread);

 	    }

 	    sum += bread;

 	}

 	EVP_DigestFinal_ex(sha256ctx, digest, NULL);
     EVP_MD_CTX_destroy(sha256ctx);

 	if(cli_versig2(digest, dsig, PSS_NSTR, PSS_ESTR) != CL_SUCCESS) {

 	    logg("!cdiff_apply: Incorrect digital signature\n");
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}
 

 	if(lseek(desc, 0, SEEK_SET) == -1) {
 	    logg("!cdiff_apply: lseek(desc, 0, SEEK_SET) failed\n");
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}
 

 	i = 0;

 	n = 0;
 	while(n < FILEBUFF - 1 && read(desc, &buff[n], 1) > 0) {
 	    if(buff[n++] == ':')

 		if(++i == 3)
 		    break;

 	}
 	buff[n] = 0;

 	if(sscanf(buff, "ClamAV-Diff:%*u:%u:", &difflen) != 1) {

 	    logg("!cdiff_apply: Incorrect file format\n");
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}
 

 	if(!(gzh = gzdopen(desc, "rb"))) {
 	    logg("!cdiff_apply: Can't gzdopen descriptor %d\n", desc);
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}
 

 	diffremain = difflen;
 	while(diffremain) {

 	    unsigned int bufsize = diffremain < line_size ? diffremain + 1 : line_size;

 
 	    if(!gzgets(gzh, line, bufsize)) {
 		logg("!cdiff_apply: Premature EOF at line %d\n", lines + 1);
 		cdiff_ctx_free(&ctx);
 		gzclose(gzh);

 		free(line);
 		free(lbuf);

 		return -1;
 	    }
 	    diffremain -= strlen(line);

 	    lines++;
 	    cli_chomp(line);

 	    if(!strlen(line))

 		continue;

 	    if(line[0] == '#') {
 		if(!strncmp(line, "#LSIZE", 6) && sscanf(line, "#LSIZE %u", &line_size) == 1) {
 			char *r1, *r2;
 		    if(line_size < CDIFF_LINE_SIZE || line_size > 10485760) {
 			logg("^cdiff_apply: Ignoring new buffer size request - invalid size %d\n", line_size);
 			line_size = CDIFF_LINE_SIZE;
 			continue;
 		    }
 		    r1 = realloc(line, line_size);
 		    r2 = realloc(lbuf, line_size);
 		    if(!r1 || !r2) {
 			logg("!cdiff_apply: Can't resize line buffer to %d bytes\n", line_size);
 			cdiff_ctx_free(&ctx);

 			gzclose(gzh);

 			if(!r1 && !r2) {
 			    free(line);
 			    free(lbuf);
 			} else if(!r1) {
 			    free(line);
 			    free(r2);
 			} else {
 			    free(r1);
 			    free(lbuf);
 			}

 			return -1;
 		    }
 		    line = r1;
 		    lbuf = r2;
 		}
 		continue;
 	    }

 	    if(cdiff_execute(line, &ctx, lbuf, line_size) == -1) {

 		logg("!cdiff_apply: Error executing command at line %d\n", lines);
 		cdiff_ctx_free(&ctx);
 		gzclose(gzh);

 		free(line);
 		free(lbuf);

 		return -1;
 	    } else {
 		cmds++;
 	    }
 	}
 	gzclose(gzh);
 
     } else { /* .script */
 

 	if(!(fh = fdopen(desc, "rb"))) {

 	    logg("!cdiff_apply: fdopen() failed for descriptor %d\n", desc);
 	    close(desc);

 	    free(line);
 	    free(lbuf);

 	    return -1;
 	}
 

 	while(fgets(line, line_size, fh)) {

 	    lines++;
 	    cli_chomp(line);
 

 	    if(!strlen(line))

 		continue;

 	    if(line[0] == '#') {
 		if(!strncmp(line, "#LSIZE", 6) && sscanf(line, "#LSIZE %u", &line_size) == 1) {
 			char *r1, *r2;
 		    if(line_size < CDIFF_LINE_SIZE || line_size > 10485760) {
 			logg("^cdiff_apply: Ignoring new buffer size request - invalid size %d\n", line_size);
 			line_size = CDIFF_LINE_SIZE;
 			continue;
 		    }
 		    r1 = realloc(line, line_size);
 		    r2 = realloc(lbuf, line_size);
 		    if(!r1 || !r2) {
 			logg("!cdiff_apply: Can't resize line buffer to %d bytes\n", line_size);
 			cdiff_ctx_free(&ctx);
 			fclose(fh);

 			if(!r1 && !r2) {
 			    free(line);
 			    free(lbuf);
 			} else if(!r1) {
 			    free(line);
 			    free(r2);
 			} else {
 			    free(r1);
 			    free(lbuf);
 			}

 			return -1;
 		    }
 		    line = r1;
 		    lbuf = r2;
 		}
 		continue;
 	    }

 	    if(cdiff_execute(line, &ctx, lbuf, line_size) == -1) {

 		logg("!cdiff_apply: Error executing command at line %d\n", lines);
 		cdiff_ctx_free(&ctx);
 		fclose(fh);

 		free(line);
 		free(lbuf);

 		return -1;
 	    } else {
 		cmds++;
 	    }
 	}
 
 	fclose(fh);
     }

     free(line);
     free(lbuf);
 

     if(ctx.open_db) {
 	logg("*cdiff_apply: File %s was not properly closed\n", ctx.open_db);
 	cdiff_ctx_free(&ctx);
 	return -1;
     }
 
     logg("*cdiff_apply: Parsed %d lines and executed %d commands\n", lines, cmds);
     return 0;
 }