vcl/workben/fftester.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20  /* e.g.
  21         export CC=afl-clang-fast
  22         export CXX=afl-clang-fast++
  23         make
  24         cp workdir/LinkTarget/Executable/fftester instdir/program
  25         LD_LIBRARY_PATH=`pwd`/instdir/program SAL_USE_VCLPLUGIN=svp AFL_PERSISTENT=1 afl-fuzz -t 50 -i ~/fuzz/in.png -o ~/fuzz/out.png -d -T png -m 50000000 instdir/program/fftester @@ png
  26
  27         On slower file formats like .doc you can probably drop the -t and rely on the
  28         estimations, on faster file formats ironically not specifing a timeout will
  29         result in a hilarious dramatic falloff in performance from thousands per second
  30         to teens per second as tiny variations from the initial calculated
  31         timeout will trigger a shutdown of the fftester and a restart and the
  32         startup time is woeful (hence the AFL_PERSISTENT mode in the first place)
  33   */
  34
  35 #include <sal/main.h>
  36 #include <tools/extendapplicationenvironment.hxx>
  37
  38 #include <cppuhelper/bootstrap.hxx>
  39 #include <comphelper/processfactory.hxx>
  40
  41 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  42 #include <com/sun/star/uno/XComponentContext.hpp>
  43 #include <unotools/configmgr.hxx>
  44 #include <vcl/dibtools.hxx>
  45 #include <vcl/event.hxx>
  46 #include <vcl/graphicfilter.hxx>
  47 #include <vcl/pngread.hxx>
  48 #include <vcl/svapp.hxx>
  49 #include <vcl/wmf.hxx>
  50 #include <vcl/wrkwin.hxx>
  51 #include <vcl/fltcall.hxx>
  52 #include <osl/file.hxx>
  53 #include <signal.h>
  54
  55 #include <../source/filter/igif/gifread.hxx>
  56 #include <../source/filter/ixbm/xbmread.hxx>
  57 #include <../source/filter/ixpm/xpmread.hxx>
  58 #include <../source/filter/jpeg/jpeg.hxx>
  59
  60 using namespace ::com::sun::star::uno;
  61 using namespace ::com::sun::star::lang;
  62 using namespace cppu;
  63
  64 extern "C" { static void SAL_CALL thisModule() {} }
  65
  66 typedef bool (*WFilterCall)(const OUString &rUrl, const OUString &rFlt);
  67 typedef bool (*HFilterCall)(const OUString &rUrl);
  68
  69 /* This constant specifies the number of inputs to process before restarting.
  70  * This is optional, but helps limit the impact of memory leaks and similar
  71  * hiccups. */
  72
  73 #define PERSIST_MAX 1000
  74 unsigned int persist_cnt;
  75
  76 SAL_IMPLEMENT_MAIN_WITH_ARGS(argc, argv)
  77 {
  78     int ret = -1;
  79     try
  80     {
  81         if (argc < 3)
  82         {
  83             fprintf(stderr, "Usage: fftester <filename> <wmf|jpg>\n");
  84             return -1;
  85         }
  86
  87         OUString in(argv[1], strlen(argv[1]), RTL_TEXTENCODING_UTF8);
  88         OUString out;
  89         osl::File::getFileURLFromSystemPath(in, out);
  90
  91         tools::extendApplicationEnvironment();
  92
  93         Reference< XComponentContext > xContext = defaultBootstrap_InitialComponentContext();
  94         Reference< XMultiServiceFactory > xServiceManager( xContext->getServiceManager(), UNO_QUERY );
  95         if( !xServiceManager.is() )
  96             Application::Abort( "Failed to bootstrap" );
  97         comphelper::setProcessServiceFactory( xServiceManager );
  98         utl::ConfigManager::EnableAvoidConfig();
  99         InitVCL();
 100
 101 try_again:
 102
 103         {
 104             if (strcmp(argv[2], "wmf") == 0 || strcmp(argv[2], "emf") == 0)
 105             {
 106                 GDIMetaFile aGDIMetaFile;
 107                 SvFileStream aFileStream(out, StreamMode::READ);
 108                 ret = (int) ReadWindowMetafile(aFileStream, aGDIMetaFile);
 109             }
 110             else if (strcmp(argv[2], "jpg") == 0)
 111             {
 112                 Graphic aGraphic;
 113                 SvFileStream aFileStream(out, StreamMode::READ);
 114                 ret = (int) ImportJPEG(aFileStream, aGraphic, nullptr, GraphicFilterImportFlags::NONE);
 115             }
 116             else if (strcmp(argv[2], "gif") == 0)
 117             {
 118                 SvFileStream aFileStream(out, StreamMode::READ);
 119                 Graphic aGraphic;
 120                 ret = (int) ImportGIF(aFileStream, aGraphic);
 121             }
 122             else if (strcmp(argv[2], "xbm") == 0)
 123             {
 124                 Graphic aGraphic;
 125                 SvFileStream aFileStream(out, StreamMode::READ);
 126                 ret = (int) ImportXBM(aFileStream, aGraphic);
 127             }
 128             else if (strcmp(argv[2], "xpm") == 0)
 129             {
 130                 Graphic aGraphic;
 131                 SvFileStream aFileStream(out, StreamMode::READ);
 132                 ret = (int) ImportXPM(aFileStream, aGraphic);
 133             }
 134             else if (strcmp(argv[2], "png") == 0)
 135             {
 136                 SvFileStream aFileStream(out, StreamMode::READ);
 137                 vcl::PNGReader aReader(aFileStream);
 138                 aReader.Read();
 139             }
 140             else if (strcmp(argv[2], "bmp") == 0)
 141             {
 142                 Bitmap aTarget;
 143                 SvFileStream aFileStream(out, StreamMode::READ);
 144                 ret = (int) ReadDIB(aTarget, aFileStream, true);
 145             }
 146             else if (strcmp(argv[2], "svm") == 0)
 147             {
 148                 GDIMetaFile aGDIMetaFile;
 149                 SvFileStream aFileStream(out, StreamMode::READ);
 150                 ReadGDIMetaFile(aFileStream, aGDIMetaFile);
 151             }
 152             else if (strcmp(argv[2], "pcd") == 0)
 153             {
 154                 static PFilterCall pfnImport(nullptr);
 155                 if (!pfnImport)
 156                 {
 157                     osl::Module aLibrary;
 158                     aLibrary.loadRelative(&thisModule, "libicdlo.so");
 159                     pfnImport = reinterpret_cast<PFilterCall>(
 160                         aLibrary.getFunctionSymbol("GraphicImport"));
 161                     aLibrary.release();
 162                 }
 163                 Graphic aTarget;
 164                 SvFileStream aFileStream(out, StreamMode::READ);
 165                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 166             }
 167             else if (strcmp(argv[2], "dxf") == 0)
 168             {
 169                 static PFilterCall pfnImport(nullptr);
 170                 if (!pfnImport)
 171                 {
 172                     osl::Module aLibrary;
 173                     aLibrary.loadRelative(&thisModule, "libidxlo.so");
 174                     pfnImport = reinterpret_cast<PFilterCall>(
 175                         aLibrary.getFunctionSymbol("GraphicImport"));
 176                     aLibrary.release();
 177                 }
 178                 Graphic aTarget;
 179                 SvFileStream aFileStream(out, StreamMode::READ);
 180                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 181             }
 182             else if (strcmp(argv[2], "met") == 0)
 183             {
 184                 static PFilterCall pfnImport(nullptr);
 185                 if (!pfnImport)
 186                 {
 187                     osl::Module aLibrary;
 188                     aLibrary.loadRelative(&thisModule, "libimelo.so");
 189                     pfnImport = reinterpret_cast<PFilterCall>(
 190                         aLibrary.getFunctionSymbol("GraphicImport"));
 191                     aLibrary.release();
 192                 }
 193                 Graphic aTarget;
 194                 SvFileStream aFileStream(out, StreamMode::READ);
 195                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 196             }
 197             else if ((strcmp(argv[2], "pbm") == 0) || strcmp(argv[2], "ppm") == 0)
 198             {
 199                 static PFilterCall pfnImport(nullptr);
 200                 if (!pfnImport)
 201                 {
 202                     osl::Module aLibrary;
 203                     aLibrary.loadRelative(&thisModule, "libipblo.so");
 204                     pfnImport = reinterpret_cast<PFilterCall>(
 205                         aLibrary.getFunctionSymbol("GraphicImport"));
 206                     aLibrary.release();
 207                 }
 208                 Graphic aTarget;
 209                 SvFileStream aFileStream(out, StreamMode::READ);
 210                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 211             }
 212             else if (strcmp(argv[2], "psd") == 0)
 213             {
 214                 static PFilterCall pfnImport(nullptr);
 215                 if (!pfnImport)
 216                 {
 217                     osl::Module aLibrary;
 218                     aLibrary.loadRelative(&thisModule, "libipdlo.so");
 219                     pfnImport = reinterpret_cast<PFilterCall>(
 220                         aLibrary.getFunctionSymbol("GraphicImport"));
 221                     aLibrary.release();
 222                 }
 223                 Graphic aTarget;
 224                 SvFileStream aFileStream(out, StreamMode::READ);
 225                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 226             }
 227             else if (strcmp(argv[2], "eps") == 0)
 228             {
 229                 static PFilterCall pfnImport(nullptr);
 230                 if (!pfnImport)
 231                 {
 232                     osl::Module aLibrary;
 233                     aLibrary.loadRelative(&thisModule, "libipslo.so");
 234                     pfnImport = reinterpret_cast<PFilterCall>(
 235                         aLibrary.getFunctionSymbol("GraphicImport"));
 236                     aLibrary.release();
 237                 }
 238                 Graphic aTarget;
 239                 SvFileStream aFileStream(out, StreamMode::READ);
 240                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 241             }
 242             else if (strcmp(argv[2], "pct") == 0)
 243             {
 244                 static PFilterCall pfnImport(nullptr);
 245                 if (!pfnImport)
 246                 {
 247                     osl::Module aLibrary;
 248                     aLibrary.loadRelative(&thisModule, "libiptlo.so");
 249                     pfnImport = reinterpret_cast<PFilterCall>(
 250                         aLibrary.getFunctionSymbol("GraphicImport"));
 251                     aLibrary.release();
 252                 }
 253                 Graphic aTarget;
 254                 SvFileStream aFileStream(out, StreamMode::READ);
 255                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 256             }
 257             else if (strcmp(argv[2], "pcx") == 0)
 258             {
 259                 static PFilterCall pfnImport(nullptr);
 260                 if (!pfnImport)
 261                 {
 262                     osl::Module aLibrary;
 263                     aLibrary.loadRelative(&thisModule, "libipxlo.so");
 264                     pfnImport = reinterpret_cast<PFilterCall>(
 265                         aLibrary.getFunctionSymbol("GraphicImport"));
 266                     aLibrary.release();
 267                 }
 268                 Graphic aTarget;
 269                 SvFileStream aFileStream(out, StreamMode::READ);
 270                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 271             }
 272             else if (strcmp(argv[2], "ras") == 0)
 273             {
 274                 static PFilterCall pfnImport(nullptr);
 275                 if (!pfnImport)
 276                 {
 277                     osl::Module aLibrary;
 278                     aLibrary.loadRelative(&thisModule, "libiralo.so");
 279                     pfnImport = reinterpret_cast<PFilterCall>(
 280                         aLibrary.getFunctionSymbol("GraphicImport"));
 281                     aLibrary.release();
 282                 }
 283                 Graphic aTarget;
 284                 SvFileStream aFileStream(out, StreamMode::READ);
 285                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 286             }
 287             else if (strcmp(argv[2], "tga") == 0)
 288             {
 289                 static PFilterCall pfnImport(nullptr);
 290                 if (!pfnImport)
 291                 {
 292                     osl::Module aLibrary;
 293                     aLibrary.loadRelative(&thisModule, "libitglo.so");
 294                     pfnImport = reinterpret_cast<PFilterCall>(
 295                         aLibrary.getFunctionSymbol("GraphicImport"));
 296                     aLibrary.release();
 297                 }
 298                 Graphic aTarget;
 299                 SvFileStream aFileStream(out, StreamMode::READ);
 300                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 301             }
 302             else if (strcmp(argv[2], "tif") == 0)
 303             {
 304                 static PFilterCall pfnImport(nullptr);
 305                 if (!pfnImport)
 306                 {
 307                     osl::Module aLibrary;
 308                     aLibrary.loadRelative(&thisModule, "libitilo.so");
 309                     pfnImport = reinterpret_cast<PFilterCall>(
 310                         aLibrary.getFunctionSymbol("GraphicImport"));
 311                     aLibrary.release();
 312                 }
 313                 Graphic aTarget;
 314                 SvFileStream aFileStream(out, StreamMode::READ);
 315                 ret = (int) (*pfnImport)(aFileStream, aTarget, nullptr);
 316             }
 317             else if ( (strcmp(argv[2], "doc") == 0) ||
 318                       (strcmp(argv[2], "ww8") == 0) ||
 319                       (strcmp(argv[2], "ww6") == 0) ||
 320                       (strcmp(argv[2], "ww2") == 0) )
 321             {
 322                 static WFilterCall pfnImport(nullptr);
 323                 if (!pfnImport)
 324                 {
 325                     osl::Module aLibrary;
 326                     aLibrary.loadRelative(&thisModule, "libmswordlo.so", SAL_LOADMODULE_LAZY);
 327                     pfnImport = reinterpret_cast<WFilterCall>(
 328                         aLibrary.getFunctionSymbol("TestImportDOC"));
 329                     aLibrary.release();
 330                 }
 331                 if (strcmp(argv[2], "ww6") == 0)
 332                     ret = (int) (*pfnImport)(out, OUString("CWW6"));
 333                 else if (strcmp(argv[2], "ww2") == 0)
 334                     ret = (int) (*pfnImport)(out, OUString("WW6"));
 335                 else
 336                     ret = (int) (*pfnImport)(out, OUString("CWW8"));
 337             }
 338             else if ( (strcmp(argv[2], "xls") == 0) ||
 339                       (strcmp(argv[2], "wb2") == 0) )
 340             {
 341                 static WFilterCall pfnImport(nullptr);
 342                 if (!pfnImport)
 343                 {
 344                     osl::Module aLibrary;
 345                     aLibrary.loadRelative(&thisModule, "libscfiltlo.so", SAL_LOADMODULE_LAZY);
 346                     pfnImport = reinterpret_cast<WFilterCall>(
 347                         aLibrary.getFunctionSymbol("TestImportSpreadsheet"));
 348                     aLibrary.release();
 349                 }
 350                 ret = (int) (*pfnImport)(out, OUString(argv[2], strlen(argv[2]), RTL_TEXTENCODING_UTF8));
 351             }
 352             else if (strcmp(argv[2], "hwp") == 0)
 353             {
 354                 static HFilterCall pfnImport(nullptr);
 355                 if (!pfnImport)
 356                 {
 357                     osl::Module aLibrary;
 358                     aLibrary.loadRelative(&thisModule, "libhwplo.so", SAL_LOADMODULE_LAZY);
 359                     pfnImport = reinterpret_cast<HFilterCall>(
 360                         aLibrary.getFunctionSymbol("TestImportHWP"));
 361                     aLibrary.release();
 362                 }
 363                 ret = (int) (*pfnImport)(out);
 364             }
 365             else if (strcmp(argv[2], "602") == 0)
 366             {
 367                 static HFilterCall pfnImport(nullptr);
 368                 if (!pfnImport)
 369                 {
 370                     osl::Module aLibrary;
 371                     aLibrary.loadRelative(&thisModule, "libt602filterlo.so", SAL_LOADMODULE_LAZY);
 372                     pfnImport = reinterpret_cast<HFilterCall>(
 373                         aLibrary.getFunctionSymbol("TestImport602"));
 374                     aLibrary.release();
 375                 }
 376                 ret = (int) (*pfnImport)(out);
 377             }
 378             else if (strcmp(argv[2], "lwp") == 0)
 379             {
 380                 static HFilterCall pfnImport(nullptr);
 381                 if (!pfnImport)
 382                 {
 383                     osl::Module aLibrary;
 384                     aLibrary.loadRelative(&thisModule, "liblwpftlo.so", SAL_LOADMODULE_LAZY);
 385                     pfnImport = reinterpret_cast<HFilterCall>(
 386                         aLibrary.getFunctionSymbol("TestImportLWP"));
 387                     aLibrary.release();
 388                 }
 389                 ret = (int) (*pfnImport)(out);
 390             }
 391             else if (strcmp(argv[2], "ppt") == 0)
 392             {
 393                 static HFilterCall pfnImport(nullptr);
 394                 if (!pfnImport)
 395                 {
 396                     osl::Module aLibrary;
 397                     aLibrary.loadRelative(&thisModule, "libsdfiltlo.so", SAL_LOADMODULE_LAZY);
 398                     pfnImport = reinterpret_cast<HFilterCall>(
 399                         aLibrary.getFunctionSymbol("TestImportPPT"));
 400                     aLibrary.release();
 401                 }
 402                 ret = (int) (*pfnImport)(out);
 403             }
 404         }
 405
 406         /* To signal successful completion of a run, we need to deliver
 407            SIGSTOP to our own process, then loop to the very beginning
 408            once we're resumed by the supervisor process. We do this only
 409            if AFL_PERSISTENT is set to retain normal behavior when the
 410            program is executed directly; and take note of PERSIST_MAX. */
 411         if (getenv("AFL_PERSISTENT") && persist_cnt++ < PERSIST_MAX)
 412         {
 413             raise(SIGSTOP);
 414             goto try_again;
 415         }
 416
 417         /* If AFL_PERSISTENT not set or PERSIST_MAX exceeded, exit normally. */
 418     }
 419     catch (...)
 420     {
 421         abort();
 422     }
 423
 424     _exit(ret);
 425 }
 426
 427 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */