@@ -1,3 +1,8 @@

+Thu Mar 12 16:22:36 CET 2009 (tk)

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

+ * libclamav, clamd, clamscan: replace cl_engine_(set|get) with

+   cl_engine_set_(num|str) and cl_engine_get_(num|str)

+

 Thu Mar 12 16:57:45 EET 2009 (edwin)

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

  * libclamav/others_common.c: typo

@@ -106,7 +106,6 @@ int main(int argc, char **argv)

 	unsigned int sigs = 0;

 	int lsockets[2], nlsockets = 0;

 	unsigned int dboptions = 0;

-	uint32_t val32;

 #ifdef C_LINUX

 	struct stat sb;

 #endif

@@ -365,8 +364,8 @@ int main(int argc, char **argv)

 	}

 	if(pua_cats) {

-	    if((ret = cl_engine_set(engine, CL_ENGINE_PUA_CATEGORIES, pua_cats))) {

-		logg("!cli_engine_set(CL_ENGINE_PUA_CATEGORIES) failed: %s\n", cl_strerror(ret));

+	    if((ret = cl_engine_set_str(engine, CL_ENGINE_PUA_CATEGORIES, pua_cats))) {

+		logg("!cli_engine_set_str(CL_ENGINE_PUA_CATEGORIES) failed: %s\n", cl_strerror(ret));

 		free(pua_cats);

 		ret = 1;

 		break;

@@ -379,17 +378,15 @@ int main(int argc, char **argv)

     /* set the temporary dir */

     if((opt = optget(opts, "TemporaryDirectory"))->enabled) {

-	if((ret = cl_engine_set(engine, CL_ENGINE_TMPDIR, opt->strarg))) {

-	    logg("!cli_engine_set(CL_ENGINE_TMPDIR) failed: %s\n", cl_strerror(ret));

+	if((ret = cl_engine_set_str(engine, CL_ENGINE_TMPDIR, opt->strarg))) {

+	    logg("!cli_engine_set_str(CL_ENGINE_TMPDIR) failed: %s\n", cl_strerror(ret));

 	    ret = 1;

 	    break;

 	}

     }

-    if(optget(opts, "LeaveTemporaryFiles")->enabled) {

-	val32 = 1;

-	cl_engine_set(engine, CL_ENGINE_KEEPTMP, &val32);

-    }

+    if(optget(opts, "LeaveTemporaryFiles")->enabled)

+	cl_engine_set_num(engine, CL_ENGINE_KEEPTMP, 1);

     if(optget(opts, "PhishingSignatures")->enabled)

 	dboptions |= CL_DB_PHISHING;

@@ -403,13 +400,11 @@ int main(int argc, char **argv)

     if(optget(opts,"DevACOnly")->enabled) {

 	logg("#Only using the A-C matcher.\n");

-        val32 = 1;

-	cl_engine_set(engine, CL_ENGINE_AC_ONLY, &val32);

+	cl_engine_set_num(engine, CL_ENGINE_AC_ONLY, 1);

     }

     if((opt = optget(opts, "DevACDepth"))->enabled) {

-	val32 = opt->numarg;

-        cl_engine_set(engine, CL_ENGINE_AC_MAXDEPTH, &val32);

+        cl_engine_set_num(engine, CL_ENGINE_AC_MAXDEPTH, opt->numarg);

 	logg("#Max A-C depth set to %u\n", opt->numarg);

     }

@@ -692,8 +692,7 @@ int recvloop_th(int *socketds, unsigned nsockets, struct cl_engine *engine, unsi

 	char buff[BUFFSIZE + 1];

 	pid_t mainpid;

 	int idletimeout;

-	uint32_t val32;

-	uint64_t val64;

+	unsigned long long val;

 	size_t i, j, rr_last = 0;

 	pthread_t accept_th;

 	struct acceptdata acceptdata = ACCEPTDATA_INIT;

@@ -714,40 +713,36 @@ int recvloop_th(int *socketds, unsigned nsockets, struct cl_engine *engine, unsi

     /* set up limits */

     if((opt = optget(opts, "MaxScanSize"))->enabled) {

-	val64 = opt->numarg;

-	if((ret = cl_engine_set(engine, CL_ENGINE_MAX_SCANSIZE, &val64))) {

-	    logg("!cli_engine_set(CL_ENGINE_MAX_SCANSIZE) failed: %s\n", cl_strerror(ret));

+	if((ret = cl_engine_set_num(engine, CL_ENGINE_MAX_SCANSIZE, opt->numarg))) {

+	    logg("!cl_engine_set_num(CL_ENGINE_MAX_SCANSIZE) failed: %s\n", cl_strerror(ret));

 	    cl_engine_free(engine);

 	    return 1;

 	}

     }

-    cl_engine_get(engine, CL_ENGINE_MAX_SCANSIZE, &val64);

-    if(val64)

-    	logg("Limits: Global size limit set to %llu bytes.\n", (unsigned long long) val64);

+    val = cl_engine_get_num(engine, CL_ENGINE_MAX_SCANSIZE, NULL);

+    if(val)

+    	logg("Limits: Global size limit set to %llu bytes.\n", val);

     else

     	logg("^Limits: Global size limit protection disabled.\n");

     if((opt = optget(opts, "MaxFileSize"))->enabled) {

-	val64 = opt->numarg;

-	if((ret = cl_engine_set(engine, CL_ENGINE_MAX_FILESIZE, &val64))) {

-	    logg("!cli_engine_set(CL_ENGINE_MAX_FILESIZE) failed: %s\n", cl_strerror(ret));

+	if((ret = cl_engine_set_num(engine, CL_ENGINE_MAX_FILESIZE, opt->numarg))) {

+	    logg("!cl_engine_set_num(CL_ENGINE_MAX_FILESIZE) failed: %s\n", cl_strerror(ret));

 	    cl_engine_free(engine);

 	    return 1;

 	}

     }

-    cl_engine_get(engine, CL_ENGINE_MAX_FILESIZE, &val64);

-    if(val64)

-    	logg("Limits: File size limit set to %llu bytes.\n", (unsigned long long) val64);

+    val = cl_engine_get_num(engine, CL_ENGINE_MAX_FILESIZE, NULL);

+    if(val)

+    	logg("Limits: File size limit set to %llu bytes.\n", val);

     else

     	logg("^Limits: File size limit protection disabled.\n");

 #ifndef C_WINDOWS

     if(getrlimit(RLIMIT_FSIZE, &rlim) == 0) {

-	cl_engine_get(engine, CL_ENGINE_MAX_FILESIZE, &val64);

-	if(rlim.rlim_max < val64)

+	if(rlim.rlim_max < (rlim_t) cl_engine_get_num(engine, CL_ENGINE_MAX_FILESIZE, NULL))

 	    logg("^System limit for file size is lower than engine->maxfilesize\n");

-	cl_engine_get(engine, CL_ENGINE_MAX_SCANSIZE, &val64);

-	if(rlim.rlim_max < val64)

+	if(rlim.rlim_max < (rlim_t) cl_engine_get_num(engine, CL_ENGINE_MAX_SCANSIZE, NULL))

 	    logg("^System limit for file size is lower than engine->maxscansize\n");

     } else {

 	logg("^Cannot obtain resource limits for file size\n");

@@ -755,30 +750,28 @@ int recvloop_th(int *socketds, unsigned nsockets, struct cl_engine *engine, unsi

 #endif

     if((opt = optget(opts, "MaxRecursion"))->enabled) {

-	val32 = opt->numarg;

-	if((ret = cl_engine_set(engine, CL_ENGINE_MAX_RECURSION, &val32))) {

-	    logg("!cli_engine_set(CL_ENGINE_MAX_RECURSION) failed: %s\n", cl_strerror(ret));

+	if((ret = cl_engine_set_num(engine, CL_ENGINE_MAX_RECURSION, opt->numarg))) {

+	    logg("!cl_engine_set_num(CL_ENGINE_MAX_RECURSION) failed: %s\n", cl_strerror(ret));

 	    cl_engine_free(engine);

 	    return 1;

 	}

     }

-    cl_engine_get(engine, CL_ENGINE_MAX_RECURSION, &val32);

-    if(val32)

-    	logg("Limits: Recursion level limit set to %u.\n", (unsigned int) val32);

+    val = cl_engine_get_num(engine, CL_ENGINE_MAX_RECURSION, NULL);

+    if(val)

+    	logg("Limits: Recursion level limit set to %u.\n", (unsigned int) val);

     else

     	logg("^Limits: Recursion level limit protection disabled.\n");

     if((opt = optget(opts, "MaxFiles"))->enabled) {

-	val32 = opt->numarg;

-	if((ret = cl_engine_set(engine, CL_ENGINE_MAX_FILES, &val32))) {

-	    logg("!cli_engine_set(CL_ENGINE_MAX_FILES) failed: %s\n", cl_strerror(ret));

+	if((ret = cl_engine_set_num(engine, CL_ENGINE_MAX_FILES, opt->numarg))) {

+	    logg("!cl_engine_set_num(CL_ENGINE_MAX_FILES) failed: %s\n", cl_strerror(ret));

 	    cl_engine_free(engine);

 	    return 1;

 	}

     }

-    cl_engine_get(engine, CL_ENGINE_MAX_FILES, &val32);

-    if(val32)

-    	logg("Limits: Files limit set to %u.\n", (unsigned int) val32);

+    val = cl_engine_get_num(engine, CL_ENGINE_MAX_FILES, NULL);

+    if(val)

+    	logg("Limits: Files limit set to %u.\n", (unsigned int) val);

     else

     	logg("^Limits: Files limit protection disabled.\n");

@@ -885,26 +878,24 @@ int recvloop_th(int *socketds, unsigned nsockets, struct cl_engine *engine, unsi

         options |= CL_SCAN_STRUCTURED;

 	if((opt = optget(opts, "StructuredMinCreditCardCount"))->enabled) {

-	    val32 = opt->numarg;

-	    if((ret = cl_engine_set(engine, CL_ENGINE_MIN_CC_COUNT, &val32))) {

-		logg("!cli_engine_set(CL_ENGINE_MIN_CC_COUNT) failed: %s\n", cl_strerror(ret));

+	    if((ret = cl_engine_set_num(engine, CL_ENGINE_MIN_CC_COUNT, opt->numarg))) {

+		logg("!cl_engine_set_num(CL_ENGINE_MIN_CC_COUNT) failed: %s\n", cl_strerror(ret));

 		cl_engine_free(engine);

 		return 1;

 	    }

 	}

-	cl_engine_get(engine, CL_ENGINE_MIN_CC_COUNT, &val32);

-	logg("Structured: Minimum Credit Card Number Count set to %u\n", (unsigned int) val32);

+	val = cl_engine_get_num(engine, CL_ENGINE_MIN_CC_COUNT, NULL);

+	logg("Structured: Minimum Credit Card Number Count set to %u\n", (unsigned int) val);

 	if((opt = optget(opts, "StructuredMinSSNCount"))->enabled) {

-	    val32 = opt->numarg;

-	    if((ret = cl_engine_set(engine, CL_ENGINE_MIN_SSN_COUNT, &val32))) {

-		logg("!cli_engine_set(CL_ENGINE_MIN_SSN_COUNT) failed: %s\n", cl_strerror(ret));

+	    if((ret = cl_engine_set_num(engine, CL_ENGINE_MIN_SSN_COUNT, opt->numarg))) {

+		logg("!cl_engine_set_num(CL_ENGINE_MIN_SSN_COUNT) failed: %s\n", cl_strerror(ret));

 		cl_engine_free(engine);

 		return 1;

 	    }

 	}

-	cl_engine_get(engine, CL_ENGINE_MIN_SSN_COUNT, &val32);

-        logg("Structured: Minimum Social Security Number Count set to %u\n", (unsigned int) val32);

+	val = cl_engine_get_num(engine, CL_ENGINE_MIN_SSN_COUNT, NULL);

+        logg("Structured: Minimum Social Security Number Count set to %u\n", (unsigned int) val);

         if(optget(opts, "StructuredSSNFormatNormal")->enabled)

             options |= CL_SCAN_STRUCTURED_SSN_NORMAL;

@@ -407,12 +407,12 @@ static int print_ver(int desc, char term, const struct cl_engine *engine)

 {

     uint32_t ver;

-    cl_engine_get(engine, CL_ENGINE_DB_VERSION, &ver);

+    ver = cl_engine_get_num(engine, CL_ENGINE_DB_VERSION, NULL);

     if(ver) {

 	char timestr[32];

 	const char *tstr;

 	time_t t;

-	cl_engine_get(engine, CL_ENGINE_DB_TIME, &t);

+	t = cl_engine_get_num(engine, CL_ENGINE_DB_TIME, NULL);

 	tstr = cli_ctime(&t, timestr, sizeof(timestr));

 	/* cut trailing \n */

 	timestr[strlen(tstr)-1] = '\0';

@@ -337,8 +337,6 @@ int scanmanager(const struct optstruct *opts)

 #ifndef C_WINDOWS

 	struct rlimit rlim;

 #endif

-	uint64_t val64;

-	uint32_t val32;

     if(optget(opts, "phishing-sigs")->enabled)

 	dboptions |= CL_DB_PHISHING;

@@ -400,8 +398,8 @@ int scanmanager(const struct optstruct *opts)

 	}

 	if(pua_cats) {

-	    if((ret = cl_engine_set(engine, CL_ENGINE_PUA_CATEGORIES, pua_cats))) {

-		logg("!cli_engine_set(CL_ENGINE_PUA_CATEGORIES) failed: %s\n", cl_strerror(ret));

+	    if((ret = cl_engine_set_str(engine, CL_ENGINE_PUA_CATEGORIES, pua_cats))) {

+		logg("!cli_engine_set_str(CL_ENGINE_PUA_CATEGORIES) failed: %s\n", cl_strerror(ret));

 		free(pua_cats);

 		cl_engine_free(engine);

 		return 50;

@@ -410,24 +408,18 @@ int scanmanager(const struct optstruct *opts)

 	}

     }

-    if(optget(opts, "dev-ac-only")->enabled) {

-	val32 = 1;

-	cl_engine_set(engine, CL_ENGINE_AC_ONLY, &val32);

-    }

+    if(optget(opts, "dev-ac-only")->enabled)

+	cl_engine_set_num(engine, CL_ENGINE_AC_ONLY, 1);

-    if(optget(opts, "dev-ac-depth")->enabled) {

-	val32 = optget(opts, "dev-ac-depth")->numarg;

-	cl_engine_set(engine, CL_ENGINE_AC_MAXDEPTH, &val32);

-    }

+    if(optget(opts, "dev-ac-depth")->enabled)

+	cl_engine_set_num(engine, CL_ENGINE_AC_MAXDEPTH, optget(opts, "dev-ac-depth")->numarg);

-    if(optget(opts, "leave-temps")->enabled) {

-	val32 = 1;

-	cl_engine_set(engine, CL_ENGINE_KEEPTMP, &val32);

-    }

+    if(optget(opts, "leave-temps")->enabled)

+	cl_engine_set_num(engine, CL_ENGINE_KEEPTMP, 1);

     if((opt = optget(opts, "tempdir"))->enabled) {

-	if((ret = cl_engine_set(engine, CL_ENGINE_TMPDIR, opt->strarg))) {

-	    logg("!cli_engine_set(CL_ENGINE_TMPDIR) failed: %s\n", cl_strerror(ret));

+	if((ret = cl_engine_set_str(engine, CL_ENGINE_TMPDIR, opt->strarg))) {

+	    logg("!cli_engine_set_str(CL_ENGINE_TMPDIR) failed: %s\n", cl_strerror(ret));

 	    cl_engine_free(engine);

 	    return 50;

 	}

@@ -461,18 +453,16 @@ int scanmanager(const struct optstruct *opts)

     /* set limits */

     if((opt = optget(opts, "max-scansize"))->enabled) {

-	val64 = opt->numarg;

-	if((ret = cl_engine_set(engine, CL_ENGINE_MAX_SCANSIZE, &val64))) {

-	    logg("!cli_engine_set(CL_ENGINE_MAX_SCANSIZE) failed: %s\n", cl_strerror(ret));

+	if((ret = cl_engine_set_num(engine, CL_ENGINE_MAX_SCANSIZE, opt->numarg))) {

+	    logg("!cli_engine_set_num(CL_ENGINE_MAX_SCANSIZE) failed: %s\n", cl_strerror(ret));

 	    cl_engine_free(engine);

 	    return 50;

 	}

     }

     if((opt = optget(opts, "max-filesize"))->enabled) {

-	val64 = opt->numarg;

-	if((ret = cl_engine_set(engine, CL_ENGINE_MAX_FILESIZE, &val64))) {

-	    logg("!cli_engine_set(CL_ENGINE_MAX_FILESIZE) failed: %s\n", cl_strerror(ret));

+	if((ret = cl_engine_set_num(engine, CL_ENGINE_MAX_FILESIZE, opt->numarg))) {

+	    logg("!cli_engine_set_num(CL_ENGINE_MAX_FILESIZE) failed: %s\n", cl_strerror(ret));

 	    cl_engine_free(engine);

 	    return 50;

 	}

@@ -480,11 +470,9 @@ int scanmanager(const struct optstruct *opts)

 #ifndef C_WINDOWS

     if(getrlimit(RLIMIT_FSIZE, &rlim) == 0) {

-	cl_engine_get(engine, CL_ENGINE_MAX_FILESIZE, &val64);

-	if(rlim.rlim_max < val64)

+	if(rlim.rlim_max < (rlim_t) cl_engine_get_num(engine, CL_ENGINE_MAX_FILESIZE, NULL))

 	    logg("^System limit for file size is lower than engine->maxfilesize\n");

-	cl_engine_get(engine, CL_ENGINE_MAX_SCANSIZE, &val64);

-	if(rlim.rlim_max < val64)

+	if(rlim.rlim_max < (rlim_t) cl_engine_get_num(engine, CL_ENGINE_MAX_SCANSIZE, NULL))

 	    logg("^System limit for file size is lower than engine->maxscansize\n");

     } else {

 	logg("^Cannot obtain resource limits for file size\n");

@@ -492,18 +480,16 @@ int scanmanager(const struct optstruct *opts)

 #endif

     if((opt = optget(opts, "max-files"))->enabled) {

-	val32 = opt->numarg;

-	if((ret = cl_engine_set(engine, CL_ENGINE_MAX_FILES, &val32))) {

-	    logg("!cli_engine_set(CL_ENGINE_MAX_FILES) failed: %s\n", cl_strerror(ret));

+	if((ret = cl_engine_set_num(engine, CL_ENGINE_MAX_FILES, opt->numarg))) {

+	    logg("!cli_engine_set_num(CL_ENGINE_MAX_FILES) failed: %s\n", cl_strerror(ret));

 	    cl_engine_free(engine);

 	    return 50;

 	}

     }

     if((opt = optget(opts, "max-recursion"))->enabled) {

-	val32 = opt->numarg;

-	if((ret = cl_engine_set(engine, CL_ENGINE_MAX_RECURSION, &val32))) {

-	    logg("!cli_engine_set(CL_ENGINE_MAX_RECURSION) failed: %s\n", cl_strerror(ret));

+	if((ret = cl_engine_set_num(engine, CL_ENGINE_MAX_RECURSION, opt->numarg))) {

+	    logg("!cli_engine_set_num(CL_ENGINE_MAX_RECURSION) failed: %s\n", cl_strerror(ret));

 	    cl_engine_free(engine);

 	    return 50;

 	}

@@ -576,18 +562,16 @@ int scanmanager(const struct optstruct *opts)

 	}

 	if((opt = optget(opts, "structured-ssn-count"))->enabled) {

-	    val32 = opt->numarg;

-	    if((ret = cl_engine_set(engine, CL_ENGINE_MIN_SSN_COUNT, &val32))) {

-		logg("!cli_engine_set(CL_ENGINE_MIN_SSN_COUNT) failed: %s\n", cl_strerror(ret));

+	    if((ret = cl_engine_set_num(engine, CL_ENGINE_MIN_SSN_COUNT, opt->numarg))) {

+		logg("!cli_engine_set_num(CL_ENGINE_MIN_SSN_COUNT) failed: %s\n", cl_strerror(ret));

 		cl_engine_free(engine);

 		return 50;

 	    }

 	}

 	if((opt = optget(opts, "structured-cc-count"))->enabled) {

-	    val32 = opt->numarg;

-	    if((ret = cl_engine_set(engine, CL_ENGINE_MIN_CC_COUNT, &val32))) {

-		logg("!cli_engine_set(CL_ENGINE_MIN_CC_COUNT) failed: %s\n", cl_strerror(ret));

+	    if((ret = cl_engine_set_num(engine, CL_ENGINE_MIN_CC_COUNT, opt->numarg))) {

+		logg("!cli_engine_set_num(CL_ENGINE_MIN_CC_COUNT) failed: %s\n", cl_strerror(ret));

 		cl_engine_free(engine);

 		return 50;

 	    }

@@ -38,6 +38,7 @@ typedef enum {

     CL_SUCCESS = 0,

     CL_VIRUS,

     CL_ENULLARG,

+    CL_EARG,

     CL_EMALFDB,

     CL_ECVD,

     CL_EVERIFY,

@@ -110,7 +111,7 @@ struct cl_engine;

 struct cl_settings;

 #define CL_INIT_DEFAULT	0x0

-extern int cl_init(unsigned int options);

+extern int cl_init(unsigned int initoptions);

 extern struct cl_engine *cl_engine_new(void);

@@ -131,9 +132,13 @@ enum cl_engine_field {

     CL_ENGINE_KEEPTMP		    /* uint32_t */

 };

-extern int cl_engine_set(struct cl_engine *engine, enum cl_engine_field field, const void *val);

+extern int cl_engine_set_num(struct cl_engine *engine, enum cl_engine_field field, long long num);

-extern int cl_engine_get(const struct cl_engine *engine, enum cl_engine_field field, void *val);

+long long cl_engine_get_num(const struct cl_engine *engine, enum cl_engine_field field, int *err);

+

+int cl_engine_set_str(struct cl_engine *engine, enum cl_engine_field field, const char *str);

+

+const char *cl_engine_get_str(const struct cl_engine *engine, enum cl_engine_field field, int *err);

 extern struct cl_settings *cl_engine_settings_copy(const struct cl_engine *engine);

@@ -168,12 +173,12 @@ struct cl_cvd {		    /* field no. */

 };

 /* file scanning */

-extern int cl_scandesc(int desc, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, unsigned int options);

+extern int cl_scandesc(int desc, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, unsigned int scanoptions);

-extern int cl_scanfile(const char *filename, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, unsigned int options);

+extern int cl_scanfile(const char *filename, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, unsigned int scanoptions);

 /* database handling */

-extern int cl_load(const char *path, struct cl_engine *engine, unsigned int *signo, unsigned int options);

+extern int cl_load(const char *path, struct cl_engine *engine, unsigned int *signo, unsigned int dboptions);

 extern const char *cl_retdbdir(void);

 /* engine handling */

@@ -7,8 +7,10 @@ CLAMAV_PUBLIC {

     cl_debug;

     cl_init;

     cl_engine_new;

-    cl_engine_set;

-    cl_engine_get;

+    cl_engine_set_num;

+    cl_engine_get_num;

+    cl_engine_set_str;

+    cl_engine_get_str;

     cl_engine_settings_copy;

     cl_engine_settings_apply;

     cl_engine_settings_free;

@@ -146,6 +146,8 @@ const char *cl_strerror(int clerror)

 	    return "Virus(es) detected";

 	case CL_ENULLARG:

 	    return "Null argument passed to function";

+	case CL_EARG:

+	    return "Invalid argument passed to function";

 	case CL_EMALFDB:

 	    return "Malformed database";

 	case CL_ECVD:

@@ -196,7 +198,7 @@ const char *cl_strerror(int clerror)

     }

 }

-int cl_init(unsigned int options)

+int cl_init(unsigned int initoptions)

 {

     /* put dlopen() stuff here, etc. */

     cli_rarload();

@@ -260,123 +262,151 @@ struct cl_engine *cl_engine_new(void)

     return new;

 }

-int cl_engine_set(struct cl_engine *engine, enum cl_engine_field field, const void *val)

+int cl_engine_set_num(struct cl_engine *engine, enum cl_engine_field field, long long num)

 {

-    if(!engine || !val)

+    if(!engine)

 	return CL_ENULLARG;

+    /* TODO: consider adding checks and warn/errs when num overflows the

+     * destination type

+     */

     switch(field) {

 	case CL_ENGINE_MAX_SCANSIZE:

-	    engine->maxscansize = *((const uint64_t *) val);

+	    engine->maxscansize = num;

 	    break;

 	case CL_ENGINE_MAX_FILESIZE:

-	    engine->maxfilesize = *((const uint64_t *) val);

+	    engine->maxfilesize = num;

 	    break;

 	case CL_ENGINE_MAX_RECURSION:

-	    engine->maxreclevel = *((const uint32_t *) val);

+	    engine->maxreclevel = num;

 	    break;

 	case CL_ENGINE_MAX_FILES:

-	    engine->maxfiles = *((const uint32_t *) val);

+	    engine->maxfiles = num;

 	    break;

 	case CL_ENGINE_MIN_CC_COUNT:

-	    engine->min_cc_count = *((const uint32_t *) val);

+	    engine->min_cc_count = num;

 	    break;

 	case CL_ENGINE_MIN_SSN_COUNT:

-	    engine->min_ssn_count = *((const uint32_t *) val);

-	    break;

-	case CL_ENGINE_PUA_CATEGORIES:

-	    engine->pua_cats = cli_mpool_strdup(engine->mempool, (const char *) val);

-	    if(!engine->pua_cats)

-		return CL_EMEM;

+	    engine->min_ssn_count = num;

 	    break;

 	case CL_ENGINE_DB_VERSION:

 	case CL_ENGINE_DB_TIME:

-	    cli_warnmsg("cl_engine_set: The field is read only\n");

-	    break;

+	    cli_warnmsg("cl_engine_set_num: The field is read only\n");

+	    return CL_EARG;

 	case CL_ENGINE_AC_ONLY:

-	    engine->ac_only = *((const uint32_t *) val);

+	    engine->ac_only = num;

 	    break;

 	case CL_ENGINE_AC_MINDEPTH:

-	    engine->ac_mindepth = *((const uint32_t *) val);

+	    engine->ac_mindepth = num;

 	    break;

 	case CL_ENGINE_AC_MAXDEPTH:

-	    engine->ac_maxdepth = *((const uint32_t *) val);

-	    break;

-	case CL_ENGINE_TMPDIR:

-	    engine->tmpdir = cli_mpool_strdup(engine->mempool, (const char *) val);

-	    if(!engine->tmpdir)

-		return CL_EMEM;

+	    engine->ac_maxdepth = num;

 	    break;

 	case CL_ENGINE_KEEPTMP:

-	    engine->keeptmp = *((const uint32_t *) val);

+	    engine->keeptmp = num;

 	    break;

 	default:

-	    cli_errmsg("cl_engine_set: Incorrect field number\n");

-	    return CL_ENULLARG; /* FIXME */

+	    cli_errmsg("cl_engine_set_num: Incorrect field number\n");

+	    return CL_EARG;

     }

     return CL_SUCCESS;

 }

-int cl_engine_get(const struct cl_engine *engine, enum cl_engine_field field, void *val)

+long long cl_engine_get_num(const struct cl_engine *engine, enum cl_engine_field field, int *err)

 {

-    if(!engine || !val)

-	return CL_ENULLARG;

+    if(!engine) {

+	cli_errmsg("cl_engine_get_num: engine == NULL\n");

+	if(err)

+	    *err = CL_ENULLARG;

+	return -1;

+    }

+

+    if(err)

+	*err = CL_SUCCESS;

     switch(field) {

 	case CL_ENGINE_MAX_SCANSIZE:

-	    *((uint64_t *) val) = engine->maxscansize;

-	    break;

+	    return engine->maxscansize;

 	case CL_ENGINE_MAX_FILESIZE:

-	    *((uint64_t *) val) = engine->maxfilesize;

-	    break;

+	    return engine->maxfilesize;

 	case CL_ENGINE_MAX_RECURSION:

-	    *((uint32_t *) val) = engine->maxreclevel;

-	    break;

+	    return engine->maxreclevel;

 	case CL_ENGINE_MAX_FILES:

-	    *((uint32_t *) val) = engine->maxfiles;

-	    break;

+	    return engine->maxfiles;

 	case CL_ENGINE_MIN_CC_COUNT:

-	    *((uint32_t *) val) = engine->min_cc_count;

-	    break;

+	    return engine->min_cc_count;

 	case CL_ENGINE_MIN_SSN_COUNT:

-	    *((uint32_t *) val) = engine->min_ssn_count;

-	    break;

-	case CL_ENGINE_PUA_CATEGORIES:

-	    if(engine->pua_cats)

-		strncpy((char *) val, engine->pua_cats, 128);

-	    break;

+	    return engine->min_ssn_count;

 	case CL_ENGINE_DB_VERSION:

-	    *((uint32_t *) val) = engine->dbversion[0];

-	    break;

+	    return engine->dbversion[0];

 	case CL_ENGINE_DB_TIME:

-	    /* time_t may be 64-bit! */

-	    *((time_t *) val) = engine->dbversion[1];

-	    break;

+	    return engine->dbversion[1];

 	case CL_ENGINE_AC_ONLY:

-	    *((uint32_t *) val) = engine->ac_only;

-	    break;

+	    return engine->ac_only;

 	case CL_ENGINE_AC_MINDEPTH:

-	    *((uint32_t *) val) = engine->ac_mindepth;

-	    break;

+	    return engine->ac_mindepth;

 	case CL_ENGINE_AC_MAXDEPTH:

-	    *((uint32_t *) val) = engine->ac_maxdepth;

+	    return engine->ac_maxdepth;

+	case CL_ENGINE_KEEPTMP:

+	    return engine->keeptmp;

+	default:

+	    cli_errmsg("cl_engine_get: Incorrect field number\n");

+	    if(err)

+		*err = CL_EARG;

+	    return -1;

+    }

+}

+

+int cl_engine_set_str(struct cl_engine *engine, enum cl_engine_field field, const char *str)

+{

+    if(!engine)

+	return CL_ENULLARG;

+

+    switch(field) {

+	case CL_ENGINE_PUA_CATEGORIES:

+	    engine->pua_cats = cli_mpool_strdup(engine->mempool, str);

+	    if(!engine->pua_cats)

+		return CL_EMEM;

 	    break;

 	case CL_ENGINE_TMPDIR:

-	    if(engine->tmpdir)

-		strncpy((char *) val, engine->tmpdir, 128);

-	    break;

-	case CL_ENGINE_KEEPTMP:

-	    *((uint32_t *) val) = engine->keeptmp;

+	    engine->tmpdir = cli_mpool_strdup(engine->mempool, str);

+	    if(!engine->tmpdir)

+		return CL_EMEM;

 	    break;

 	default:

-	    cli_errmsg("cl_engine_get: Incorrect field number\n");

-	    return CL_ENULLARG; /* FIXME */

+	    cli_errmsg("cl_engine_set_num: Incorrect field number\n");

+	    return CL_EARG;

     }

     return CL_SUCCESS;

 }

+const char *cl_engine_get_str(const struct cl_engine *engine, enum cl_engine_field field, int *err)

+{

+    if(!engine) {

+	cli_errmsg("cl_engine_get_str: engine == NULL\n");

+	if(err)

+	    *err = CL_ENULLARG;

+	return NULL;

+    }

+

+    if(err)

+	*err = CL_SUCCESS;

+

+    switch(field) {

+	case CL_ENGINE_PUA_CATEGORIES:

+	    return engine->pua_cats;

+	case CL_ENGINE_TMPDIR:

+	    return engine->tmpdir;

+	default:

+	    cli_errmsg("cl_engine_get: Incorrect field number\n");

+	    if(err)

+		*err = CL_EARG;

+	    return NULL;

+    }

+}

+

 struct cl_settings *cl_engine_settings_copy(const struct cl_engine *engine)

 {

 	struct cl_settings *settings;

@@ -1639,7 +1639,7 @@ static int cli_loaddbdir(const char *dirname, struct cl_engine *engine, unsigned

     return ret;

 }

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

+int cl_load(const char *path, struct cl_engine *engine, unsigned int *signo, unsigned int dboptions)

 {

 	struct stat sb;

 	int ret;

@@ -1654,19 +1654,19 @@ int cl_load(const char *path, struct cl_engine *engine, unsigned int *signo, uns

         return CL_ESTAT;

     }

-    if((options & CL_DB_PHISHING_URLS) && !engine->phishcheck && (engine->dconf->phishing & PHISHING_CONF_ENGINE))

+    if((dboptions & CL_DB_PHISHING_URLS) && !engine->phishcheck && (engine->dconf->phishing & PHISHING_CONF_ENGINE))

 	if((ret = phishing_init(engine)))

 	    return ret;

-    engine->dboptions = options;

+    engine->dboptions = dboptions;

     switch(sb.st_mode & S_IFMT) {

 	case S_IFREG: 

-	    ret = cli_load(path, engine, signo, options, NULL);

+	    ret = cli_load(path, engine, signo, dboptions, NULL);

 	    break;

 	case S_IFDIR:

-	    ret = cli_loaddbdir(path, engine, signo, options);

+	    ret = cli_loaddbdir(path, engine, signo, dboptions);

 	    break;

 	default:

@@ -2114,7 +2114,7 @@ int cli_magic_scandesc(int desc, cli_ctx *ctx)

     }

 }

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

+int cl_scandesc(int desc, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, unsigned int scanoptions)

 {

     cli_ctx ctx;

     int rc;

@@ -2123,7 +2123,7 @@ int cl_scandesc(int desc, const char **virname, unsigned long int *scanned, cons

     ctx.engine = engine;

     ctx.virname = virname;

     ctx.scanned = scanned;

-    ctx.options = options;

+    ctx.options = scanoptions;

     ctx.found_possibly_unwanted = 0;

     ctx.dconf = (struct cli_dconf *) engine->dconf;

@@ -2168,7 +2168,7 @@ static int cli_scanfile(const char *filename, cli_ctx *ctx)

     return ret;

 }

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

+int cl_scanfile(const char *filename, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, unsigned int scanoptions)

 {

 	int fd, ret;

@@ -2176,7 +2176,7 @@ int cl_scanfile(const char *filename, const char **virname, unsigned long int *s

     if((fd = open(filename, O_RDONLY|O_BINARY)) == -1)

 	return CL_EOPEN;

-    ret = cl_scandesc(fd, virname, scanned, engine, options);

+    ret = cl_scandesc(fd, virname, scanned, engine, scanoptions);

     close(fd);

     return ret;