@@ -1,6 +1,28 @@

+<<<<<<< HEAD

 Mon Oct 18 15:52:47 CEST 2010 (tk)

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

  * libclamav/matcher.c: fix stack smash with HandlerType (bb#2298)

+=======

+Mon Oct 18 13:23:42 CEST 2010 (acab)

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

+ * libclamav/scanners.c: mark embpes as unreliable (bb#2307)

+

+Mon Oct 18 14:16:11 EEST 2010 (edwin)

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

+ * clamconf/clamconf.c, libclamav/others.c: warn about zlib version mismatches (bb #2072)

+

+Mon Oct 18 13:55:17 EEST 2010 (edwin)

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

+ * libclamav/pdf.c: bb #2295

+

+Mon Oct 18 13:46:59 EEST 2010 (edwin)

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

+ * libclamav/builtin_bytecodes.h: disable JIT on CPUs without CMOV (bb #2327).

+

+Mon Oct 18 12:52:25 EEST 2010 (edwin)

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

+ * libclamav/pdf.c: keep parsing after %%EOF (bb #2264).

+>>>>>>> 110731e7842dfbfbb73a89c5f773a8e09a76cbb7

 Mon Oct 18 11:30:01 CEST 2010 (tk)

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

@@ -237,6 +237,8 @@ static void print_platform(struct cli_environment *env)

     }

 #endif

+    if (strcmp(ZLIB_VERSION, zlibVersion()))

+	printf("WARNING: zlib version mismatch: %s (%s)\n", ZLIB_VERSION, zlibVersion());

 #ifdef ZLIB_VERNUM

     printf("zlib version: %s (%s), compile flags: %02lx\n",

 	   ZLIB_VERSION, zlibVersion(), zlibCompileFlags());

@@ -29,53 +29,64 @@

  * fallback.

  * Usually bytecode.cvd will contain this bytecode */

-static const char* builtin_bc_startup = "ClamBCafheaie`fld|afefdfggifnf```aa```|biacflfafmfbfcfmb`cnbacacmbacdcicmbgfhcachcgcbchccf``bkbaap`clamcoincidencejb:1378\n"

+static const char* builtin_bc_startup = "ClamBCafhmknalkld|afefdfggifnf```aa```|biacflfafmfbfcfmb`cnbacacmbacgcgcmbgfbffcbficbfbfac``bgcaap`clamcoincidencejb:4096\n"

 "\n"

-"Teddaaahdabahdacahdadahdaeahdafahdagahebjfebidebifebhfebgfebffebedebefebdfebcfebadcbgab`bb`bb`bb`bb`bb`bb`bbbfbbfbbfbbfbbfbbfbbfahahahahahahahahahebgeebbfaaaaaaaab`baabb`bb`baacb`bbadb`baacb`bbheb`baacb`bb`bb`baadb`bbadb`bb`baadb`bbadbadb`bdbadahdbkaahdbbcahdbibahdb`eahdbddahdbodahdbdaahdbnbah\n"

-"Ebjdaibcdbke|bcaefnfgfifnfefoedfcfofnfffoelfeffgeflf``bbdbke|bkaefnfgfifnfefoeffegnfcfdgifofnfaflfifdgigoelfeffgeflf``agble|baadfefbfeggfoe`gbgifnfdgoeegifnfdg``bcable|afdgefcgdgbc``afbme|b`adfefbfeggfoe`gbgifnfdgoecgdgbg``bhdbne|b`agfefdgoeefnffgifbgofnfmfefnfdg``aaboe|afdgefcgdgac``bidb`f|bdadfifcgafbflfefoebfigdgefcfofdfefoeifff``bjdb`f|aodfifcgafbflfefoejfifdgoeifff``\n"

-"G`bha`@`b`aAa`bjfBifBkeBccBdcBmeBhcBfcB`bBdfBefBdgBefBcfBdgBefBdfBlbB`bBjdBidBdeB`bBnfBefBefBdfBcgB`bB`gBefBnfBdgBifBegBmfB`bBofBbgB`bBbfBefBdgBdgBefBbg@`bidBifBccBhcBfc@`bidBifBdcBhcBfc@`bifBbeBgeBheB`bBmfBafB`gB`gBifBnfBgfB`bBdfBefBnfBifBefBdfBnb@`bhfBneBceBedBldBifBnfBegBhgB`bBifBcgB`bB`gBbgBefBfgBefBnfBdgBifBnfBgfB`bBgbBefBhgBefBcfBmfBefBmfBgbB`bBafBcfBcfBefBcgBcgBnbAjBbeBegBnfB`bB`bBgbBcgBefBdgBcgBefBbfBofBofBlfB`bBmbB`eB`bBcfBlfBafBmfBdfBoeBegBcgBefBoeBjfBifBdgB`bBofBnfBgbBnb@`bgfBneB`eBafBheB`bBifBcgB`bB`gBbgBefBfgBefBnfBdgBifBnfBgfB`bBgbBmfB`gBbgBofBdgBefBcfBdgBgbB`bBafBcfBcfBefBcgBcgBnbAjBbeBegBnfB`bBgbB`gBafBhgBcfBdgBlfB`bBmbBcfBmfB`bBlcBefBhgBefBcfBegBdgBafBbfBlfBefBncBgb@`bffBneBbeBgeBheB`bBmfBafB`gB`gBifBnfBgfB`bBdfBefBnfBifBefBdfB`bBffBofBbgB`bBegBnfBkfBnfBofBggBnfB`bBbgBefBafBcgBofBnfBnbB`eBlfBefBafBcgBefB`bBbgBefB`gBofBbgBdgB`bBdgBofB`bBhfBdgBdgB`gBjcBobBobBbfBegBgfBcgBnbBcfBlfBafBmfBafBfgBnbBnfBefBdgAj@`bed@`befBcgBdgBafBbgBdgBegB`gBjcB`bBbfBigBdgBefBcfBofBdfBefB`bBefBhgBefBcfBegBdgBifBofBnfB`bBifBnfB`bBafBegBdgBofB`bBmfBofBdfBef@`bdfBcgBdgBafBbgBdgBegB`gBjcB`bBbfBigBdgBefBcfBofBdfBefB`bBefBhgBefBcfBegBdgBifBofBnfB`bBggBifBdgBhfB`bBifBnfBdgBefBbgB`gBbgBefBdgBefBbgB`bBofBnfBlfBig@`bcfBcgBdgBafBbgBdgBegB`gBjcB`bBbfBigBdgBefBcfBofBdfBefB`bBdfBifBcgBafBbfBlfBefBdf@`bad@Ab`bad@Ac`bad@Ad`bad@Ae`bad@Af`bad@Ag`bad@Ah`bad@Ai`bad@Aj`bad@Ak`bad@Al`\n"

-"A`b`bLbahb`bab`babgeab`b`bad`ah`aa`bad`ah`aa`bie`bad`b`b`aa`b`b`aa`b`b`b`b`bad`ah`b`b`b`b`aa`b`b`bad`ah`aa`ah`b`b`b`b`aa`b`b`b`b`aa`b`b`b`b`bad`ah`aa`bad`ah`aa`b`b`aa`b`b`b`b`aa`aa`aa`aa`aa`b`b`b`b`b`b`ah`aa`bcd`b`b`aa`bcd`b`b`bcd`b`b`aa`b`b`aa`b`b`b`b`aa`bad`ah`b`b`aa`b`b`aa`bad`ah`b`b`b`b`bad`ah`b`b`b`b`bad`ah`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`bad`ah`b`b`b`b`bcd`b`b`b`b`b`b`bad`ah`b`b`b`b`bcd`b`b`b`b`bcd`b`b`aa`b`b`bcd`b`b`aa`b`b`bcd`b`b`aa`b`b`b`b`aa`b`b`b`b`aa`b`b`b`b`Fb`kbib\n"

-"Bb`bacabbbhdabClnadbadaddbbheabBdadahaegbadaaafeaahae@aTaaafb`aaa\n"

-"BbadagdbbheabB`adahahgbagaaaieaahahAaaTaaaiabae\n"

-"BbieajdbbheabAidbadakdbbieaj@db`balkbakAn`Addaaameab`bal@db`b`bbAadaaTaaamadac\n"

-"Bb`bankbakAo`Addaaaoeab`ban@db`baa`aaob`b`bbaaaaTbaad\n"

-"Bb`bb`abbaab`ab`bbaaabcbjdAm`@db`aTbaae\n"

-"BbadbbadbbheabBeadahbcagbbbab`bbda`abcab`bbeak`bdaAadaabfaeab`bbea@dTaabfaafal\n"

-"Bb`bbgaabcbjdB`a`@dAadbadbhadbbheabBaadahbiagbbhaaabjaeaahbiaAjaTaabjaagb`a\n"

-"Bahbkagbbbab`bbla`abkab`bbmak`blaAbdaabnaeab`bbma@dTaabnaaiah\n"

-"Bb`bboaabcbjdBaa`@dAadTbab`a\n"

-"Bb`bb`bk`blaAhdaababeab`bb`b@dTaababakaj\n"

-"Bb`bbbbabcbjdBba`@dAadTbab`a\n"

-"Bb`bbcbabcbjdBca`@dAadTbab`a\n"

-"BbadbdbdbbheabBaadahbebgbbdbaabfbeaahbebAjaTaabfbanam\n"

-"BbadbgbdbbheabBbadahbhbgbbgbaabibeaahbhbAfaTaabibanb`a\n"

-"Bb`bbjbk`bdaB`adaabkbeab`bbjb@dTaabkbb`aao\n"

-"Bb`bblbabcbjdBba`@dAadTbab`a\n"

-"Bb`bbmbabcbidBda`@d@daabnbnab`bbmbAadTaabnbbdabaa\n"

-"Baabobnab`bbmbAbdTaabobbcabba\n"

-"Baab`ceab`bbmbAbdTaab`cbgabha\n"

-"Baabaceab`bbmbAadTaabacbfabha\n"

-"Baabbceab`bbmb@dTaabbcbeabha\n"

-"Bb`bbccabbafBea`@dTbabha\n"

-"Bb`bbdcabbafBfa`@dTbabha\n"

-"Bb`bbecabbafBga`@dTbabha\n"

-"Bahbfcgbadaabgceaahbfc@aTaabgcbjabia\n"

-"BbcdbhcdbbheabAddb`bbicgbbhcaabjceab`bbic@db`b`bbEamjnmd`Taabjcbhbbja\n"

-"BbcdbkcdbbheabAfdb`bblcgbbkcbcdbmcdbbheabAedb`bbncgbbmcaabociab`bblcbncb`b`bbEbmjnmd`Taabocbhbbka\n"

-"Bb`bb`dab`bbdaabadeab`bbncb`db`b`bbEcmjnmd`Taabadblabhb\n"

-"Bb`bbbdgbbkcb`bbcdab`bcdaabddeab`bbbdbcdb`b`bbEdmjnmd`Taabddbmabhb\n"

-"BbadbeddbbheabAndahbfdgbbedb`bbgd`abfdaabhdlbb`bbid`abhdaabjdeab`bbgdbidb`b`bbEemjnmd`Taabjdbnabhb\n"

-"BbadbkddbbheabBaadahbldgbbkdb`bbmd`abldb`bbndh`bmdBhadbadboddbbheabB`adahb`egbbodb`bbae`ab`eb`bbbeh`baeBdadbadbcedbbheabBcadahbdegbbceb`bbee`abdeb`bbfeh`beeB`adb`bbgegbbmcb`bbheh`bgeAhdb`bbiegbbkcb`bbjel`bbebndb`bbkel`bjebheb`bblel`bkebieb`bbmel`blebfeb`bbneh`bgdBladbadboedbbheabAodahb`fgbboeb`bbaf`ab`fb`bbbfh`bafBhadbcdbcfdbbheabAddb`bbdfgbbcfb`bbefl`bdfbneb`bbffl`befbbfbadbgfdbbheabBeadahbhfgbbgfb`bbif`abhfb`bbjfh`bifBhadbcdbkfdbbheabAcdb`bblfgbbkfb`bbmfl`bjfblfbcdbnfdbbheab@db`bbofgbbnfaab`geab`bbmebofTaab`gb`bboa\n"

-"Bb`bbagabaagbmeTcab`bEfmjnmd\n"

-"BbcdbbgdbbheabAadb`bbcggbbbgaabdgeab`bbffbcgTaabdgbbbbab\n"

-"Bb`bbegabaagbffTcab`bEgmjnmd\n"

-"BbcdbfgdbbheabAbdb`bbgggbbfgaabhgeab`bbmfbggTaabhgbdbbcb\n"

-"Bb`bbigabaagbmfTcab`bEhmjnmd\n"

-"Bb`bbjgabbaaHonnkm``odHm``oonnkdaabkgeab`bbjgHhgfedcbadTaabkgbfbbeb\n"

-"Bb`bblgabaagbjgTcab`bEimjnmd\n"

-"Bb`bbmgababcaDm``odaabngeab`bbmgDo``mdb`b`bbHnejkjgjmd`Taabngbhbbgb\n"

-"Bb`bbogabaagbmgTcab`bF`amjnmd\n"

-"Bb`bb`hbb`b`hTcab`bb`hE\n"

+"Teddaaahdabahdacahdadahdaeahdafahdagahebfgebidebegebdgebgdebkdebcgebbgebageb`gebofebnfebmfebedeblfebkfebjfebadcbgab`bb`bb`bb`bb`bb`bb`bbifbifbifbifbifbifbifahahahahahahahahahebneebifaaaaaaaab`baabb`bb`baacb`bbadb`baacb`bboeb`baacb`bb`bb`baadb`bbadb`bb`baadb`bbadbadb`bdbadahdbkaahdbbcahdbibahdb`eahdbddahdbodahdbdaahdaiahdakahdamahdahahdbgcahdbnbah\n"

+"Ebjdaibcdbbf|bcaefnfgfifnfefoedfcfofnfffoelfeffgeflf``bbdbbf|bkaefnfgfifnfefoeffegnfcfdgifofnfaflfifdgigoelfeffgeflf``agbcf|baadfefbfeggfoe`gbgifnfdgoeegifnfdg``bcabcf|afdgefcgdgbc``afbdf|b`adfefbfeggfoe`gbgifnfdgoecgdgbg``bhdbef|b`agfefdgoeefnffgifbgofnfmfefnfdg``aabff|afdgefcgdgac``bidbgf|bdadfifcgafbflfefoebfigdgefcfofdfefoeifff``bjdbgf|aodfifcgafbflfefoejfifdgoeifff``\n"

+"G`b`c`@`b`aAa`bfgBifBkeBccBdcBmeBhcBfcB`bBdfBefBdgBefBcfBdgBefBdfBlbB`bBjdBidBdeB`bBnfBefBefBdfBcgB`bB`gBefBnfBdgBifBegBmfB`bBofBbgB`bBbfBefBdgBdgBefBbg@`bidBifBccBhcBfc@`bidBifBdcBhcBfc@`begBcdB`eBeeB`bBdfBofBefBcgBnfBgbBdgB`bBcgBegB`gB`gBofBbgBdgB`bBcdBmdBodBfeBlbB`bBggBofBegBlfBdfB`bBnfBefBefBdfB`bBldBldBfeBmdB`bBbcBnbBhcB`bBdgBofB`bBggBofBbgBkfBab@`bidBifBecBhcBfc@`bdgB`gBefBnfBdgBifBegBmf@`bidBifBfcBhcBfc@`bgdBkfBfc@`bidBkfBfcBmbBbc@`bidBkfBfcBmbBcc@`bkdBafBdgBhfBlfBofBnf@`bcgBafBdgBhfBlfBofBnfBmbBdgBbfBifBbgBdf@`bbgBggBifBnfBcfBhfBifB`gBmbBcfBfc@`bagBggBifBnfBcfBhfBifB`gBbc@`bgdBcfBcc@`b`gBbeBgeBheB`bBmfBafB`gB`gBifBnfBgfB`bBdfBefBnfBifBefBdfBnb@`bofBneBceBedBldBifBnfBegBhgB`bBifBcgB`bB`gBbgBefBfgBefBnfBdgBifBnfBgfB`bBgbBefBhgBefBcfBmfBefBmfBgbB`bBafBcfBcfBefBcgBcgBnbAjBbeBegBnfB`bB`bBgbBcgBefBdgBcgBefBbfBofBofBlfB`bBmbB`eB`bBcfBlfBafBmfBdfBoeBegBcgBefBoeBjfBifBdgB`bBofBnfBgbBnb@`bnfBneB`eBafBheB`bBifBcgB`bB`gBbgBefBfgBefBnfBdgBifBnfBgfB`bBgbBmfB`gBbgBofBdgBefBcfBdgBgbB`bBafBcfBcfBefBcgBcgBnbAjBbeBegBnfB`bBgbB`gBafBhgBcfBdgBlfB`bBmbBcfBmfB`bBlcBefBhgBefBcfBegBdgBafBbfBlfBefBncBgb@`bmfBneBbeBgeBheB`bBmfBafB`gB`gBifBnfBgfB`bBdfBefBnfBifBefBdfB`bBffBofBbgB`bBegBnfBkfBnfBofBggBnfB`bBbgBefBafBcgBofBnfBnbB`eBlfBefBafBcgBefB`bBbgBefB`gBofBbgBdgB`bBdgBofB`bBhfBdgBdgB`gBjcBobBobBbfBegBgfBcgBnbBcfBlfBafBmfBafBfgBnbBnfBefBdgAj@`bed@`blfBcgBdgBafBbgBdgBegB`gBjcB`bBbfBigBdgBefBcfBofBdfBefB`bBefBhgBefBcfBegBdgBifBofBnfB`bBifBnfB`bBafBegBdgBofB`bBmfBofBdfBef@`bkfBcgBdgBafBbgBdgBegB`gBjcB`bBbfBigBdgBefBcfBofBdfBefB`bBefBhgBefBcfBegBdgBifBofBnfB`bBggBifBdgBhfB`bBifBnfBdgBefBbgB`gBbgBefBdgBefBbgB`bBofBnfBlfBig@`bjfBcgBdgBafBbgBdgBegB`gBjcB`bBbfBigBdgBefBcfBofBdfBefB`bBdfBifBcgBafBbfBlfBefBdf@`bad@Ab`bad@Ac`bad@Ad`bad@Ae`bad@Af`bad@Ag`bad@Ah`bad@Ai`bad@Aj`bad@Ak`bad@Al`bad@Am`bad@An`bad@Ao`bad@B`a`bad@Baa`bad@Bba`bad@Bca`bad@Bda`bad@Bea`bad@Bfa`bad@Bga`bad@Bha`\n"

+"A`b`bLbjib`bab`bab`babneab`b`bad`ah`aa`bad`ah`aa`b`f`bad`b`b`aa`b`b`aa`b`b`b`b`b`b`aa`b`b`aa`b`b`aa`b`b`aa`b`b`aa`b`b`aa`b`b`aa`b`b`aa`b`b`aa`b`b`aa`b`b`aa`b`b`b`b`bad`ah`b`b`b`b`aa`b`b`bad`ah`aa`ah`b`b`b`b`aa`b`b`b`b`aa`b`b`b`b`bad`ah`aa`bad`ah`aa`b`b`aa`b`b`b`b`aa`aa`aa`aa`aa`b`b`b`b`b`b`ah`aa`bcd`b`b`aa`bcd`b`b`bcd`b`b`aa`b`b`aa`b`b`b`b`aa`bad`ah`b`b`aa`b`b`aa`bad`ah`b`b`b`b`bad`ah`b`b`b`b`bad`ah`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`b`bad`ah`b`b`b`b`bcd`b`b`b`b`b`b`bad`ah`b`b`b`b`bcd`b`b`b`b`bcd`b`b`aa`b`b`bcd`b`b`aa`b`b`bcd`b`b`aa`b`b`b`b`aa`b`b`b`b`aa`b`b`b`b`Fbombdc\n"

+"Bb`badabbbhdacClnadbadaedbboeacBdadahafgbaeaaageaahaf@aTaaagbkaaa\n"

+"BbadahdbboeacB`adahaigbahaaajeaahaiAaaTaaajabb`a\n"

+"Bb`fakdbboeacAidbadaldbb`fak@db`bamkbalBja`Addaaaneab`bam@db`b`bbAadabTaaanadac\n"

+"Bb`baokbalBka`Addaab`aeab`bao@db`bab`ab`ab`b`bbababTbaad\n"

+"Bb`bbaabbabbaab`bbbaabcbjdBia`@dbaab`bbcakbalBma`Addaabdaeab`bbca@db`b`bbAadaaTaabdaaoae\n"

+"Bb`bbeakbalBna`Agdaabfaeab`bbea@db`b`bbAadaaTaabfaaoaf\n"

+"Bb`bbgakbalBoa`Addaabhaeab`bbga@db`b`bbAadaaTaabhaaoag\n"

+"Bb`bbiakbalB`b`Abdaabjaeab`bbia@db`b`bbAadaaTaabjaaoah\n"

+"Bb`bbkakbalBab`Addaablaeab`bbka@db`b`bbAadaaTaablaaoai\n"

+"Bb`bbmakbalBbb`Addaabnaeab`bbma@db`b`bbAadaaTaabnaaoaj\n"

+"Bb`bboakbalBcb`Afdaab`beab`bboa@db`b`bbAadaaTaab`baoak\n"

+"Bb`bbabkbalBdb`Aldaabbbeab`bbab@db`b`bbAadaaTaabbbaoal\n"

+"Bb`bbcbkbalBeb`Ajdaabdbeab`bbcb@db`b`bbAadaaTaabdbaoam\n"

+"Bb`bbebkbalBfb`Ahdaabfbeab`bbeb@db`b`bbAadaaTaabfbaoan\n"

+"Bb`bbgbkbalBgb`Abdaabhbeab`bbgb@db`baa`abhbb`b`bbaaaaTbaao\n"

+"Bb`bbibbbaabibb`bbjbabcbjdBla`@dbibTbab`a\n"

+"BbadbkbdbboeacBeadahblbgbbkbb`bbmb`ablbb`bbnbk`bmbAadaabobeab`bbnb@dTaabobbaabga\n"

+"Bb`bb`cabcbjdBhb`@dAadbadbacdbboeacBaadahbbcgbbacaabcceaahbbcAjaTaabccbbabka\n"

+"Bahbdcgbbkbb`bbec`abdcb`bbfck`becAbdaabgceab`bbfc@dTaabgcbdabca\n"

+"Bb`bbhcabcbjdBib`@dAadTbabka\n"

+"Bb`bbick`becAhdaabjceab`bbic@dTaabjcbfabea\n"

+"Bb`bbkcabcbjdBjb`@dAadTbabka\n"

+"Bb`bblcabcbjdBkb`@dAadTbabka\n"

+"BbadbmcdbboeacBaadahbncgbbmcaaboceaahbncAjaTaabocbiabha\n"

+"Bbadb`ddbboeacBbadahbadgbb`daabbdeaahbadAfaTaabbdbiabka\n"

+"Bb`bbcdk`bmbB`adaabddeab`bbcd@dTaabddbkabja\n"

+"Bb`bbedabcbjdBjb`@dAadTbabka\n"

+"Bb`bbfdabcbidBlb`@d@daabgdnab`bbfdAadTaabgdboabla\n"

+"Baabhdnab`bbfdAbdTaabhdbnabma\n"

+"Baabideab`bbfdAbdTaabidbbbbcb\n"

+"Baabjdeab`bbfdAadTaabjdbabbcb\n"

+"Baabkdeab`bbfd@dTaabkdb`bbcb\n"

+"Bb`bbldabbafBmb`@dTbabcb\n"

+"Bb`bbmdabbafBnb`@dTbabcb\n"

+"Bb`bbndabbafBob`@dTbabcb\n"

+"Bahbodgbaeaab`eeaahbod@aTaab`ebebbdb\n"

+"BbcdbaedbboeacAddb`bbbegbbaeaabceeab`bbbe@db`b`bbEamjnmd`Taabcebccbeb\n"

+"BbcdbdedbboeacAfdb`bbeegbbdebcdbfedbboeacAedb`bbgegbbfeaabheiab`bbeebgeb`b`bbEbmjnmd`Taabhebccbfb\n"

+"Bb`bbieab`bbdaabjeeab`bbgebieb`b`bbEcmjnmd`Taabjebgbbcc\n"

+"Bb`bbkegbbdeb`bbleab`bcdaabmeeab`bbkebleb`b`bbEdmjnmd`Taabmebhbbcc\n"

+"BbadbnedbboeacAndahboegbbneb`bb`f`aboeaabaflbb`bbbf`abafaabcfeab`bb`fbbfb`b`bbEemjnmd`Taabcfbibbcc\n"

+"BbadbdfdbboeacBaadahbefgbbdfb`bbff`abefb`bbgfh`bffBhadbadbhfdbboeacB`adahbifgbbhfb`bbjf`abifb`bbkfh`bjfBdadbadblfdbboeacBcadahbmfgbblfb`bbnf`abmfb`bbofh`bnfB`adb`bb`ggbbfeb`bbagh`b`gAhdb`bbbggbbdeb`bbcgl`bkfbgfb`bbdgl`bcgbagb`bbegl`bdgbbgb`bbfgl`begbofb`bbggh`b`fBladbadbhgdbboeacAodahbiggbbhgb`bbjg`abigb`bbkgh`bjgBhadbcdblgdbboeacAddb`bbmggbblgb`bbngl`bmgbggb`bbogl`bngbkgbadb`hdbboeacBeadahbahgbb`hb`bbbh`abahb`bbchh`bbhBhadbcdbdhdbboeacAcdb`bbehgbbdhb`bbfhl`bchbehbcdbghdbboeac@db`bbhhgbbghaabiheab`bbfgbhhTaabihbkbbjb\n"

+"Bb`bbjhabaagbfgTcab`bEfmjnmd\n"

+"BbcdbkhdbboeacAadb`bblhgbbkhaabmheab`bbogblhTaabmhbmbblb\n"

+"Bb`bbnhabaagbogTcab`bEgmjnmd\n"

+"BbcdbohdbboeacAbdb`bb`igbbohaabaieab`bbfhb`iTaabaibobbnb\n"

+"Bb`bbbiabaagbfhTcab`bEhmjnmd\n"

+"Bb`bbciabbaaHonnkm``odHm``oonnkdaabdieab`bbciHhgfedcbadTaabdibacb`c\n"

+"Bb`bbeiabaagbciTcab`bEimjnmd\n"

+"Bb`bbfiababcaDm``odaabgieab`bbfiDo``mdb`b`bbHnejkjgjmd`Taabgibccbbc\n"

+"Bb`bbhiabaagbfiTcab`bF`amjnmd\n"

+"Bb`bbiibb`biiTcab`bbiiE\n"

 ;

 /* source-code for builtin_bc_startup: */

 #if 0

@@ -97,6 +108,21 @@ int entrypoint()

       disable_jit_if("i[34]86 detected, JIT needs pentium or better",0,

                      !memcmp(env.cpu,"i386",4) ||

                      !memcmp(env.cpu,"i486",4));

+      /* FIXME: update embedded LLVM to 2.8 which correctly skips CMOV if CPU

+       * doesn't support it.

+       * For now disable JIT on CPUs without cmov */

+      disable_jit_if("CPU doesn't support CMOV, would need LLVM 2.8 to work!",0,

+		     !memcmp(env.cpu,"i586",4) ||

+		     !memcmp(env.cpu,"pentium",7) ||

+		     !memcmp(env.cpu,"i686",4) ||

+		     !memcmp(env.cpu,"k6",2) ||

+		     !memcmp(env.cpu,"k6-2",4) ||

+		     !memcmp(env.cpu,"k6-3",4) ||

+		     !memcmp(env.cpu,"athlon",6) ||

+		     !memcmp(env.cpu,"athlon-tbird",12) ||

+		     !memcmp(env.cpu,"winchip-c6",10) ||

+		     !memcmp(env.cpu,"winchip2",8) ||

+		     !memcmp(env.cpu,"c3",2));

       break;

     default:

       break;

@@ -1629,10 +1629,15 @@ int cli_bytecode_run(const struct cli_all_bc *bcs, const struct cli_bc *bc, stru

     if (test_mode) {

 	jit_ev = cli_events_new(BCEV_LASTEVENT);

 	interp_ev = cli_events_new(BCEV_LASTEVENT);

-	if (!jit_ev || !interp_ev)

+	if (!jit_ev || !interp_ev) {

+	    cli_events_free(jit_ev);

+	    cli_events_free(interp_ev);

 	    return CL_EMEM;

+	}

 	if (register_events(jit_ev) == -1 ||

 	    register_events(interp_ev) == -1) {

+	    cli_events_free(jit_ev);

+	    cli_events_free(interp_ev);

 	    return CL_EBYTECODE_TESTFAIL;

 	}

     }

@@ -1655,6 +1660,8 @@ int cli_bytecode_run(const struct cli_all_bc *bcs, const struct cli_bc *bc, stru

 	inst.u.ops.opsizes = ctx->opsizes;

 	cli_dbgmsg("Bytecode %u: executing in interpeter mode\n", bc->id);

+	ctx->on_jit = 0;

+

 	cli_event_time_start(interp_ev, BCEV_EXEC_TIME);

 	ret = cli_vm_execute(ctx->bc, ctx, &func, &inst);

 	cli_event_time_stop(interp_ev, BCEV_EXEC_TIME);

@@ -1674,6 +1681,7 @@ int cli_bytecode_run(const struct cli_all_bc *bcs, const struct cli_bc *bc, stru

 	ctx->bc_events = jit_ev;

 	cli_dbgmsg("Bytecode %u: executing in JIT mode\n", bc->id);

+	ctx->on_jit = 1;

 	cli_event_time_start(jit_ev, BCEV_EXEC_TIME);

 	ret = cli_vm_execute_jit(bcs, ctx, &bc->funcs[ctx->funcid]);

 	cli_event_time_stop(jit_ev, BCEV_EXEC_TIME);

@@ -1699,7 +1707,7 @@ int cli_bytecode_run(const struct cli_all_bc *bcs, const struct cli_bc *bc, stru

 			bc->id, interp_errors, jit_errors);

 	    ok = 0;

 	}

-	if (cli_event_diff_all(interp_ev, jit_ev, NULL)) {

+	if (!ctx->no_diff && cli_event_diff_all(interp_ev, jit_ev, NULL)) {

 	    cli_infomsg(cctx, "bytecode %d execution different with JIT and interpreter, see --debug for details\n",

 			bc->id);

 	    ok = 0;

@@ -1720,9 +1728,14 @@ int cli_bytecode_run(const struct cli_all_bc *bcs, const struct cli_bc *bc, stru

 	}

 	/*cli_event_debug(jit_ev, BCEV_EXEC_TIME);

 	cli_event_debug(interp_ev, BCEV_EXEC_TIME);*/

-	if (!ok)

+	if (!ok) {

+	    cli_events_free(jit_ev);

+	    cli_events_free(interp_ev);

 	    return CL_EBYTECODE_TESTFAIL;

+	}

     }

+    cli_events_free(jit_ev);

+    cli_events_free(interp_ev);

     return ret;

 }

@@ -1340,9 +1340,9 @@ int32_t cli_bcapi_version_compare(struct cli_bc_ctx *ctx , const uint8_t* lhs, u

 	if (!isdigit(lhs[i]) || !isdigit(rhs[j]))

 	    return lhs[i] < rhs[j] ? -1 : 1;

 	while (isdigit(lhs[i]) && i < lhs_len)

-	    li = 10*li + (lhs[i] - '0');

+	    li = 10*li + (lhs[i++] - '0');

 	while (isdigit(rhs[j]) && j < rhs_len)

-	    ri = 10*ri + (rhs[j] - '0');

+	    ri = 10*ri + (rhs[j++] - '0');

 	if (li < ri)

 	    return -1;

 	if (li > ri)

@@ -1502,3 +1502,8 @@ int32_t cli_bcapi_pdf_get_dumpedobjid(struct cli_bc_ctx *ctx)

     return ctx->pdf_dumpedid;

 }

+int32_t cli_bcapi_running_on_jit(struct cli_bc_ctx *ctx )

+{

+    ctx->no_diff = 1;

+    return ctx->on_jit;

+}

@@ -977,5 +977,11 @@ int32_t pdf_get_dumpedobjid(void);

 int32_t matchicon(const uint8_t* group1, int32_t group1_len,

                   const uint8_t* group2, int32_t group2_len);

 /* ---------------- END 0.96.2 APIs   ----------------------------------- */

+/* ----------------- BEGIN 0.96.4 APIs ---------------------------------- */

+/* Returns whether running on JIT. As side-effect it disables

+ * interp / JIT comparisons in test mode (errors are still checked) */

+int32_t running_on_jit(void);

+

+/* ----------------- END 0.96.4 APIs ---------------------------------- */

 #endif

 #endif

@@ -122,6 +122,7 @@ int32_t cli_bcapi_pdf_get_offset(struct cli_bc_ctx *ctx , int32_t);

 int32_t cli_bcapi_pdf_get_phase(struct cli_bc_ctx *ctx );

 int32_t cli_bcapi_pdf_get_dumpedobjid(struct cli_bc_ctx *ctx );

 int32_t cli_bcapi_matchicon(struct cli_bc_ctx *ctx , const uint8_t*, int32_t, const uint8_t*, int32_t);

+int32_t cli_bcapi_running_on_jit(struct cli_bc_ctx *ctx );

 const struct cli_apiglobal cli_globals[] = {

 /* Bytecode globals BEGIN */

@@ -146,8 +147,8 @@ static uint16_t cli_tmp4[]={16, 8, 8, 32, 32, 32, 32, 32, 32, 32, 32, 32, 16, 16

 static uint16_t cli_tmp5[]={32, 16, 16, 32, 32, 32, 16, 16};

 static uint16_t cli_tmp6[]={32};

 static uint16_t cli_tmp7[]={32};

-static uint16_t cli_tmp8[]={32, 65, 32, 65, 32};

-static uint16_t cli_tmp9[]={32};

+static uint16_t cli_tmp8[]={32};

+static uint16_t cli_tmp9[]={32, 65, 32, 65, 32};

 static uint16_t cli_tmp10[]={32, 32};

 static uint16_t cli_tmp11[]={32, 32, 32};

 static uint16_t cli_tmp12[]={65, 32, 32};

@@ -179,8 +180,8 @@ const struct cli_bc_type cli_apicall_types[]={

 	{DStructType, cli_tmp5, 8, 0, 0},

 	{DArrayType, cli_tmp6, 1, 0, 0},

 	{DArrayType, cli_tmp7, 64, 0, 0},

-	{DFunctionType, cli_tmp8, 5, 0, 0},

-	{DFunctionType, cli_tmp9, 1, 0, 0},

+	{DFunctionType, cli_tmp8, 1, 0, 0},

+	{DFunctionType, cli_tmp9, 5, 0, 0},

 	{DFunctionType, cli_tmp10, 2, 0, 0},

 	{DFunctionType, cli_tmp11, 3, 0, 0},

 	{DFunctionType, cli_tmp12, 3, 0, 0},

@@ -230,7 +231,7 @@ const struct cli_apicall cli_apicalls[]={

 	{"fill_buffer", 20, 0, 4},

 	{"extract_new", 10, 4, 2},

 	{"read_number", 10, 5, 2},

-	{"hashset_new", 9, 0, 5},

+	{"hashset_new", 8, 0, 5},

 	{"hashset_add", 11, 2, 0},

 	{"hashset_remove", 11, 3, 0},

 	{"hashset_contains", 11, 4, 0},

@@ -257,7 +258,7 @@ const struct cli_apicall cli_apicalls[]={

 	{"iexp", 13, 2, 7},

 	{"isin", 13, 3, 7},

 	{"icos", 13, 4, 7},

-	{"memstr", 8, 0, 8},

+	{"memstr", 9, 0, 8},

 	{"hex2ui", 11, 8, 0},

 	{"atoi", 19, 13, 1},

 	{"debug_print_str_start", 19, 14, 1},

@@ -272,19 +273,19 @@ const struct cli_apicall cli_apicalls[]={

 	{"map_getvalue", 12, 2, 6},

 	{"map_done", 10, 20, 2},

 	{"file_find_limit", 14, 4, 9},

-	{"engine_functionality_level", 9, 1, 5},

-	{"engine_dconf_level", 9, 2, 5},

-	{"engine_scan_options", 9, 3, 5},

-	{"engine_db_options", 9, 4, 5},

+	{"engine_functionality_level", 8, 1, 5},

+	{"engine_dconf_level", 8, 2, 5},

+	{"engine_scan_options", 8, 3, 5},

+	{"engine_db_options", 8, 4, 5},

 	{"extract_set_container", 10, 21, 2},

 	{"input_switch", 10, 22, 2},

 	{"get_environment", 15, 17, 1},

 	{"disable_bytecode_if", 14, 5, 9},

 	{"disable_jit_if", 14, 6, 9},

-	{"version_compare", 8, 1, 8},

+	{"version_compare", 9, 1, 8},

 	{"check_platform", 13, 5, 7},

-	{"pdf_get_obj_num", 9, 5, 5},

-	{"pdf_get_flags", 9, 6, 5},

+	{"pdf_get_obj_num", 8, 5, 5},

+	{"pdf_get_flags", 8, 6, 5},

 	{"pdf_set_flags", 10, 23, 2},

 	{"pdf_lookupobj", 10, 24, 2},

 	{"pdf_getobjsize", 10, 25, 2},

@@ -293,9 +294,10 @@ const struct cli_apicall cli_apicalls[]={

 	{"pdf_getobjflags", 10, 27, 2},

 	{"pdf_setobjflags", 11, 10, 0},

 	{"pdf_get_offset", 10, 28, 2},

-	{"pdf_get_phase", 9, 7, 5},

-	{"pdf_get_dumpedobjid", 9, 8, 5},

-	{"matchicon", 8, 2, 8}

+	{"pdf_get_phase", 8, 7, 5},

+	{"pdf_get_dumpedobjid", 8, 8, 5},

+	{"matchicon", 9, 2, 8},

+	{"running_on_jit", 8, 9, 5}

 /* Bytecode APIcalls END */

 };

 const cli_apicall_int2 cli_apicalls0[] = {

@@ -377,7 +379,8 @@ const cli_apicall_allocobj cli_apicalls5[] = {

 	(cli_apicall_allocobj)cli_bcapi_pdf_get_obj_num,

 	(cli_apicall_allocobj)cli_bcapi_pdf_get_flags,

 	(cli_apicall_allocobj)cli_bcapi_pdf_get_phase,

-	(cli_apicall_allocobj)cli_bcapi_pdf_get_dumpedobjid

+	(cli_apicall_allocobj)cli_bcapi_pdf_get_dumpedobjid,

+	(cli_apicall_allocobj)cli_bcapi_running_on_jit

 };

 const cli_apicall_bufget cli_apicalls6[] = {

 	(cli_apicall_bufget)cli_bcapi_buffer_pipe_read_get,

@@ -120,5 +120,6 @@ int32_t cli_bcapi_pdf_get_offset(struct cli_bc_ctx *ctx , int32_t);

 int32_t cli_bcapi_pdf_get_phase(struct cli_bc_ctx *ctx );

 int32_t cli_bcapi_pdf_get_dumpedobjid(struct cli_bc_ctx *ctx );

 int32_t cli_bcapi_matchicon(struct cli_bc_ctx *ctx , const uint8_t*, int32_t, const uint8_t*, int32_t);

+int32_t cli_bcapi_running_on_jit(struct cli_bc_ctx *ctx );

 #endif

@@ -34,8 +34,9 @@ int cli_bytecode_prepare_jit(struct cli_all_bc *bcs)

     for (i=0;i<bcs->count;i++) {

 	if (bcs->all_bcs[i].state == bc_skip)

 	    continue;

-	if (bcs->all_bcs[i].state != bc_loaded) {

-	    cli_warnmsg("Cannot prepare for JIT, because it has already been converted to interpreter");

+	if (bcs->all_bcs[i].state != bc_loaded &&

+	    bcs->all_bcs[i].kind != BC_STARTUP) {

+	    cli_warnmsg("Cannot prepare for JIT, because it has already been converted to interpreter\n");

 	    return CL_EBYTECODE;

 	}

     }

@@ -225,6 +225,8 @@ struct cli_bc_ctx {

     const struct cli_environment *env;

     unsigned bytecode_disable_status;

     cli_events_t *bc_events;

+    int on_jit;

+    int no_diff;

 };

 struct cli_all_bc;

 int cli_vm_execute(const struct cli_bc *bc, struct cli_bc_ctx *ctx, const struct cli_bc_func *func, const struct cli_bc_inst *inst);

@@ -2022,6 +2022,8 @@ int cli_bytecode_prepare_jit(struct cli_all_bc *bcs)

 	for (unsigned i=0;i<bcs->count;i++) {

 	    const struct cli_bc_func *func = &bcs->all_bcs[i].funcs[0];

+	    if (bcs->all_bcs[i].state == bc_interp)

+		continue; /* probably BC_STARTUP */

 	    bcs->engine->compiledFunctions[func] = EE->getPointerToFunction(Functions[i]);

 	    bcs->all_bcs[i].state = bc_jit;

 	}

@@ -67,6 +67,7 @@

 #include "default.h"

 #include "scanners.h"

 #include "bytecode.h"

+#include "bytecode_api_impl.h"

 int (*cli_unrar_open)(int fd, const char *dirname, unrar_state_t *state);

 int (*cli_unrar_extract_next_prepare)(unrar_state_t *state, const char *dirname);

@@ -261,6 +262,19 @@ int cl_init(unsigned int initoptions)

 	struct timeval tv;

 	unsigned int pid = (unsigned int) getpid();

+	const char *zlibver = zlibVersion();

+	int cmp = cli_bcapi_version_compare(NULL, zlibver, strlen(zlibver),

+					    ZLIB_VERSION, strlen(ZLIB_VERSION));

+	if (cmp) {

+	    cli_dbgmsg("zlib version at runtime: %s, compile time: %s\n",

+		       zlibver, ZLIB_VERSION);

+	}

+	if (cmp < 0) {

+	    cli_warnmsg("zlib version at runtime is older than compile time: %s < %s\n",

+			zlibver, ZLIB_VERSION);

+	    cli_infomsg(NULL, "Make sure zlib is built as shared library, and that the new zlib library is installed in the proper place\n");

+	}

+

     {

 	unrar_main_header_t x;

 	if (((char*)&x.flags - (char*)&x) != 3) {

@@ -899,7 +899,7 @@ static void pdf_parseobj(struct pdf_struct *pdf, struct pdf_obj *obj)

     dict_length = q3 - dict;

     /*  process pdf names */

-    for (q = dict;dict_length;) {

+    for (q = dict;dict_length > 0;) {

 	int escapes = 0;

 	q2 = memchr(q, '/', dict_length);

 	if (!q2)

@@ -907,7 +907,7 @@ static void pdf_parseobj(struct pdf_struct *pdf, struct pdf_obj *obj)

 	dict_length -= q2 - q;

 	q = q2;

 	/* normalize PDF names */

-	for (i = 0;dict_length && (i < sizeof(pdfname)-1); i++) {

+	for (i = 0;dict_length > 0 && (i < sizeof(pdfname)-1); i++) {

 	    q++;

 	    dict_length--;

 	    if (*q == '#') {

@@ -929,8 +929,8 @@ static void pdf_parseobj(struct pdf_struct *pdf, struct pdf_obj *obj)

 	    pdfobj_flag(pdf, obj, LINEARIZED_PDF);

 	    objstate = STATE_NONE;

 	}

-	if (objstate == STATE_JAVASCRIPT ||

-	    objstate == STATE_OPENACTION) {

+	if (dict_length > 0 && (objstate == STATE_JAVASCRIPT ||

+	    objstate == STATE_OPENACTION)) {

 	    if (objstate == STATE_OPENACTION)

 		pdfobj_flag(pdf, obj, HAS_OPENACTION);

 	    q2 = pdf_nextobject(q, dict_length);

@@ -941,7 +941,7 @@ static void pdf_parseobj(struct pdf_struct *pdf, struct pdf_obj *obj)

 		if (q2 && isdigit(*q2)) {

 		    objid |= atoi(q2) & 0xff;

 		    q2 = pdf_nextobject(q2, dict_length);

-		    if (*q2 == 'R') {

+		    if (q2 && *q2 == 'R') {

 			struct pdf_obj *obj2;

 			cli_dbgmsg("cli_pdf: found %s stored in indirect object %u %u\n",

 				   pdfname,

@@ -1043,7 +1043,7 @@ int cli_pdf(const char *dir, cli_ctx *ctx, off_t offset)

 	cli_dbgmsg("cli_pdf: %%%%EOF not found\n");

     } else {

 	const char *t;

-	size = q - eofmap + map_off;

+	/*size = q - eofmap + map_off;*/

 	q -= 9;

 	for (;q > eofmap;q--) {

 	    if (memcmp(q, "startxref", 9) == 0)

@@ -1636,6 +1636,7 @@ static int cli_scanembpe(cli_ctx *ctx, off_t offset)

 	char *buff;

 	char *tmpname;

 	fmap_t *map = *ctx->fmap;

+	unsigned int corrupted_input;

     tmpname = cli_gentemp(ctx->engine->tmpdir);

     if(!tmpname)

@@ -1686,7 +1687,11 @@ static int cli_scanembpe(cli_ctx *ctx, off_t offset)

     ctx->recursion++;

     lseek(fd, 0, SEEK_SET);

-    if((ret = cli_magic_scandesc(fd, ctx)) == CL_VIRUS) {

+    corrupted_input = ctx->corrupted_input;

+    ctx->corrupted_input = 1;

+    ret = cli_magic_scandesc(fd, ctx);

+    ctx->corrupted_input = corrupted_input;

+    if(ret == CL_VIRUS) {

 	cli_dbgmsg("cli_scanembpe: Infected with %s\n", *ctx->virname);

 	close(fd);

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

@@ -47,7 +47,7 @@ die()

 # Setup test directory to avoid temporary and output file clashes

 test_start() {

-    ulimit -t 120; ulimit -d 512000;

+    ulimit -t 120 || true; ulimit -d 512000 || true;

     ulimit -v 512000 || true;

     (cd test-$1 2>/dev/null && killclamd || true)

     rm -rf test-$1

@@ -2,7 +2,7 @@

 # Helper script to run a program under electric-fence / duma

 # prevent core dumps

-ulimit -c 0

+ulimit -c 0 || true

 LD_PRELOAD=$LIBPRELOAD

 export LD_PRELOAD

 export CK_DEFAULT_TIMEOUT=40