@@ -191,7 +191,7 @@ int cli_7unz(cli_ctx *ctx, size_t offset)

                 cli_dbgmsg("cli_7unz: Saving to %s\n", tmp_name);

                 if (cli_writen(fd, outBuffer + offset, outSizeProcessed) != outSizeProcessed)

                     found = CL_EWRITE;

-                else if ((found = cli_magic_scandesc(fd, tmp_name, ctx, name)) == CL_VIRUS)

+                else if ((found = cli_magic_scan_desc(fd, tmp_name, ctx, name)) == CL_VIRUS)

                     viruses_found++;

                 close(fd);

                 if (!ctx->engine->keeptmp && cli_unlink(tmp_name))

@@ -222,8 +222,8 @@ int cli_scanapm(cli_ctx *ctx)

         cli_dbgmsg("Blocks: [%u, +%u), ([%lu, +%lu))\n",

                    apentry.pBlockStart, apentry.pBlockCount, (long unsigned)partoff, (long unsigned)partsize);

-        /* send the partition to cli_map_scan */

-        ret = cli_map_scan(*ctx->fmap, partoff, partsize, ctx, CL_TYPE_PART_ANY, (const char *)apentry.name);

+        /* send the partition to cli_magic_scan_nested_fmap_type */

+        ret = cli_magic_scan_nested_fmap_type(*ctx->fmap, partoff, partsize, ctx, CL_TYPE_PART_ANY, (const char *)apentry.name);

         if (ret != CL_CLEAN) {

             if (SCAN_ALLMATCHES && (ret == CL_VIRUS))

                 detection = CL_VIRUS;

@@ -451,8 +451,7 @@ const char *autoit_functions[] = {

     "WINWAIT",

     "WINWAITACTIVE",

     "WINWAITCLOSE",

-    "WINWAITNOTACTIVE"

-};

+    "WINWAITNOTACTIVE"};

 const char *autoit_keywords[] = {

     "UNKNOWN_0",

@@ -858,7 +857,7 @@ static int ea05(cli_ctx *ctx, const uint8_t *base, char *tmpd)

             close(i);

             return CL_ESEEK;

         }

-        if (cli_magic_scandesc(i, tempfile, ctx, NULL) == CL_VIRUS) {

+        if (cli_magic_scan_desc(i, tempfile, ctx, NULL) == CL_VIRUS) {

             if (!SCAN_ALLMATCHES) {

                 close(i);

                 if (!ctx->engine->keeptmp)

@@ -1185,7 +1184,7 @@ static int ea06(cli_ctx *ctx, const uint8_t *base, char *tmpd)

                             cli_dbgmsg("autoit: too few bytes present - expected enough for a keyword ID\n");

                             break;

                         }

-                        keyword_id  = cli_readint32((char *)&UNP.outputbuf[UNP.cur_input]);

+                        keyword_id = cli_readint32((char *)&UNP.outputbuf[UNP.cur_input]);

                         if (keyword_id >= (sizeof(autoit_keywords) / sizeof(autoit_keywords[0]))) {

                             UNP.error = 1;

                             cli_dbgmsg("autoit: unknown AutoIT keyword ID: 0x%x\n", keyword_id);

@@ -1219,7 +1218,7 @@ static int ea06(cli_ctx *ctx, const uint8_t *base, char *tmpd)

                             cli_dbgmsg("autoit: too few bytes present - expected enough for a function ID\n");

                             break;

                         }

-                        function_id  = cli_readint32((char *)&UNP.outputbuf[UNP.cur_input]);

+                        function_id = cli_readint32((char *)&UNP.outputbuf[UNP.cur_input]);

                         if (function_id >= (sizeof(autoit_functions) / sizeof(autoit_functions[0]))) {

                             UNP.error = 1;

                             cli_dbgmsg("autoit: unknown AutoIT function ID: 0x%x\n", function_id);

@@ -1467,7 +1466,7 @@ static int ea06(cli_ctx *ctx, const uint8_t *base, char *tmpd)

             close(i);

             return CL_ESEEK;

         }

-        if (cli_magic_scandesc(i, tempfile, ctx, NULL) == CL_VIRUS) {

+        if (cli_magic_scan_desc(i, tempfile, ctx, NULL) == CL_VIRUS) {

             if (!SCAN_ALLMATCHES) {

                 close(i);

                 if (!ctx->engine->keeptmp)

@@ -122,7 +122,7 @@ int cli_binhex(cli_ctx *ctx)

                         ret = CL_ESEEK;

                         break;

                     }

-                    ret = cli_magic_scandesc(datafd, dname, ctx, NULL);

+                    ret = cli_magic_scan_desc(datafd, dname, ctx, NULL);

                     if (ret == CL_VIRUS) break;

                 }

                 if (dec_done)

@@ -168,7 +168,7 @@ int cli_binhex(cli_ctx *ctx)

                         ret = CL_ESEEK;

                         break;

                     }

-                    ret = cli_magic_scandesc(resfd, rname, ctx, NULL);

+                    ret = cli_magic_scan_desc(resfd, rname, ctx, NULL);

                     break;

                 }

             }

@@ -180,7 +180,7 @@ int cli_binhex(cli_ctx *ctx)

                         ret = CL_ESEEK;

                         break;

                     }

-                    ret = cli_magic_scandesc(datafd, dname, ctx, NULL);

+                    ret = cli_magic_scan_desc(datafd, dname, ctx, NULL);

                 } else if (write_phase == IN_RES) {

                     cli_dbgmsg("cli_binhex: scanning partially extracted resource fork\n");

                     if (lseek(resfd, 0, SEEK_SET) == -1) {

@@ -188,7 +188,7 @@ int cli_binhex(cli_ctx *ctx)

                         ret = CL_ESEEK;

                         break;

                     }

-                    ret = cli_magic_scandesc(resfd, rname, ctx, NULL);

+                    ret = cli_magic_scan_desc(resfd, rname, ctx, NULL);

                 }

                 break;

             }

@@ -584,7 +584,7 @@ int fileblobAddData(fileblob *fb, const unsigned char *data, size_t len)

                     *ctx->scanned += (unsigned long)len / CL_COUNT_PRECISION;

                 fb->bytes_scanned += (unsigned long)len;

-                if ((len > 5) && cli_updatelimits(ctx, len) == CL_CLEAN && (cli_scanbuff(data, (unsigned int)len, 0, ctx->virname, ctx->engine, CL_TYPE_BINARY_DATA, NULL) == CL_VIRUS)) {

+                if ((len > 5) && cli_updatelimits(ctx, len) == CL_CLEAN && (cli_scan_buff(data, (unsigned int)len, 0, ctx->virname, ctx->engine, CL_TYPE_BINARY_DATA, NULL) == CL_VIRUS)) {

                     cli_dbgmsg("fileblobAddData: found %s\n", cli_get_last_virus_str(ctx->virname));

                     fb->isInfected = 1;

                 }

@@ -649,7 +649,7 @@ int fileblobScan(const fileblob *fb)

         virus_found = 1;

     }

-    rc = cli_magic_scandesc(fb->fd, fb->fullname, fb->ctx, fb->b.name);

+    rc = cli_magic_scan_desc(fb->fd, fb->fullname, fb->ctx, fb->b.name);

     if (rc == CL_VIRUS || virus_found != 0) {

         cli_dbgmsg("%s is infected\n", fb->fullname);

         return CL_VIRUS;

@@ -164,12 +164,12 @@ static int cli_bytecode_context_reset(struct cli_bc_ctx *ctx)

             snprintf(fullname, 1024, "%s" PATHSEP "javascript", ctx->jsnormdir);

             fd = open(fullname, O_RDONLY | O_BINARY);

             if (fd >= 0) {

-                ret = cli_scandesc(fd, cctx, CL_TYPE_HTML, 0, NULL, AC_SCAN_VIR, NULL, NULL);

+                ret = cli_scan_desc(fd, cctx, CL_TYPE_HTML, 0, NULL, AC_SCAN_VIR, NULL, NULL);

                 if (ret == CL_CLEAN) {

                     if (lseek(fd, 0, SEEK_SET) == -1)

                         cli_dbgmsg("cli_bytecode: call to lseek() has failed\n");

                     else

-                        ret = cli_scandesc(fd, cctx, CL_TYPE_TEXT_ASCII, 0, NULL, AC_SCAN_VIR, NULL, NULL);

+                        ret = cli_scan_desc(fd, cctx, CL_TYPE_TEXT_ASCII, 0, NULL, AC_SCAN_VIR, NULL, NULL);

                 }

                 close(fd);

             }

@@ -2906,7 +2906,7 @@ int cli_bytecode_runhook(cli_ctx *cctx, const struct cl_engine *engine, struct c

                 lseek(fd, 0, SEEK_SET);

                 cli_dbgmsg("***** Scanning unpacked file ******\n");

                 cctx->recursion++;

-                ret = cli_magic_scandesc(fd, tempfile, cctx, NULL);

+                ret = cli_magic_scan_desc(fd, tempfile, cctx, NULL);

                 cctx->recursion--;

                 if (!cctx->engine->keeptmp)

                     if (ftruncate(fd, 0) == -1)

@@ -552,7 +552,7 @@ int32_t cli_bcapi_extract_new(struct cli_bc_ctx *ctx, int32_t id)

             size_t csize = cli_get_container_size(cctx, -2);

             cli_set_container(cctx, ctx->containertype, csize);

         }

-        res = cli_magic_scandesc(ctx->outfd, ctx->tempfile, cctx, NULL);

+        res = cli_magic_scan_desc(ctx->outfd, ctx->tempfile, cctx, NULL);

         cctx->recursion--;

         if (res == CL_VIRUS) {

             ctx->virname = cli_get_last_virus(cctx);

@@ -163,7 +163,7 @@ int cli_scancpio_old(cli_ctx *ctx)

             if (ret == CL_EMAXFILES) {

                 goto leave;

             } else if (ret == CL_SUCCESS) {

-                ret = cli_map_scan(*ctx->fmap, pos, filesize, ctx, CL_TYPE_ANY, name);

+                ret = cli_magic_scan_nested_fmap_type(*ctx->fmap, pos, filesize, ctx, CL_TYPE_ANY, name);

                 if (ret == CL_VIRUS) {

                     if (!SCAN_ALLMATCHES)

                         return ret;

@@ -252,7 +252,7 @@ int cli_scancpio_odc(cli_ctx *ctx)

         if (ret == CL_EMAXFILES) {

             goto leave;

         } else if (ret == CL_SUCCESS) {

-            ret = cli_map_scan(*ctx->fmap, pos, filesize, ctx, CL_TYPE_ANY, name);

+            ret = cli_magic_scan_nested_fmap_type(*ctx->fmap, pos, filesize, ctx, CL_TYPE_ANY, name);

             if (ret == CL_VIRUS) {

                 if (!SCAN_ALLMATCHES)

                     return ret;

@@ -345,7 +345,7 @@ int cli_scancpio_newc(cli_ctx *ctx, int crc)

         if (ret == CL_EMAXFILES) {

             goto leave;

         } else if (ret == CL_SUCCESS) {

-            ret = cli_map_scan(*ctx->fmap, pos, filesize, ctx, CL_TYPE_ANY, name);

+            ret = cli_magic_scan_nested_fmap_type(*ctx->fmap, pos, filesize, ctx, CL_TYPE_ANY, name);

             if (ret == CL_VIRUS) {

                 if (!SCAN_ALLMATCHES)

                     return ret;

@@ -178,8 +178,8 @@ int cli_scandmg(cli_ctx *ctx)

         }

     }

-    /* scan XML with cli_map_scan */

-    ret = cli_map_scan(*ctx->fmap, (off_t)hdr.xmlOffset, (size_t)hdr.xmlLength, ctx, CL_TYPE_ANY, NULL);

+    /* scan XML with cli_magic_scan_nested_fmap_type */

+    ret = cli_magic_scan_nested_fmap_type(*ctx->fmap, (off_t)hdr.xmlOffset, (size_t)hdr.xmlLength, ctx, CL_TYPE_ANY, NULL);

     if (ret != CL_CLEAN) {

         cli_dbgmsg("cli_scandmg: retcode from scanning TOC xml: %s\n", cl_strerror(ret));

         if (!ctx->engine->keeptmp)

@@ -1083,7 +1083,7 @@ static int dmg_handle_mish(cli_ctx *ctx, unsigned int mishblocknum, char *dir,

     /* If okay so far, scan rebuilt partition */

     if (ret == CL_CLEAN) {

         /* Have to keep partition typing separate */

-        ret = cli_base_scandesc(ofd, outfile, ctx, CL_TYPE_PART_ANY, NULL);

+        ret = cli_magic_scan_desc_type(ofd, outfile, ctx, CL_TYPE_PART_ANY, NULL);

     }

     close(ofd);

@@ -881,7 +881,7 @@ int cli_unpackelf(cli_ctx *ctx)

                     cli_dbgmsg("cli_scanelf: Unpacked and rebuilt executable\n");

                 lseek(ndesc, 0, SEEK_SET);

                 cli_dbgmsg("***** Scanning rebuilt ELF file *****\n");

-                if (cli_magic_scandesc(ndesc, tempfile, ctx, NULL) == CL_VIRUS) {

+                if (cli_magic_scan_desc(ndesc, tempfile, ctx, NULL) == CL_VIRUS) {

                     close(ndesc);

                     CLI_TMPUNLK();

                     free(tempfile);

@@ -138,8 +138,6 @@ static const struct ftmap_s {

 };

 // clang-format on

-cli_file_t cli_partitiontype(const unsigned char *buf, size_t buflen, const struct cl_engine *engine);

-

 cli_file_t cli_ftcode(const char *name)

 {

     unsigned int i;

@@ -184,7 +182,7 @@ void cli_ftfree(const struct cl_engine *engine)

     }

 }

-cli_file_t cli_partitiontype(const unsigned char *buf, size_t buflen, const struct cl_engine *engine)

+cli_file_t cli_compare_ftm_partition(const unsigned char *buf, size_t buflen, const struct cl_engine *engine)

 {

     struct cli_ftype *ptype = engine->ptypes;

@@ -202,7 +200,7 @@ cli_file_t cli_partitiontype(const unsigned char *buf, size_t buflen, const stru

     return CL_TYPE_PART_ANY;

 }

-cli_file_t cli_filetype(const unsigned char *buf, size_t buflen, const struct cl_engine *engine)

+cli_file_t cli_compare_ftm_file(const unsigned char *buf, size_t buflen, const struct cl_engine *engine)

 {

     struct cli_ftype *ftype = engine->ftypes;

@@ -273,7 +271,7 @@ const struct ooxml_ftcodes {

         }                                                                       \

     } while (0)

-cli_file_t cli_filetype2(fmap_t *map, const struct cl_engine *engine, cli_file_t basetype)

+cli_file_t cli_determine_fmap_type(fmap_t *map, const struct cl_engine *engine, cli_file_t basetype)

 {

     unsigned char buffer[MAGIC_BUFFER_SIZE];

     const unsigned char *buff;

@@ -284,7 +282,7 @@ cli_file_t cli_filetype2(fmap_t *map, const struct cl_engine *engine, cli_file_t

     struct cli_ac_data mdata;

     if (!engine) {

-        cli_errmsg("cli_filetype2: engine == NULL\n");

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

         return CL_TYPE_ERROR;

     }

@@ -302,7 +300,7 @@ cli_file_t cli_filetype2(fmap_t *map, const struct cl_engine *engine, cli_file_t

     if (buff) {

         sret = cli_memcpy(buffer, buff, bread);

         if (sret) {

-            cli_errmsg("cli_filetype2: fileread error!\n");

+            cli_errmsg("cli_determine_fmap_type: fileread error!\n");

             return CL_TYPE_ERROR;

         }

         sret = 0;

@@ -311,9 +309,9 @@ cli_file_t cli_filetype2(fmap_t *map, const struct cl_engine *engine, cli_file_t

     }

     if (basetype == CL_TYPE_PART_ANY) { /* typing a partition */

-        ret = cli_partitiontype(buff, bread, engine);

+        ret = cli_compare_ftm_partition(buff, bread, engine);

     } else { /* typing a file */

-        ret = cli_filetype(buff, bread, engine);

+        ret = cli_compare_ftm_file(buff, bread, engine);

         if (ret == CL_TYPE_BINARY_DATA) {

             switch (is_tar(buff, bread)) {

@@ -376,7 +374,7 @@ cli_file_t cli_filetype2(fmap_t *map, const struct cl_engine *engine, cli_file_t

                         zread = MIN(MAGIC_BUFFER_SIZE, map->len - zoff);

                         zbuff = fmap_need_off_once(map, zoff, zread);

                         if (zbuff == NULL) {

-                            cli_dbgmsg("cli_filetype2: error mapping data for OOXML check\n");

+                            cli_dbgmsg("cli_determine_fmap_type: error mapping data for OOXML check\n");

                             return CL_TYPE_ERROR;

                         }

                         zoff += zread;

@@ -405,7 +403,7 @@ cli_file_t cli_filetype2(fmap_t *map, const struct cl_engine *engine, cli_file_t

     if (ret >= CL_TYPE_TEXT_ASCII && ret <= CL_TYPE_BINARY_DATA) {

         /* HTML files may contain special characters and could be

-         * misidentified as BINARY_DATA by cli_filetype()

+         * misidentified as BINARY_DATA by cli_compare_ftm_file()

          */

         root = engine->root[0];

         if (!root)

@@ -463,7 +461,7 @@ cli_file_t cli_filetype2(fmap_t *map, const struct cl_engine *engine, cli_file_t

                         if (out_area.length > 0) {

                             sret = cli_ac_scanbuff(decodedbuff, out_area.length, NULL, NULL, NULL, engine->root[0], &mdata, 0, 0, NULL, AC_SCAN_FT, NULL); /* FIXME: can we use CL_TYPE_TEXT_ASCII instead of 0? */

                             if (sret == CL_TYPE_HTML) {

-                                cli_dbgmsg("cli_filetype2: detected HTML signature in Unicode file\n");

+                                cli_dbgmsg("cli_determine_fmap_type: detected HTML signature in Unicode file\n");

                                 /* htmlnorm is able to handle any unicode now, since it skips null chars */

                                 ret = CL_TYPE_HTML;

                             }

@@ -144,8 +144,9 @@ struct cli_matched_type {

 cli_file_t cli_ftcode(const char *name);

 const char *cli_ftname(cli_file_t code);

 void cli_ftfree(const struct cl_engine *engine);

-cli_file_t cli_filetype(const unsigned char *buf, size_t buflen, const struct cl_engine *engine);

-cli_file_t cli_filetype2(fmap_t *map, const struct cl_engine *engine, cli_file_t basetype);

+cli_file_t cli_compare_ftm_file(const unsigned char *buf, size_t buflen, const struct cl_engine *engine);

+cli_file_t cli_compare_ftm_partition(const unsigned char *buf, size_t buflen, const struct cl_engine *engine);

+cli_file_t cli_determine_fmap_type(fmap_t *map, const struct cl_engine *engine, cli_file_t basetype);

 int cli_addtypesigs(struct cl_engine *engine);

 #endif

@@ -151,7 +151,7 @@ scan_overlay:

     // Is there an overlay?

     if (offset < map->len) {

-        cl_error_t recRetVal = cli_map_scan(map, offset, map->len - offset, ctx, CL_TYPE_ANY, NULL);

+        cl_error_t recRetVal = cli_magic_scan_nested_fmap_type(map, offset, map->len - offset, ctx, CL_TYPE_ANY, NULL);

         retVal        = recRetVal != CL_SUCCESS ? recRetVal : retVal;

     }

@@ -298,7 +298,7 @@ static int gpt_scan_partitions(cli_ctx *ctx, struct gpt_header hdr, size_t secto

         max_prtns = ctx->engine->maxpartitions;

     }

-    /* use the partition tables to pass partitions to cli_map_scan */

+    /* use the partition tables to pass partitions to cli_magic_scan_nested_fmap_type */

     pos = hdr.tableStartLBA * sectorsize;

     for (i = 0; i < max_prtns; ++i) {

         /* read in partition entry */

@@ -341,10 +341,10 @@ static int gpt_scan_partitions(cli_ctx *ctx, struct gpt_header hdr, size_t secto

                        (long long unsigned)gpe.firstLBA, (long long unsigned)(gpe.firstLBA * sectorsize),

                        (long long unsigned)gpe.lastLBA, (long long unsigned)((gpe.lastLBA + 1) * sectorsize));

-            /* send the partition to cli_map_scan */

+            /* send the partition to cli_magic_scan_nested_fmap_type */

             part_off  = gpe.firstLBA * sectorsize;

             part_size = (gpe.lastLBA - gpe.firstLBA + 1) * sectorsize;

-            ret       = cli_map_scan(*ctx->fmap, part_off, part_size, ctx, CL_TYPE_PART_ANY, namestr);

+            ret       = cli_magic_scan_nested_fmap_type(*ctx->fmap, part_off, part_size, ctx, CL_TYPE_PART_ANY, namestr);

             if (NULL != namestr) {

                 free(namestr);

             }

@@ -434,7 +434,7 @@ static cl_error_t hfsplus_scanfile(cli_ctx *ctx, hfsPlusVolumeHeader *volHeader,

     }

     else {

         if (ret == CL_CLEAN) {

-            ret = cli_magic_scandesc(ofd, tmpname, ctx, orig_filename);

+            ret = cli_magic_scan_desc(ofd, tmpname, ctx, orig_filename);

         }

         if (!ctx->engine->keeptmp) {

@@ -985,7 +985,7 @@ static cl_error_t hfsplus_walk_catalog(cli_ctx *ctx, hfsPlusVolumeHeader *volHea

                         cli_errmsg("hfsplus_walk_catalog: failed to convert UTF-16BE to UTF-8\n");

                         name_utf8 = NULL;

                     }

-                    cli_errmsg("hfsplus_walk_catalog: Extracting file %s\n", name_utf8);

+                    cli_dbgmsg("hfsplus_walk_catalog: Extracting file %s\n", name_utf8);

                 }

             }

             /* Copy type (after key, which is after keylength field) */

@@ -1336,7 +1336,7 @@ static cl_error_t hfsplus_walk_catalog(cli_ctx *ctx, hfsPlusVolumeHeader *volHea

                             cli_dbgmsg("hfsplus_walk_catalog: Extracted to %s\n", tmpname);

                             /* if successful so far, scan the output */

-                            ret = cli_magic_scandesc(ofd, tmpname, ctx, name_utf8);

+                            ret = cli_magic_scan_desc(ofd, tmpname, ctx, name_utf8);

                             if (ret == CL_VIRUS) {

                                 has_alerts = 1;

@@ -175,7 +175,7 @@ static cl_error_t decompress_and_callback(cli_ctx *ctx, fmap_t *input, size_t at

         ret = cb(cbdata, ofd, tmpname, ctx);

     } else {

         /* default to scanning what we got */

-        ret = cli_magic_scandesc(ofd, tmpname, ctx, NULL);

+        ret = cli_magic_scan_desc(ofd, tmpname, ctx, NULL);

     }

     /* clean-up */

@@ -293,8 +293,8 @@ cl_error_t cli_scanhwpole2(cli_ctx *ctx)

     else

         cli_dbgmsg("HWPOLE2: Matched uncompressed prefix and size: %u == %u\n", usize, asize);

-    return cli_map_scandesc(map, 4, 0, ctx, CL_TYPE_ANY, NULL);

-    //return cli_map_scandesc(map, 4, 0, ctx, CL_TYPE_OLE2);

+    return cli_magic_scan_nested_fmap_type(map, 4, 0, ctx, CL_TYPE_ANY, NULL);

+    //return cli_magic_scan_nested_fmap_type(map, 4, 0, ctx, CL_TYPE_OLE2);

 }

 /*** HWP5 ***/

@@ -377,7 +377,7 @@ static cl_error_t hwp5_cb(void *cbdata, int fd, const char *filepath, cli_ctx *c

     if (fd < 0 || !ctx)

         return CL_ENULLARG;

-    return cli_magic_scandesc(fd, filepath, ctx, NULL);

+    return cli_magic_scan_desc(fd, filepath, ctx, NULL);

 }

 cl_error_t cli_scanhwp5_stream(cli_ctx *ctx, hwp5_header_t *hwp5, char *name, int fd, const char *filepath)

@@ -397,7 +397,7 @@ cl_error_t cli_scanhwp5_stream(cli_ctx *ctx, hwp5_header_t *hwp5, char *name, in

             if (hwp5->flags & HWP5_PASSWORD) {

                 cli_dbgmsg("HWP5.x: Password encrypted stream, scanning as-is\n");

-                return cli_magic_scandesc(fd, filepath, ctx, name);

+                return cli_magic_scan_desc(fd, filepath, ctx, name);

             }

             if (hwp5->flags & HWP5_COMPRESSED) {

@@ -440,7 +440,7 @@ cl_error_t cli_scanhwp5_stream(cli_ctx *ctx, hwp5_header_t *hwp5, char *name, in

     }

     /* normal streams */

-    return cli_magic_scandesc(fd, filepath, ctx, name);

+    return cli_magic_scan_desc(fd, filepath, ctx, name);

 }

 /*** HWP3 ***/

@@ -1645,7 +1645,7 @@ static inline cl_error_t parsehwp3_infoblk_1(cli_ctx *ctx, fmap_t *dmap, size_t

 #endif

             /* 32 bytes for extra data fields */

             if (infolen > 0)

-                ret = cli_map_scan(map, *offset + 32, infolen - 32, ctx, CL_TYPE_ANY, NULL);

+                ret = cli_magic_scan_nested_fmap_type(map, *offset + 32, infolen - 32, ctx, CL_TYPE_ANY, NULL);

             break;

         case 2: /* OLE2 Data */

             hwp3_debug("HWP3.x: Information Block[%llu]: TYPE: OLE2 Data\n", infoloc);

@@ -1654,7 +1654,7 @@ static inline cl_error_t parsehwp3_infoblk_1(cli_ctx *ctx, fmap_t *dmap, size_t

                 cli_jsonstr(entry, "Type", "OLE2 Data");

 #endif

             if (infolen > 0)

-                ret = cli_map_scan(map, *offset, infolen, ctx, CL_TYPE_ANY, NULL);

+                ret = cli_magic_scan_nested_fmap_type(map, *offset, infolen, ctx, CL_TYPE_ANY, NULL);

             break;

         case 3: /* Hypertext/Hyperlink Information */

             hwp3_debug("HWP3.x: Information Block[%llu]: TYPE: Hypertext/Hyperlink Information\n", infoloc);

@@ -1682,7 +1682,7 @@ static inline cl_error_t parsehwp3_infoblk_1(cli_ctx *ctx, fmap_t *dmap, size_t

                 hwp3_debug("HWP3.x: Information Block[%llu]: %d: NAME: %s\n", infoloc, i, field);

 #endif

                 /* scanning macros - TODO - check numbers */

-                ret = cli_map_scan(map, *offset + (617 * i) + 288, 325, ctx, CL_TYPE_ANY, NULL);

+                ret = cli_magic_scan_nested_fmap_type(map, *offset + (617 * i) + 288, 325, ctx, CL_TYPE_ANY, NULL);

             }

             break;

         case 4: /* Presentation Information */

@@ -1719,7 +1719,7 @@ static inline cl_error_t parsehwp3_infoblk_1(cli_ctx *ctx, fmap_t *dmap, size_t

 #endif

             /* 324 bytes for extra data fields */

             if (infolen > 0)

-                ret = cli_map_scan(map, *offset + 324, infolen - 324, ctx, CL_TYPE_ANY, NULL);

+                ret = cli_magic_scan_nested_fmap_type(map, *offset + 324, infolen - 324, ctx, CL_TYPE_ANY, NULL);

             break;

         case 0x100: /* Table Extension */

             hwp3_debug("HWP3.x: Information Block[%llu]: TYPE: Table Extension\n", infoloc);

@@ -1740,7 +1740,7 @@ static inline cl_error_t parsehwp3_infoblk_1(cli_ctx *ctx, fmap_t *dmap, size_t

         default:

             cli_warnmsg("HWP3.x: Information Block[%llu]: TYPE: UNKNOWN(%u)\n", infoloc, infoid);

             if (infolen > 0)

-                ret = cli_map_scan(map, *offset, infolen, ctx, CL_TYPE_ANY, NULL);

+                ret = cli_magic_scan_nested_fmap_type(map, *offset, infolen, ctx, CL_TYPE_ANY, NULL);

     }

     *offset += infolen;

@@ -1863,8 +1863,8 @@ static cl_error_t hwp3_cb(void *cbdata, int fd, const char *filepath, cli_ctx *c

         cl_error_t subret = ret;

         size_t dlen       = offset - start;

-        ret = cli_map_scandesc(map, start, dlen, ctx, CL_TYPE_ANY, NULL);

-        //ret = cli_map_scandesc(map, 0, 0, ctx, CL_TYPE_ANY);

+        ret = cli_magic_scan_nested_fmap_type(map, start, dlen, ctx, CL_TYPE_ANY, NULL);

+        //ret = cli_magic_scan_nested_fmap_type(map, 0, 0, ctx, CL_TYPE_ANY);

         if (ret == CL_SUCCESS)

             ret = subret;

@@ -1978,7 +1978,7 @@ static cl_error_t hwpml_scan_cb(void *cbdata, int fd, const char *filepath, cli_

     if (fd < 0 || !ctx)

         return CL_ENULLARG;

-    return cli_magic_scandesc(fd, filepath, ctx, NULL);

+    return cli_magic_scan_desc(fd, filepath, ctx, NULL);

 }

 static cl_error_t hwpml_binary_cb(int fd, const char *filepath, cli_ctx *ctx, int num_attribs, struct attrib_entry *attribs, void *cbdata)

@@ -2014,7 +2014,7 @@ static cl_error_t hwpml_binary_cb(int fd, const char *filepath, cli_ctx *ctx, in

     /* decode the binary data if needed - base64 */

     if (enc < 0) {

         cli_errmsg("HWPML: Unrecognized encoding method\n");

-        return cli_magic_scandesc(fd, filepath, ctx, NULL);

+        return cli_magic_scan_desc(fd, filepath, ctx, NULL);

     } else if (enc == 1) {

         STATBUF statbuf;

         fmap_t *input;

@@ -2046,7 +2046,7 @@ static cl_error_t hwpml_binary_cb(int fd, const char *filepath, cli_ctx *ctx, in

         funmap(input);

         if (!decoded) {

             cli_errmsg("HWPML: Failed to get base64 decode binary data\n");

-            return cli_magic_scandesc(fd, filepath, ctx, NULL);

+            return cli_magic_scan_desc(fd, filepath, ctx, NULL);

         }

         /* open file for writing and scanning */

@@ -303,7 +303,7 @@ int cli_scanishield_msi(cli_ctx *ctx, off_t off)

                 cli_dbgmsg("ishield-msi: call to lseek() failed\n");

                 ret = CL_ESEEK;

             }

-            ret = cli_magic_scandesc(ofd, tempfile, ctx, filename);

+            ret = cli_magic_scan_desc(ofd, tempfile, ctx, filename);

         }

         close(ofd);

@@ -494,7 +494,7 @@ static int is_dump_and_scan(cli_ctx *ctx, off_t off, size_t fsize)

             cli_dbgmsg("ishield: call to lseek() failed\n");

             ret = CL_ESEEK;

         }

-        ret = cli_magic_scandesc(ofd, fname, ctx, NULL);

+        ret = cli_magic_scan_desc(ofd, fname, ctx, NULL);

     }

     close(ofd);

     if (!ctx->engine->keeptmp)

@@ -794,7 +794,7 @@ static int is_extract_cab(cli_ctx *ctx, uint64_t off, uint64_t size, uint64_t cs

             cli_dbgmsg("is_extract_cab: extracted to %s\n", tempfile);

         if (lseek(ofd, 0, SEEK_SET) == -1)

             cli_dbgmsg("is_extract_cab: call to lseek() failed\n");

-        ret = cli_magic_scandesc(ofd, tempfile, ctx, NULL);

+        ret = cli_magic_scan_desc(ofd, tempfile, ctx, NULL);

     }

     close(ofd);

@@ -82,7 +82,7 @@ static int iso_scan_file(const iso9660_t *iso, unsigned int block, unsigned int

     }

     if (!len)

-        ret = cli_magic_scandesc(fd, tmpf, iso->ctx, iso->buf);

+        ret = cli_magic_scan_desc(fd, tmpf, iso->ctx, iso->buf);

     close(fd);

     if (!iso->ctx->engine->keeptmp) {

@@ -173,8 +173,8 @@ CLAMAV_PRIVATE {

     cli_bm_scanbuff;

     cli_bm_free;

     cli_initroots;

-    cli_scanbuff;

-    cli_fmap_scandesc;

+    cli_scan_buff;

+    cli_scan_fmap;

     cli_check_auth_header;

     cli_genhash_pe;

     html_screnc_decode;

@@ -408,7 +408,7 @@ int cli_scanmscab(cli_ctx *ctx, off_t sfx_offset)

             /* Failed to extract. Try to scan what is there */

             cli_dbgmsg("%s() failed to extract %d\n", __func__, ret);

-        ret = cli_scanfile(tmp_fname, ctx, cab_f->filename);

+        ret = cli_magic_scan_file(tmp_fname, ctx, cab_f->filename);

         if (CL_EOPEN == ret) {

             ret = CL_CLEAN;

         } else if (CL_VIRUS == ret) {

@@ -511,7 +511,7 @@ int cli_scanmschm(cli_ctx *ctx)

             /* Failed to extract. Try to scan what is there */

             cli_dbgmsg("%s() failed to extract %d\n", __func__, ret);

-        ret = cli_scanfile(tmp_fname, ctx, mschm_f->filename);

+        ret = cli_magic_scan_file(tmp_fname, ctx, mschm_f->filename);

         if (CL_EOPEN == ret) {

             ret = CL_CLEAN;

         } else if (CL_VIRUS == ret) {

@@ -562,7 +562,7 @@ int cli_scanmacho_unibin(cli_ctx *ctx)

         cli_dbgmsg("UNIBIN: Binary %u of %u\n", i + 1, fat_header.nfats);

         cli_dbgmsg("UNIBIN: File offset: %u\n", fat_arch.offset);

         cli_dbgmsg("UNIBIN: File size: %u\n", fat_arch.size);

-        ret = cli_map_scan(map, fat_arch.offset, fat_arch.size, ctx, CL_TYPE_ANY, NULL);

+        ret = cli_magic_scan_nested_fmap_type(map, fat_arch.offset, fat_arch.size, ctx, CL_TYPE_ANY, NULL);

         if (ret == CL_VIRUS)

             break;

     }

@@ -602,7 +602,7 @@ int cli_unpackmacho(cli_ctx *ctx)

                     cli_dbgmsg("cli_scanmacho: Unpacked and rebuilt executable\n");

                 lseek(ndesc, 0, SEEK_SET);

                 cli_dbgmsg("***** Scanning rebuilt Mach-O file *****\n");

-                if (cli_magic_scandesc(ndesc, tempfile, ctx, NULL) == CL_VIRUS) {

+                if (cli_magic_scan_desc(ndesc, tempfile, ctx, NULL) == CL_VIRUS) {

                     close(ndesc);

                     CLI_TMPUNLK();

                     free(tempfile);

@@ -258,7 +258,7 @@ static inline cl_error_t matcher_run(const struct cli_matcher *root,

     return ret;

 }

-cl_error_t cli_scanbuff(const unsigned char *buffer, uint32_t length, uint32_t offset, cli_ctx *ctx, cli_file_t ftype, struct cli_ac_data **acdata)

+cl_error_t cli_scan_buff(const unsigned char *buffer, uint32_t length, uint32_t offset, cli_ctx *ctx, cli_file_t ftype, struct cli_ac_data **acdata)

 {

     cl_error_t ret = CL_CLEAN;

     unsigned int i = 0, j = 0, viruses_found = 0;

@@ -268,7 +268,7 @@ cl_error_t cli_scanbuff(const unsigned char *buffer, uint32_t length, uint32_t o

     const struct cl_engine *engine = ctx->engine;

     if (!engine) {

-        cli_errmsg("cli_scanbuff: engine == NULL\n");

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

         return CL_ENULLARG;

     }

@@ -759,7 +759,7 @@ int32_t cli_bcapi_matchicon(struct cli_bc_ctx *ctx, const uint8_t *grp1, int32_t

     return (int32_t)ret;

 }

-cl_error_t cli_scandesc(int desc, cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, struct cli_matched_type **ftoffset, unsigned int acmode, struct cli_ac_result **acres, const char *name)

+cl_error_t cli_scan_desc(int desc, cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, struct cli_matched_type **ftoffset, unsigned int acmode, struct cli_ac_result **acres, const char *name)

 {

     cl_error_t ret = CL_EMEM;

     int empty;

@@ -767,7 +767,7 @@ cl_error_t cli_scandesc(int desc, cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly

     ctx->fmap++; /* Perform scan with child fmap */

     if (NULL != (*ctx->fmap = fmap_check_empty(desc, 0, 0, &empty, name))) {

-        ret                  = cli_fmap_scandesc(ctx, ftype, ftonly, ftoffset, acmode, acres, NULL);

+        ret                  = cli_scan_fmap(ctx, ftype, ftonly, ftoffset, acmode, acres, NULL);

         map->dont_cache_flag = (*ctx->fmap)->dont_cache_flag;

         funmap(*ctx->fmap);

     }

@@ -829,7 +829,7 @@ static cl_error_t lsig_eval(cli_ctx *ctx, struct cli_matcher *root, struct cli_a

             if (0 != memcmp(ctx->handlertype_hash, hash, 16)) {

                 ctx->recursion++;

                 memcpy(ctx->handlertype_hash, hash, 16);

-                if (cli_magic_scandesc_type(ctx, ac_lsig->tdb.handlertype[0]) == CL_VIRUS) {

+                if (cli_magic_scan(ctx, ac_lsig->tdb.handlertype[0]) == CL_VIRUS) {

                     ctx->recursion--;

                     return CL_VIRUS;

                 }

@@ -920,7 +920,7 @@ cl_error_t cli_exp_eval(cli_ctx *ctx, struct cli_matcher *root, struct cli_ac_da

     return CL_CLEAN;

 }

-cl_error_t cli_fmap_scandesc(cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, struct cli_matched_type **ftoffset, unsigned int acmode, struct cli_ac_result **acres, unsigned char *refhash)

+cl_error_t cli_scan_fmap(cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, struct cli_matched_type **ftoffset, unsigned int acmode, struct cli_ac_result **acres, unsigned char *refhash)

 {

     const unsigned char *buff;

     cl_error_t ret = CL_CLEAN, type = CL_CLEAN;

@@ -940,7 +940,7 @@ cl_error_t cli_fmap_scandesc(cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, str

     void *md5ctx, *sha1ctx, *sha256ctx;

     if (!ctx->engine) {

-        cli_errmsg("cli_scandesc: engine == NULL\n");

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

         return CL_ENULLARG;

     }

@@ -996,7 +996,7 @@ cl_error_t cli_fmap_scandesc(cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, str

     cli_targetinfo(&info, i, map);

     if (-1 == info.status) {

-        cli_dbgmsg("cli_fmap_scandesc: Failed to successfully parse the executable header. "

+        cli_dbgmsg("cli_scan_fmap: Failed to successfully parse the executable header. "

                    "Scan features will be disabled, such as "

                    "NDB/LDB subsigs using EOF-n/EP+n/EP-n/Sx+n/SEx/SL+n, "

                    "fuzzy icon matching, "

@@ -1005,7 +1005,7 @@ cl_error_t cli_fmap_scandesc(cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, str

     }

     /* If it's a PE, check the Authenticode header.  This would be more

-     * appropriate in cli_scanpe, but cli_scanraw->cli_fmap_scandesc gets

+     * appropriate in cli_scanpe, but scanraw->cli_scan_fmap gets

      * called first for PEs, and we want to determine the whitelist/blacklist

      * status early on so we can skip things like embedded PE extraction

      * (which is broken for signed binaries within signed binaries).

@@ -237,7 +237,7 @@ static const struct cli_mtarget cli_mtargets[CLI_MTARGETS] =  {

  * @param acdata    [in/out] A list of pattern maching data structs to contain match results, one for each pattern matching trie.

  * @return cl_error_t

  */

-cl_error_t cli_scanbuff(const unsigned char *buffer, uint32_t length, uint32_t offset, cli_ctx *ctx, cli_file_t ftype, struct cli_ac_data **acdata);

+cl_error_t cli_scan_buff(const unsigned char *buffer, uint32_t length, uint32_t offset, cli_ctx *ctx, cli_file_t ftype, struct cli_ac_data **acdata);

 /**

  * @brief Non-magic scan matching using a file descriptor for input.

@@ -245,7 +245,7 @@ cl_error_t cli_scanbuff(const unsigned char *buffer, uint32_t length, uint32_t o

  * This function does not perform file type magic identification and does not use

  * the file format scanners.

  *

- * This function uses the newer cli_fmap_scandesc() scanning API.

+ * This function uses the newer cli_scan_fmap() scanning API.

  *

  * @param desc      File descriptor to be used for input

  * @param ctx       The scanning context.

@@ -257,7 +257,7 @@ cl_error_t cli_scanbuff(const unsigned char *buffer, uint32_t length, uint32_t o

  * @param name      (optional) Original name of the file (to set fmap name metadata)

  * @return cl_error_t

  */

-cl_error_t cli_scandesc(int desc, cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, struct cli_matched_type **ftoffset, unsigned int acmode, struct cli_ac_result **acres, const char *name);

+cl_error_t cli_scan_desc(int desc, cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, struct cli_matched_type **ftoffset, unsigned int acmode, struct cli_ac_result **acres, const char *name);

 /**

  * @brief Non-magic scan matching of the current fmap in the scan context.  Newer API.

@@ -273,11 +273,11 @@ cl_error_t cli_scandesc(int desc, cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly

  * @param refhash   MD5 hash of the current file, used to save time creating hashes and to limit scan recursion for the HandlerType logical signature FTM feature.

  * @return cl_error_t

  */

-cl_error_t cli_fmap_scandesc(cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, struct cli_matched_type **ftoffset, unsigned int acmode, struct cli_ac_result **acres, unsigned char *refhash);

+cl_error_t cli_scan_fmap(cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, struct cli_matched_type **ftoffset, unsigned int acmode, struct cli_ac_result **acres, unsigned char *refhash);

 /**

  * @brief Evaluate logical signatures and yara rules given the AC matching results

- * from cli_scanbuff() / matcher_run().

+ * from cli_scan_buff() / matcher_run().

  *

  * @param ctx           The scanning context.

  * @param root          The AC trie root to match with.

@@ -410,7 +410,7 @@ cli_parse_mbox(const char *dir, cli_ctx *ctx)

 	 * Is it a UNIX style mbox with more than one

 	 * mail message, or just a single mail message?

 	 *

-	 * TODO: It would be better if we called cli_scandir here rather than

+	 * TODO: It would be better if we called cli_magic_scan_dir here rather than

 	 * in cli_scanmail. Then we could improve the way mailboxes with more

 	 * than one message is handled, e.g. giving a better indication of

 	 * which message within the mailbox is infected

@@ -484,7 +484,7 @@ cli_parse_mbox(const char *dir, cli_ctx *ctx)

 				 * Starting a new message, throw away all the

 				 * information about the old one. It would

 				 * be best to be able to scan this message

-				 * now, but cli_scanfile needs arguments

+				 * now, but cli_magic_scan_file needs arguments

 				 * that haven't been passed here so it can't be

 				 * called

 				 */

@@ -562,7 +562,7 @@ cli_parse_mbox(const char *dir, cli_ctx *ctx)

                     break;

                 case FAIL:

                     /*

-					 * beware: cli_magic_scandesc(),

+					 * beware: cli_magic_scan_desc(),

 					 * changes this into CL_CLEAN, so only

 					 * use it to inform the higher levels

 					 * that we couldn't decode it because

@@ -4097,7 +4097,7 @@ isBounceStart(mbox_ctx *mctx, const char *line)

             return FALSE;

         return TRUE;

     }

-    return (bool)(cli_filetype((const unsigned char *)line, len, mctx->ctx->engine) == CL_TYPE_MAIL);

+    return (bool)(cli_compare_ftm_file((const unsigned char *)line, len, mctx->ctx->engine) == CL_TYPE_MAIL);

 }

 /*

@@ -184,7 +184,7 @@ int cli_scanmbr(cli_ctx *ctx, size_t sectorsize)

     }

     /* MBR is valid, examine bootstrap code */

-    ret = cli_map_scan(*ctx->fmap, 0, sectorsize, ctx, CL_TYPE_ANY, NULL);

+    ret = cli_magic_scan_nested_fmap_type(*ctx->fmap, 0, sectorsize, ctx, CL_TYPE_ANY, NULL);

     if (ret != CL_CLEAN) {

         if (SCAN_ALLMATCHES && (ret == CL_VIRUS))

             detection = CL_VIRUS;

@@ -239,8 +239,8 @@ int cli_scanmbr(cli_ctx *ctx, size_t sectorsize)

             partoff  = mbr.entries[i].firstLBA * sectorsize;

             partsize = mbr.entries[i].numLBA * sectorsize;

-            mbr_parsemsg("cli_map_scan: [%u, +%u)\n", partoff, partsize);

-            ret = cli_map_scan(*ctx->fmap, partoff, partsize, ctx, CL_TYPE_PART_ANY, NULL);

+            mbr_parsemsg("cli_magic_scan_nested_fmap_type: [%u, +%u)\n", partoff, partsize);

+            ret = cli_magic_scan_nested_fmap_type(*ctx->fmap, partoff, partsize, ctx, CL_TYPE_PART_ANY, NULL);

             if (ret != CL_CLEAN) {

                 if (SCAN_ALLMATCHES && (ret == CL_VIRUS))

                     detection = CL_VIRUS;

@@ -381,7 +381,7 @@ static int mbr_scanextprtn(cli_ctx *ctx, unsigned *prtncount, off_t extlba, size

                         return CL_EFORMAT;

                     }

-                    ret = cli_map_scan(*ctx->fmap, partoff, partsize, ctx, CL_TYPE_PART_ANY, NULL);

+                    ret = cli_magic_scan_nested_fmap_type(*ctx->fmap, partoff, partsize, ctx, CL_TYPE_PART_ANY, NULL);

                     if (ret != CL_CLEAN) {

                         if (SCAN_ALLMATCHES && (ret == CL_VIRUS))

                             detection = CL_VIRUS;

@@ -1133,7 +1133,7 @@ messageIsEncoding(message *m)

         m->encoding = m->body_last;

     else if ((m->bounce == NULL) && m->ctx &&

              (strncasecmp(line, "Received: ", 10) == 0) &&

-             (cli_filetype((const unsigned char *)line, strlen(line), m->ctx->engine) == CL_TYPE_MAIL))

+             (cli_compare_ftm_file((const unsigned char *)line, strlen(line), m->ctx->engine) == CL_TYPE_MAIL))

         m->bounce = m->body_last;

     /* Not needed with fast track visa technology */

     /*else if((m->uuencode == NULL) && isuuencodebegin(line))

@@ -1732,7 +1732,7 @@ bounceBegin(message *m)

 	const text *t_line;

 	for(t_line = messageGetBody(m); t_line; t_line = t_line->t_next)

-		if(cli_filetype(t_line->t_text, strlen(t_line->t_text)) == CL_TYPE_MAIL)

+		if(cli_compare_ftm_file(t_line->t_text, strlen(t_line->t_text)) == CL_TYPE_MAIL)

 			return t_line;

 	return NULL;

@@ -462,7 +462,7 @@ static int msxml_parse_element(struct msxml_ctx *mxctx, xmlTextReaderPtr reader,

                             cli_dbgmsg("msxml_parse_element: extracted binary data to %s\n", tempfile);

-                            ret = cli_magic_scandesc(of, tempfile, ctx, NULL);

+                            ret = cli_magic_scan_desc(of, tempfile, ctx, NULL);

                             close(of);

                             if (!(ctx->engine->keeptmp))

                                 cli_unlink(tempfile);

@@ -546,9 +546,9 @@ int cli_scannulsft(cli_ctx *ctx, off_t offset)

                 return CL_ESEEK;

             }

             if (nsist.fno == 1)

-                ret = cli_scandesc(nsist.ofd, ctx, 0, 0, NULL, AC_SCAN_VIR, NULL, NULL); /// TODO: Extract file names

+                ret = cli_scan_desc(nsist.ofd, ctx, 0, 0, NULL, AC_SCAN_VIR, NULL, NULL); /// TODO: Extract file names

             else

-                ret = cli_magic_scandesc(nsist.ofd, nsist.ofn, ctx, NULL); /// TODO: Extract file names

+                ret = cli_magic_scan_desc(nsist.ofd, nsist.ofn, ctx, NULL); /// TODO: Extract file names

             close(nsist.ofd);

             if (!ctx->engine->keeptmp)

                 if (cli_unlink(nsist.ofn)) ret = CL_EUNLINK;

@@ -1425,7 +1425,7 @@ static cl_error_t scan_mso_stream(int fd, cli_ctx *ctx)

     }

     /* scanning inflated stream */

-    ret = cli_magic_scandesc(ofd, tmpname, ctx, NULL);

+    ret = cli_magic_scan_desc(ofd, tmpname, ctx, NULL);

     /* clean-up */

 mso_end:

@@ -1627,7 +1627,7 @@ handler_otf(ole2_header_t *hdr, property_t *prop, const char *dir, cli_ctx *ctx)

         ret = scan_mso_stream(ofd, ctx);

     } else {

         /* Normal File Scan */

-        ret = cli_magic_scandesc(ofd, tempfile, ctx, NULL);

+        ret = cli_magic_scan_desc(ofd, tempfile, ctx, NULL);

     }

     if (name)

         free(name);

@@ -1412,7 +1412,7 @@ static int pdf_scan_contents(int fd, struct pdf_struct *pdf)

     cli_writen(fout, s.out, s.out_pos);

     lseek(fout, 0, SEEK_SET);

-    rc = cli_magic_scandesc(fout, fullname, pdf->ctx, NULL);

+    rc = cli_magic_scan_desc(fout, fullname, pdf->ctx, NULL);

     close(fout);

     if (!pdf->ctx->engine->keeptmp)

@@ -1801,7 +1801,7 @@ done:

         /* TODO: invoke bytecode on this pdf obj with metainformation associated */

         lseek(fout, 0, SEEK_SET);

-        rc2 = cli_magic_scandesc(fout, fullname, pdf->ctx, NULL);

+        rc2 = cli_magic_scan_desc(fout, fullname, pdf->ctx, NULL);

         if (rc2 == CL_VIRUS || rc == CL_SUCCESS)

             rc = rc2;

@@ -126,7 +126,7 @@

     }

 #define CLI_UNPTEMP(NAME, FREEME)                                                       \

-    if (!(tempfile = cli_gentemp(ctx->sub_tmpdir))) {                               \

+    if (!(tempfile = cli_gentemp(ctx->sub_tmpdir))) {                                   \