@@ -222,7 +222,7 @@ CL_CLEAN = File is scanned

 CL_BREAK = Whitelisted by callback - file is skipped and marked as clean

 CL_VIRUS = Blacklisted by callback - file is skipped and marked as infected

 */

-extern void cl_engine_set_clcb_file_type(struct cl_engine *engine, clcb_pre_cache callback);

+extern void cl_engine_set_clcb_pre_cache(struct cl_engine *engine, clcb_pre_cache callback);

 typedef cl_error_t (*clcb_pre_scan)(int fd, const char *type, void *context);

 /* PRE-SCAN

@@ -261,11 +261,12 @@ CL_VIRUS = Blacklisted by callback - scan result is set to CL_VIRUS

 extern void cl_engine_set_clcb_post_scan(struct cl_engine *engine, clcb_post_scan callback);

-typedef int (*clcb_sigload)(const char *type, const char *name, void *context);

+typedef int (*clcb_sigload)(const char *type, const char *name, unsigned int custom, void *context);

 /* SIGNATURE LOAD

 Input:

 type = The signature type (e.g. "db", "ndb", "mdb", etc.)

 name = The virus name

+custom = The signature is official (custom == 0) or custom (custom != 0)

 context = Opaque application provided data

 Output:

@@ -573,7 +573,7 @@ static int cli_loaddb(FILE *fs, struct cl_engine *engine, unsigned int *signo, u

 	if(engine->ignored && cli_chkign(engine->ignored, start, buffer_cpy))

 	    continue;

-	if(engine->cb_sigload && engine->cb_sigload("db", start, engine->cb_sigload_ctx)) {

+	if(engine->cb_sigload && engine->cb_sigload("db", start, options & CL_DB_OFFICIAL, engine->cb_sigload_ctx)) {

 	    cli_dbgmsg("cli_loaddb: skipping %s due to callback\n", start);

 	    continue;

 	}

@@ -652,7 +652,7 @@ static int cli_loadidb(FILE *fs, struct cl_engine *engine, unsigned int *signo,

 	if(engine->ignored && cli_chkign(engine->ignored, tokens[0], buffer_cpy))

 	    continue;

-	if(engine->cb_sigload && engine->cb_sigload("idb", tokens[0], engine->cb_sigload_ctx)) {

+	if(engine->cb_sigload && engine->cb_sigload("idb", tokens[0], options & CL_DB_OFFICIAL, engine->cb_sigload_ctx)) {

 	    cli_dbgmsg("cli_loadidb: skipping %s due to callback\n", tokens[0]);

 	    continue;

 	}

@@ -926,7 +926,7 @@ static int cli_loadndb(FILE *fs, struct cl_engine *engine, unsigned int *signo,

 	if(engine->ignored && cli_chkign(engine->ignored, virname, buffer_cpy))

 	    continue;

-	if(!sdb && engine->cb_sigload && engine->cb_sigload("ndb", virname, engine->cb_sigload_ctx)) {

+	if(!sdb && engine->cb_sigload && engine->cb_sigload("ndb", virname, options & CL_DB_OFFICIAL, engine->cb_sigload_ctx)) {

 	    cli_dbgmsg("cli_loadndb: skipping %s due to callback\n", virname);

 	    continue;

 	}

@@ -1235,7 +1235,7 @@ static int load_oneldb(char *buffer, int chkpua, int chkign, struct cl_engine *e

     if (chkign && cli_chkign(engine->ignored, virname, buffer_cpy))

 	return CL_SUCCESS;

-    if(engine->cb_sigload && engine->cb_sigload("ldb", virname, engine->cb_sigload_ctx)) {

+    if(engine->cb_sigload && engine->cb_sigload("ldb", virname, options & CL_DB_OFFICIAL, engine->cb_sigload_ctx)) {

 	cli_dbgmsg("cli_loadldb: skipping %s due to callback\n", virname);

 	(*sigs)--;

 	return CL_SUCCESS;

@@ -1443,7 +1443,7 @@ static int cli_loadcbc(FILE *fs, struct cl_engine *engine, unsigned int *signo,

 	return CL_SUCCESS;

     }

-    if(engine->cb_sigload && engine->cb_sigload("cbc", dbname, engine->cb_sigload_ctx)) {

+    if(engine->cb_sigload && engine->cb_sigload("cbc", dbname, options & CL_DB_OFFICIAL, engine->cb_sigload_ctx)) {

 	cli_dbgmsg("cli_loadcbc: skipping %s due to callback\n", dbname);

 	return CL_SUCCESS;

     }

@@ -1948,7 +1948,7 @@ static int cli_loadhash(FILE *fs, struct cl_engine *engine, unsigned int *signo,

 		dot = dbname;

 	    else

 		dot++;

-	    if(engine->cb_sigload(dot, pt, engine->cb_sigload_ctx)) {

+	    if(engine->cb_sigload(dot, pt, options & CL_DB_OFFICIAL, engine->cb_sigload_ctx)) {

 		cli_dbgmsg("cli_loadhash: skipping %s (%s) due to callback\n", pt, dot);

 	        continue;

 	    }

@@ -2090,7 +2090,7 @@ static int cli_loadmd(FILE *fs, struct cl_engine *engine, unsigned int *signo, i

 	    continue;

 	}

-	if(engine->cb_sigload && engine->cb_sigload("md", new->virname, engine->cb_sigload_ctx)) {

+	if(engine->cb_sigload && engine->cb_sigload("md", new->virname, options & CL_DB_OFFICIAL, engine->cb_sigload_ctx)) {

 	    cli_dbgmsg("cli_loadmd: skipping %s due to callback\n", new->virname);

 	    mpool_free(engine->mempool, new->virname);

 	    mpool_free(engine->mempool, new);

@@ -2230,7 +2230,7 @@ static int cli_loadcdb(FILE *fs, struct cl_engine *engine, unsigned int *signo,

 	    continue;

 	}

-	if(engine->cb_sigload && engine->cb_sigload("cdb", new->virname, engine->cb_sigload_ctx)) {

+	if(engine->cb_sigload && engine->cb_sigload("cdb", new->virname, options & CL_DB_OFFICIAL, engine->cb_sigload_ctx)) {

 	    cli_dbgmsg("cli_loadcdb: skipping %s due to callback\n", new->virname);

 	    mpool_free(engine->mempool, new->virname);

 	    mpool_free(engine->mempool, new);

@@ -441,7 +441,7 @@ int load_regex_matcher(struct cl_engine *engine,struct regex_matcher* matcher,FI

 		if(functionality_level_check(buffer))

 			continue;

-		if(engine->cb_sigload && engine->cb_sigload("phishing", buffer, engine->cb_sigload_ctx)) {

+		if(engine->cb_sigload && engine->cb_sigload("phishing", buffer, options & CL_DB_OFFICIAL, engine->cb_sigload_ctx)) {

 			cli_dbgmsg("load_regex_matcher: skipping %s due to callback\n", buffer);

 			continue;

 		}

@@ -48,9 +48,13 @@ check_clamav.c: $(top_builddir)/test/clam.exe clamav.hdb

 clamav.hdb: input/clamav.hdb

 	cp $< $@

+check_clamav.c: $(top_builddir)/test/clam.exe clamav.hdb

 check_clamd.sh: $(top_builddir)/test/clam.exe check_clamd

 check_clamscan.sh: $(top_builddir)/test/clam.exe

+clamav.hdb: input/clamav.hdb

+	cp $< $@

+

 $(top_builddir)/test/clam.exe:

 	(cd $(top_builddir)/test && $(MAKE))

@@ -1102,9 +1102,13 @@ check_clamav.c: $(top_builddir)/test/clam.exe clamav.hdb

 clamav.hdb: input/clamav.hdb

 	cp $< $@

+check_clamav.c: $(top_builddir)/test/clam.exe clamav.hdb

 check_clamd.sh: $(top_builddir)/test/clam.exe check_clamd

 check_clamscan.sh: $(top_builddir)/test/clam.exe

+clamav.hdb: input/clamav.hdb

+	cp $< $@

+

 $(top_builddir)/test/clam.exe:

 	(cd $(top_builddir)/test && $(MAKE))

@@ -146,12 +146,90 @@ END_TEST

 START_TEST (test_cl_cvdparse)

 END_TEST

+static int get_test_file(int i, char *file, unsigned fsize, unsigned long *size);

+static struct cl_engine *g_engine;

+

 /* int cl_scandesc(int desc, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, const struct cl_limits *limits, unsigned int options) */

 START_TEST (test_cl_scandesc)

+{

+    const char *virname = NULL;

+    char file[256];

+    unsigned long size;

+    unsigned long int scanned = 0;

+    int ret;

+

+    int fd = get_test_file(_i, file, sizeof(file), &size);

+    cli_dbgmsg("scanning (scandesc) %s\n", file);

+    ret = cl_scandesc(fd, &virname, &scanned, g_engine, CL_SCAN_STDOPT);

+    cli_dbgmsg("scan end (scandesc) %s\n", file);

+

+    fail_unless_fmt(ret == CL_VIRUS, "cl_scandesc failed for %s: %s", file, cl_strerror(ret));

+    fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);

+    close(fd);

+}

 END_TEST

 /* int cl_scanfile(const char *filename, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, const struct cl_limits *limits, unsigned int options) */

 START_TEST (test_cl_scanfile)

+{

+    const char *virname = NULL;

+    char file[256];

+    unsigned long size;

+    unsigned long int scanned = 0;

+    int ret;

+

+    int fd = get_test_file(_i, file, sizeof(file), &size);

+    close(fd);

+

+    cli_dbgmsg("scanning (scanfile) %s\n", file);

+    ret = cl_scanfile(file, &virname, &scanned, g_engine, CL_SCAN_STDOPT);

+    cli_dbgmsg("scan end (scanfile) %s\n", file);

+

+    fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile failed for %s: %s", file, cl_strerror(ret));

+    fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);

+}

+END_TEST

+

+START_TEST (test_cl_scanfile_callback)

+{

+    const char *virname = NULL;

+    char file[256];

+    unsigned long size;

+    unsigned long int scanned = 0;

+    int ret;

+

+    int fd = get_test_file(_i, file, sizeof(file), &size);

+    close(fd);

+

+    cli_dbgmsg("scanning (scanfile_cb) %s\n", file);

+    /* TODO: test callbacks */

+    ret = cl_scanfile_callback(file, &virname, &scanned, g_engine, CL_SCAN_STDOPT, NULL);

+    cli_dbgmsg("scan end (scanfile_cb) %s\n", file);

+

+    fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile failed for %s: %s", file, cl_strerror(ret));

+    fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);

+}

+END_TEST

+

+START_TEST (test_cl_scandesc_callback)

+{

+    const char *virname = NULL;

+    char file[256];

+    unsigned long size;

+    unsigned long int scanned = 0;

+    int ret;

+

+    int fd = get_test_file(_i, file, sizeof(file), &size);

+

+    cli_dbgmsg("scanning (scandesc_cb) %s\n", file);

+    /* TODO: test callbacks */

+    ret = cl_scandesc_callback(fd, &virname, &scanned, g_engine, CL_SCAN_STDOPT, NULL);

+    cli_dbgmsg("scan end (scandesc_cb) %s\n", file);

+

+    fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile failed for %s: %s", file, cl_strerror(ret));

+    fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);

+    close(fd);

+}

 END_TEST

 /* int cl_load(const char *path, struct cl_engine **engine, unsigned int *signo, unsigned int options) */

@@ -180,6 +258,7 @@ END_TEST

 static char **testfiles = NULL;

 static unsigned testfiles_n = 0;

+static const expected_testfiles = 46;

 static void init_testfiles(void)

 {

@@ -201,6 +280,7 @@ static void init_testfiles(void)

 	testfiles[i-1] = strdup(dirent->d_name);

     }

     testfiles_n = i;

+    fail_unless_fmt(testfiles_n == expected_testfiles, "testfiles: %d != %d", testfiles_n, expected_testfiles);

     closedir(d);

 }

@@ -216,7 +296,6 @@ static void free_testfiles(void)

     testfiles_n = 0;

 }

-static struct cl_engine *g_engine;

 static int inited = 0;

 static void engine_setup(void)

@@ -334,8 +413,6 @@ static Suite *test_cl_suite(void)

     tcase_add_test(tc_cl, test_cl_retflevel);

     tcase_add_test(tc_cl, test_cl_cvdhead);

     tcase_add_test(tc_cl, test_cl_cvdparse);

-    tcase_add_test(tc_cl, test_cl_scandesc);

-    tcase_add_test(tc_cl, test_cl_scanfile);

     tcase_add_test(tc_cl, test_cl_load);

     tcase_add_test(tc_cl, test_cl_cvdverify);

     tcase_add_test(tc_cl, test_cl_statinidir);

@@ -345,9 +422,13 @@ static Suite *test_cl_suite(void)

     suite_add_tcase(s, tc_cl_scan);

     tcase_add_checked_fixture (tc_cl_scan, engine_setup, engine_teardown);

-    tcase_add_loop_test(tc_cl_scan, test_cl_scanmap_callback_handle, 0, 16);

-    tcase_add_loop_test(tc_cl_scan, test_cl_scanmap_callback_mem, 0, 16);

-

+    tcase_add_loop_test(tc_cl_scan, test_cl_scandesc, 0, expected_testfiles);

+    tcase_add_loop_test(tc_cl_scan, test_cl_scanfile, 0, expected_testfiles);

+    tcase_add_loop_test(tc_cl_scan, test_cl_scandesc_callback, 0, expected_testfiles);

+    tcase_add_loop_test(tc_cl_scan, test_cl_scanfile_callback, 0, expected_testfiles);

+    tcase_add_loop_test(tc_cl_scan, test_cl_scanmap_callback_handle, 0, expected_testfiles);

+    tcase_add_loop_test(tc_cl_scan, test_cl_scanmap_callback_mem, 0, expected_testfiles);

+    

     return s;

 }

@@ -691,6 +772,7 @@ int main(void)

     srunner_add_suite(sr, test_htmlnorm_suite());

     srunner_add_suite(sr, test_bytecode_suite());

+

     srunner_set_log(sr, "test.log");

     if(freopen("test-stderr.log","w+",stderr) == NULL) {

 	    fputs("Unable to redirect stderr!\n",stderr);

@@ -255,6 +255,12 @@ int CLAMAPI Scan_ScanObject(CClamAVScanner *pScanner, const wchar_t *pObjectPath

 int CLAMAPI Scan_ScanObjectByHandle(CClamAVScanner *pScanner, HANDLE object, int *pScanStatus, PCLAM_SCAN_INFO_LIST *pInfoList);

 /*

+ * Returns the outer file type as an _int64[2] for the give HANDLE

+ * Scan is not performed and no callback is invoked

+ */

+ int CLAMAPI Scan_GetFileType(HANDLE hFile, _int64 *filetype);

+

+/*

  * MANDATORY SUPPORT

  * Destroy memory allocated when malicious objects are found during scan

  * INPUT @param pScanner : opaque object

@@ -28,6 +28,58 @@

 #include "clscanapi.h"

 #include "interface.h"

+const char *types[] = {

+"HTML",

+"HTML_UTF16",

+"MSEXE",

+"GRAPHICS",

+"TEXT_ASCII",

+"TEXT_UTF8",

+"TEXT_UTF16LE",

+"TEXT_UTF16BE",

+"PDF",

+"SCRIPT",

+"RTF",

+"RIFF",

+"MSCHM",

+"MSCAB",

+"MSOLE2",

+"MSSZDD",

+"ZIP",

+"RAR",

+"7Z",

+"BZ",

+"GZ",

+"ARJ",

+"ZIPSFX",

+"RARSFX",

+"CABSFX",

+"ARJSFX",

+"NULSFT",

+"AUTOIT",

+"ISHIELD_MSI",

+"SFX",

+"BINHEX",

+"MAIL",

+"TNEF",

+"BINARY_DATA",

+"CRYPTFF",

+"UUENCODED",

+"SCRENC",

+"POSIX_TAR",

+"OLD_TAR",

+"ELF",

+"MACHO",

+"MACHO_UNIBIN",

+"SIS",

+"SWF",

+"CPIO_OLD",

+"CPIO_ODC",

+"CPIO_NEWC",

+"CPIO_CRC",

+NULL

+};

+

 int WINAPI SHCreateDirectoryExA(HWND, LPCTSTR, SECURITY_ATTRIBUTES *); /* cannot include Shlobj.h due to DATADIR collision */

 #define FMT(s) "!"__FUNCTION__": "s"\n"

@@ -55,6 +107,7 @@ typedef struct {

     CLAM_SCAN_CALLBACK scancb;

     void *scancb_ctx;

     unsigned int scanopts;

+    _int64 *filetype;

 } instance;

 struct {

@@ -73,6 +126,7 @@ BOOL minimal_definitions = FALSE;

 #define lock_instances()(WaitForSingleObject(instance_mutex, INFINITE) == WAIT_FAILED)

 #define unlock_instances() do {ReleaseMutex(instance_mutex);} while(0)

+cl_error_t filetype_cb(int fd, const char *detected_file_type, void *context);

 cl_error_t prescan_cb(int fd, const char *detected_file_type, void *context);

 cl_error_t postscan_cb(int fd, int result, const char *virname, void *context);

@@ -250,8 +304,8 @@ BOOL interface_setup(void) {

     return TRUE;

 }

-static int sigload_callback(const char *type, const char *name, void *context) {

-    if(minimal_definitions && strcmp(type, "fp"))

+static int sigload_callback(const char *type, const char *name, unsigned int custom, void *context) {

+    if(minimal_definitions && (custom || strcmp(type, "fp")))

 	return 1;

     return 0;

 }

@@ -355,7 +409,8 @@ int CLAMAPI Scan_Initialize(const wchar_t *pEnginesFolder, const wchar_t *pTempR

 	unlock_engine();

 	FAIL(CL_EMEM, "Not enough memory for a new engine");

     }

-    cl_engine_set_clcb_pre_cache(engine, prescan_cb);

+    cl_engine_set_clcb_pre_cache(engine, filetype_cb);

+    cl_engine_set_clcb_pre_scan(engine, prescan_cb);

     cl_engine_set_clcb_post_scan(engine, postscan_cb);

     minimal_definitions = bLoadMinDefs;

@@ -449,7 +504,7 @@ int CLAMAPI Scan_CreateInstance(CClamAVScanner **ppScanner) {

     INFN();

     if(!ppScanner)

 	FAIL(CL_ENULLARG, "NULL pScanner");

-    inst = calloc(1, sizeof(*inst));

+    inst = (instance *)calloc(1, sizeof(*inst));

     if(!inst)

 	FAIL(CL_EMEM, "CreateInstance: OOM");

     if(lock_engine()) {

@@ -887,7 +942,7 @@ int CLAMAPI Scan_ScanObjectByHandle(CClamAVScanner *pScanner, HANDLE object, int

     perf = GetTickCount();

     res = cl_scandesc_callback(fd, &virname, NULL, engine, inst->scanopts, &sctx);

-    do {

+    if(!inst->filetype) do {

 	CLAM_SCAN_INFO si;

 	CLAM_ACTION act;

 	DWORD cbperf;

@@ -935,7 +990,7 @@ int CLAMAPI Scan_ScanObjectByHandle(CClamAVScanner *pScanner, HANDLE object, int

     if(res == CL_VIRUS) {

 	logg("Scan_ScanObjectByHandle (instance %p): file is INFECTED with %s\n", inst, virname);

 	if(pInfoList) {

-	    CLAM_SCAN_INFO_LIST *infolist = calloc(1, sizeof(CLAM_SCAN_INFO_LIST) + sizeof(CLAM_SCAN_INFO) + MAX_VIRNAME_LEN * 2);

+	    CLAM_SCAN_INFO_LIST *infolist = (CLAM_SCAN_INFO_LIST *)calloc(1, sizeof(CLAM_SCAN_INFO_LIST) + sizeof(CLAM_SCAN_INFO) + MAX_VIRNAME_LEN * 2);

 	    PCLAM_SCAN_INFO scaninfo;

 	    wchar_t *wvirname;

 	    if(!infolist)

@@ -967,6 +1022,16 @@ int CLAMAPI Scan_ScanObjectByHandle(CClamAVScanner *pScanner, HANDLE object, int

     WIN();

 }

+int CLAMAPI Scan_GetFileType(HANDLE hFile, _int64 *filetype) {

+    instance *inst;

+    int status, ret = Scan_CreateInstance((CClamAVScanner **)&inst);

+    if(ret != CLAMAPI_SUCCESS)

+	return ret;

+    inst->filetype = filetype;

+    ret = Scan_ScanObjectByHandle((CClamAVScanner *)inst, hFile, &status, NULL);

+    Scan_DestroyInstance((CClamAVScanner *)inst);

+    return ret;

+}

 int CLAMAPI Scan_DeleteScanInfo(CClamAVScanner *pScanner, PCLAM_SCAN_INFO_LIST pInfoList) {

     logg("*in Scan_DeleteScanInfo(pScanner = %p, pInfoList = %p)\n", pScanner, pInfoList);

@@ -989,6 +1054,33 @@ int CLAMAPI Scan_DeleteScanInfo(CClamAVScanner *pScanner, PCLAM_SCAN_INFO_LIST p

     WIN();

 }

+cl_error_t filetype_cb(int fd, const char *type, void *context) {

+    struct scan_ctx *sctx = (struct scan_ctx *)context;

+    if(sctx && sctx->inst && sctx->inst->filetype) {

+	int i=0;

+	if(strncmp(type, "CL_TYPE_", 8)) {

+	    for(i=0; types[i]; i++) {

+		if(!strcmp(&type[8], types[i]))

+		    break;

+	    }

+	    if(!types[i]) i = -1;

+	} else

+	    i = -1;

+	if(i<0) {

+	    sctx->inst->filetype[0] = -1;

+	    sctx->inst->filetype[1] = -1;

+	} else if(i<64) {

+	    sctx->inst->filetype[0] = 1LL << i;

+	    sctx->inst->filetype[1] = 0;

+	} else {

+	    sctx->inst->filetype[0] = 0;

+	    sctx->inst->filetype[1] = 1LL << (i-64);

+	}

+	return CL_BREAK;

+    }

+    return CL_CLEAN;

+}

+

 cl_error_t prescan_cb(int fd, const char *type, void *context) {

     struct scan_ctx *sctx = (struct scan_ctx *)context;

     char tmpf[4096];

@@ -1003,6 +1095,9 @@ cl_error_t prescan_cb(int fd, const char *type, void *context) {

 	return CL_CLEAN;

     }

     inst = sctx->inst;

+    if(inst && inst->filetype)

+	return CL_CLEAN; /* Just in case, this shouldn't happen */

+

     logg("*in prescan_cb with clamav context %p, instance %p, fd %d, type %s)\n", context, inst, fd, type);

     if(strncmp(type, "CL_TYPE_", 8) ||

        (strcmp(&type[8], "BINARY_DATA") &&

@@ -1105,10 +1200,13 @@ cl_error_t postscan_cb(int fd, int result, const char *virname, void *context) {

 	logg("!postscan_cb called with NULL clamav context\n");

 	return CL_CLEAN;

     }

+    inst = sctx->inst;

+    if(inst && inst->filetype)

+	return CL_CLEAN; /* No callback, we are just filetyping */

+

     if(fd == sctx->entryfd)

 	return CL_CLEAN; /* Moved to after cl_scandesc returns due to heuristic results not being yet set in magicscan */

-    inst = sctx->inst;

     si.cbSize = sizeof(si);

     si.flags = 0;

     si.scanPhase = SCAN_PHASE_POSTSCAN;

@@ -256,7 +256,7 @@ bool SigUICopy::copySignatures(const wxString &staging)

     return OK;

 }

-int SigUICopy::sigprogress(const char* WXUNUSED(type), const char* WXUNUSED(name), void *context)

+int SigUICopy::sigprogress(const char* WXUNUSED(type), const char* WXUNUSED(name), unsigned int WXUNUSED(custom), void *context)

 {

     SigUICopy *p = (SigUICopy*)context;

     if (++p->cnt % 1000)

@@ -40,7 +40,7 @@ class SigUICopy

 		bool copySignatures(const wxString &staging);

 		bool loadDB(const wxString& dir);

 		bool canceled(void);

-		static int sigprogress(const char *type, const char *name, void *context);

+		static int sigprogress(const char *type, const char *name, unsigned int custom, void *context);

 };

 #endif