Ticket #4233: mythgame.diff

File mythgame.diff, 72.4 KB (added by ffelix@…, 14 years ago)

initial patch

  • dbcheck.cpp

    diff -ruN mythgame.old/dbcheck.cpp mythgame.new/dbcheck.cpp
    old new  
    1010
    1111#include "gamesettings.h"
    1212
    13 const QString currentDatabaseVersion = "1012";
     13const QString currentDatabaseVersion = "1013";
    1414
    1515static bool UpdateDBVersionNumber(const QString &newnumber)
    1616{
     
    8282"  gametype varchar(64) NOT NULL default '',"
    8383"  diskcount tinyint(1) NOT NULL default '1',"
    8484"  country varchar(128) NOT NULL default '',"
    85 "  crc_value varchar(64) NOT NULL default '',"
    8685"  display tinyint(1) NOT NULL default '1',"
    87 "  version varchar(64) NOT NULL default '',"
    8886"  KEY system (system),"
    8987"  KEY year (year),"
    9088"  KEY romname (romname),"
     
    104102"  PRIMARY KEY  (gameplayerid),"
    105103"  UNIQUE KEY playername (playername)"
    106104");",
    107 "CREATE TABLE romdb ("
    108 crc varchar(64) NOT NULL default '',"
    109 name varchar(128) NOT NULL default '',"
    110 description varchar(128) NOT NULL default '',"
    111 category varchar(128) NOT NULL default '',"
     105"CREATE TABLE gamedb ("
     106gametype varchar(128) NOT NULL default '',"
     107romname varchar(128) NOT NULL default '',"
     108gamename varchar(128) NOT NULL default '',"
     109genre varchar(128) NOT NULL default '',"
    112110"  year varchar(10) NOT NULL default '',"
    113 "  manufacturer varchar(128) NOT NULL default '',"
    114 "  country varchar(128) NOT NULL default '',"
    115111"  publisher varchar(128) NOT NULL default '',"
    116 "  platform varchar(64) NOT NULL default '',"
    117 "  filesize int(12) default NULL,"
    118 "  flags varchar(64) NOT NULL default '',"
    119 "  version varchar(64) NOT NULL default '',"
    120 "  KEY crc (crc),"
    121 "  KEY year (year),"
    122 "  KEY category (category),"
    123 "  KEY name (name),"
    124 "  KEY description (description),"
    125 "  KEY platform (platform)"
     112"  country varchar(128) NOT NULL default '',"
     113"  KEY gametype (gametype)"
    126114");",
    127115""
    128116};
     
    290278            return false;
    291279    }
    292280
     281    if (dbver == "1012")
     282    {
     283        const QString updates[] = {
     284"CREATE TABLE gamedb ("
     285"  gametype varchar(128) NOT NULL default '',"
     286"  romname varchar(128) NOT NULL default '',"
     287"  gamename varchar(128) NOT NULL default '',"
     288"  genre varchar(128) NOT NULL default '',"
     289"  year varchar(10) NOT NULL default '',"
     290"  publisher varchar(128) NOT NULL default '',"
     291"  country varchar(128) NOT NULL default '',"
     292"  KEY gametype (gametype)"
     293");",
     294"ALTER TABLE `gamemetadata` DROP `crc_value`;",
     295"ALTER TABLE `gamemetadata` DROP `version`;",
     296""
     297};
     298
     299        if (!performActualUpdate(updates, "1013", dbver))
     300            return false;
     301    }
     302
    293303
    294304    return true;
    295305}
  • gamehandler.cpp

    diff -ruN mythgame.old/gamehandler.cpp mythgame.new/gamehandler.cpp
    old new  
    102102    QString key;
    103103
    104104    MSqlQuery query(MSqlQuery::InitCon());
    105     QString thequery = QString("SELECT crc, category, year, country, name, "
    106                                "description, publisher, platform, version, "
    107                                "binfile FROM romdb WHERE platform = '%1';")
     105    QString thequery = QString("SELECT romname, gamename, genre, "
     106                               "year, publisher, country "
     107                               "FROM gamedb WHERE gametype = '%1';")
    108108                              .arg(GameType);
    109109    query.exec(thequery);
    110110
     
    112112    {
    113113        while (query.next())
    114114        {
    115             key = QString("%1:%2")
    116                   .arg(query.value(0).toString())
    117                   .arg(query.value(9).toString());
     115            key = QString("%1")
     116                  .arg(query.value(0).toString());
     117
    118118            romDB[key] = RomData(
    119119                                         query.value(1).toString(),
    120120                                         query.value(2).toString(),
    121121                                         query.value(3).toString(),
    122122                                         query.value(4).toString(),
    123                                          query.value(5).toString(),
    124                                          query.value(6).toString(),
    125                                          query.value(7).toString(),
    126                                          query.value(8).toString());
     123                                         query.value(5).toString());
    127124        }
    128125    }
    129126
     
    135132}
    136133
    137134void GameHandler::GetMetadata(GameHandler *handler, QString rom, QString* Genre, QString* Year,
    138                               QString* Country, QString* CRC32, QString* GameName,
    139                               QString *Publisher, QString *Version)
     135                              QString* Country, QString* GameName,
     136                              QString *Publisher)
    140137{
    141     QString key;
    142     QString tmpcrc;
    143 
    144     *CRC32 = crcinfo(rom, handler->GameType(), &key, &romDB);
    145 
    146     //cerr << "Key = " << key << endl;
    147 
    148138    // Set our default values
    149139    *Year = QObject::tr("19xx");
    150140    *Country = QObject::tr("Unknown");
    151141    *GameName = QObject::tr("Unknown");
    152142    *Genre = QObject::tr("Unknown");
    153143    *Publisher = QObject::tr("Unknown");
    154     *Version = QObject::tr("0");
    155144
    156     if (*CRC32 != "")
     145    if (romDB.contains(rom))
    157146    {
    158         if (romDB.contains(key))
    159         {
    160             //cerr << "ROMDB FOUND for " << romDB[key].GameName() << endl;
    161             *Year = romDB[key].Year();
    162             *Country = romDB[key].Country();
    163             *Genre = romDB[key].Genre();
    164             *Publisher = romDB[key].Publisher();
    165             *GameName = romDB[key].GameName();
    166             *Version = romDB[key].Version();
    167         }
    168         //else cerr << "NO ROMDB FOUND for " << rom << endl;
    169 
    170     };
     147        //cerr << "ROMDB FOUND for " << romDB[rom].GameName() << endl;
     148        *GameName = romDB[rom].GameName();
     149        *Genre = romDB[rom].Genre();
     150        *Year = romDB[rom].Year();
     151        *Publisher = romDB[rom].Publisher();
     152        *Country = romDB[rom].Country();
     153    }
    171154
    172155    if (*Genre == "Unknown")
    173156        *Genre = QString("Unknown%1").arg( handler->GameType() );
     
    371354    QString GameName;
    372355    QString Genre;
    373356    QString Country;
    374     QString CRC32;
    375357    QString thequery;
    376358    QString queryvalues;
    377359    QString Year;
    378360    QString Publisher;
    379     QString Version;
    380361
    381362    int removalprompt = gContext->GetSetting("GameRemovalPrompt").toInt();
    382     int indepth = gContext->GetSetting("GameDeepScan").toInt();
    383363
    384364    for (iter = m_GameMap.begin(); iter != m_GameMap.end(); iter++)
    385365    {
    386366
    387367        if (iter.data().FoundLoc() == inFileSystem)
    388368        {
    389             if (indepth)
    390             {
    391                 GetMetadata(handler, iter.data().RomFullPath(), &Genre, &Year, &Country, &CRC32, &GameName,
    392                             &Publisher, &Version);
    393             }
    394             else
    395             {
    396                 Genre = QObject::tr( QString("Unknown%1").arg( handler->GameType() ));
    397                 Country = QObject::tr("Unknown");
    398                 CRC32 = "";
    399                 Year = QObject::tr("19xx");
    400                 GameName = QObject::tr("Unknown");
    401                 Publisher = QObject::tr("Unknown");
    402                 Version = QObject::tr("0");
    403             }
     369            GetMetadata(handler, iter.data().Rom(), &Genre, &Year, &Country, &GameName,
     370                        &Publisher);
    404371
    405372            if (GameName == QObject::tr("Unknown"))
    406373                GameName = iter.data().GameName();
     
    408375                // Put the game into the database.
    409376                // Had to break the values up into 2 pieces since QString only allows 9 arguments and we had 10
    410377
    411             thequery = QString("INSERT INTO gamemetadata "
    412                                "(system, romname, gamename, genre, year, gametype, rompath, country, crc_value,"
    413                                " diskcount, display, publisher, version) ");
    414             queryvalues = QString ("VALUES ('%1', '%2', '%3', '%4', '%5', '%6',")
    415                 .arg(handler->SystemName())
    416                 .arg(iter.data().Rom().latin1())
    417                 .arg(GameName.latin1())
    418                 .arg(Genre.latin1())
    419                 .arg(Year.latin1())
    420                 .arg(handler->GameType());
    421 
    422             queryvalues.append( QString("'%1', '%2', '%3', 1 ,'1', '%4', '%5');")
    423                 .arg(iter.data().RomPath().latin1())
    424                 .arg(Country.latin1())
    425                 .arg(CRC32)
    426                 .arg(Publisher)
    427                 .arg(Version));
    428378
    429             thequery.append(queryvalues);
     379            thequery = QString("INSERT INTO gamemetadata "                                                                                                                         
     380                               "(system, romname, gamename, genre, year, gametype, rompath, country,"                                                                   
     381                               " diskcount, display, publisher) ");                                                                                                       
     382            queryvalues = QString ("VALUES ('%1', '%2', '%3', '%4', '%5', '%6',")                                                                                                   
     383                .arg(handler->SystemName())                                                                                                                                         
     384                .arg(iter.data().Rom().latin1())                                                                                                                                   
     385                .arg(GameName.latin1())                                                                                                                                             
     386                .arg(Genre.latin1())                                                                                                                                               
     387                .arg(Year.latin1())                                                                                                                                                 
     388                .arg(handler->GameType());                                                                                                                                         
     389                                                                                                                                                                                   
     390            queryvalues.append( QString("'%1', '%2', 1, 1, '%3');")
     391                .arg(iter.data().RomPath().latin1())                                                                                                                               
     392                .arg(Country.latin1())                                                                                                                                             
     393                .arg(Publisher.latin1()));                                                                                                                                                     
     394
     395
     396            thequery.append(queryvalues);                                                                                                                                           
     397            cerr << "SQL " << thequery << endl;
    430398            query.exec(thequery);
    431399        }
    432400        else if ((iter.data().FoundLoc() == inDatabase) && (removalprompt))
  • gamehandler.h

    diff -ruN mythgame.old/gamehandler.h mythgame.new/gamehandler.h
    old new  
    7070    void InitMetaDataMap(QString GameType);
    7171    void GetMetadata(GameHandler *handler, QString rom,
    7272                             QString* Genre, QString* Year, QString* Country,
    73                              QString* CRC32, QString* GameName,
    74                              QString* Publisher, QString* Version);
     73                             QString* GameName,
     74                             QString* Publisher);
    7575
    7676    void promptForRemoval(QString filename, QString RomPath );
    7777    void UpdateGameDB(GameHandler *handler);
  • gamesettings.cpp

    diff -ruN mythgame.old/gamesettings.cpp mythgame.new/gamesettings.cpp
    old new  
    4747    return gc;
    4848}
    4949
    50 static HostCheckBox *GameDeepScan()
    51 {   
    52     HostCheckBox *gc = new HostCheckBox("GameDeepScan");
    53     gc->setLabel(QObject::tr("Indepth Game Scan"));
    54     gc->setHelpText(QObject::tr("Enabling this causes a game scan to gather crc values and attempt to find out more"
    55                     " detailed information about the game: NOTE this can greatly increase the time a gamescan takes"
    56                     " based on the amount of games scanned."));
    57     return gc;
    58 }   
    59 
    6050static HostCheckBox *GameRemovalPrompt()
    6151{
    6252    HostCheckBox *gc = new HostCheckBox("GameRemovalPrompt");
     
    6454    gc->setHelpText(QObject::tr("This enables a prompt for removing"
    6555                                " deleted roms from the database during a "
    6656                                " gamescan"));
    67    
     57
    6858    return gc;
    6959}
    7060
    7161static HostCheckBox *GameShowFileNames()
    72 { 
     62{
    7363    HostCheckBox *gc = new HostCheckBox("GameShowFileNames");
    7464    gc->setLabel(QObject::tr("Display Files Names in Game Tree"));
    7565    gc->setHelpText(QObject::tr("Enabling this causes the filenames to be displayed in the game tree rather than the trimmed/looked up gamename"));
    7666    return gc;
    77 }   
     67}
    7868
    7969static HostCheckBox *GameTreeView()
    8070{
     
    9181    general->setLabel(QObject::tr("MythGame Settings -- General"));
    9282    general->addChild(GameAllTreeLevels());
    9383    general->addChild(GameFavTreeLevels());
    94     general->addChild(GameDeepScan());
    9584    general->addChild(GameRemovalPrompt());
    9685    general->addChild(GameShowFileNames());
    9786    general->addChild(GameTreeView());
     
    210199{
    211200    // must be first
    212201    addChild(id = new ID());
    213    
     202
    214203    ConfigurationGroup *group = new VerticalConfigurationGroup(false, false);
    215204    group->setLabel(QObject::tr("Game Player Setup"));
    216205    group->addChild(name = new Name(*this));
     
    279268void MythGamePlayerEditor::menu(void)
    280269{
    281270    if (!listbox->getValue().toUInt())
    282     {   
     271    {
    283272        MythGamePlayerSettings gp;
    284273        gp.exec();
    285274    }
    286275    else
    287     {   
     276    {
    288277        DialogCode val = MythPopupBox::Show2ButtonPopup(
    289278            gContext->GetMainWindow(),
    290279            "", tr("Game Player Menu"),
    291280            tr("Edit.."), tr("Delete.."), kDialogCodeButton1);
    292        
     281
    293282        if (kDialogCodeButton0 == val)
    294283            edit();
    295284        else if (kDialogCodeButton1 == val)
     
    298287}
    299288
    300289void MythGamePlayerEditor::edit(void)
    301 {   
     290{
    302291    MythGamePlayerSettings gp;
    303292
    304293    uint sourceid = listbox->getValue().toUInt();
     
    327316        if (!query.exec() || !query.isActive())
    328317            MythContext::DBError("Deleting MythGamePlayerSettings:", query);
    329318
    330         load(); 
     319        load();
    331320    }
    332321}
    333322
  • gametree.cpp

    diff -ruN mythgame.old/gametree.cpp mythgame.new/gametree.cpp
    old new  
    403403    info_popup->addLabel(QString("Name: %1 (%2)")
    404404                         .arg(rom->Gamename()).arg(rom->GameType()));
    405405    info_popup->addLabel(QString("Rom : %1").arg(rom->Romname()));
    406     info_popup->addLabel(QString("CRC : %1").arg(rom->CRC_VALUE()));
    407406    info_popup->addLabel(QString("Path: %1").arg(rom->Rompath()));
    408407    //info_popup->addLabel(QString("Type: %1").arg(rom->GameType()));
    409408    info_popup->addLabel(QString("Genre: %1").arg(rom->Genre()));
  • mythgame.pro

    diff -ruN mythgame.old/mythgame.pro mythgame.new/mythgame.pro
    old new  
    1515INSTALLS += uifiles installfiles
    1616
    1717# Input
    18 HEADERS += gamehandler.h rominfo.h unzip.h gamesettings.h gametree.h
     18HEADERS += gamehandler.h rominfo.h gamesettings.h gametree.h
    1919HEADERS += rom_metadata.h romedit.h
    2020
    21 SOURCES += main.cpp gamehandler.cpp rominfo.cpp gametree.cpp unzip.c
    22 SOURCES += gamesettings.cpp dbcheck.cpp rom_metadata.cpp romedit.cpp
     21SOURCES += main.cpp gamehandler.cpp rominfo.cpp gametree.cpp
     22SOURCES += gamesettings.cpp dbcheck.cpp romedit.cpp
    2323
    2424macx {
    2525    QMAKE_LFLAGS += -flat_namespace -undefined suppress
  • rominfo.cpp

    diff -ruN mythgame.old/rominfo.cpp mythgame.new/rominfo.cpp
    old new  
    1717void RomInfo::edit_rominfo()
    1818{
    1919
    20     QString rom_ver = Version();
    21 
    2220    GameEditDialog romeditdlg(Romname().latin1());
    2321
    2422    DialogCode res = romeditdlg.exec();
     
    4745            t_country = query.value(3).toString();
    4846            t_publisher = query.value(4).toString();
    4947            t_favourite = query.value(5).toBool();
    50    
    51             if ((t_gamename != Gamename()) || (t_genre != Genre()) || (t_year != Year())
    52                || (t_country != Country()) || (t_publisher != Publisher()) || (t_favourite != Favorite()))
    53             {
    54                 thequery = QString("UPDATE gamemetadata SET version = '%1' WHERE gametype = '%2' AND romname = '%3';")
    55                                    .arg(QString("CUSTOM"))
    56                                    .arg(GameType())
    57                                    .arg(Romname());
    58 
    59                 query.exec(thequery);
    60             }
    6148        }
    6249   }
    6350}
     
    132119        rompath = data;
    133120    else if (field == "country")
    134121        country = data;
    135     else if (field == "crc_value")
    136         crc_value = data;
    137122    else if (field == "diskcount")
    138123        diskcount = data.toInt();
    139124    else if (field == "gametype")
     
    176161    }
    177162
    178163    QString thequery = "SELECT system,gamename,genre,year,romname,favorite,"
    179                        "rompath,country,crc_value,diskcount,gametype,publisher,"
    180                        "version FROM gamemetadata WHERE gamename='"
     164                       "rompath,country,diskcount,gametype,publisher"
     165                       " FROM gamemetadata WHERE gamename='"
    181166                       + gamename + "'";
    182167
    183168    if (system != "")
     
    203188        setField("favorite",query.value(5).toString());
    204189        setRompath(query.value(6).toString());
    205190        setCountry(query.value(7).toString());
    206         setCRC_VALUE(query.value(8).toString());
    207         setDiskCount(query.value(9).toInt());
    208         setGameType(query.value(10).toString());
    209         setPublisher(query.value(11).toString());
    210         setVersion(query.value(12).toString());
     191        setDiskCount(query.value(8).toInt());
     192        setGameType(query.value(9).toString());
     193        setPublisher(query.value(10).toString());
    211194    }
    212195
    213196    thequery = "SELECT screenshots FROM gameplayers WHERE playername = '" + system + "';";
  • rominfo.h

    diff -ruN mythgame.old/rominfo.h mythgame.new/rominfo.h
    old new  
    1010  public:
    1111    RomInfo(QString lromname = "", QString lsystem = "", QString lgamename ="",
    1212            QString lgenre = "", QString lyear = "", bool lfavorite = FALSE,
    13             QString lrompath = "", QString lcountry ="", QString lcrc_value = "",
     13            QString lrompath = "", QString lcountry ="",
    1414            int ldiskcount = 0, QString lgametype = "", int lromcount = 0,
    15             QString lallsystems = "", QString lpublisher = "", QString lversion = "")
     15            QString lallsystems = "", QString lpublisher = "")
    1616            {
    1717                romname = lromname;
    1818                system = lsystem;
     
    2222                favorite = lfavorite;
    2323                rompath = lrompath;
    2424                country = lcountry;
    25                 crc_value = lcrc_value;
    2625                diskcount = ldiskcount;
    2726                gametype = lgametype;
    2827                romcount = lromcount;
    2928                allsystems = lallsystems;
    3029                publisher = lpublisher;
    31                 version = lversion;
    3230            }
    3331
    3432    RomInfo(const RomInfo &lhs)
     
    4139                favorite = lhs.favorite;
    4240                rompath = lhs.rompath;
    4341                country = lhs.country;
    44                 crc_value = lhs.crc_value;
    4542                diskcount = lhs.diskcount;
    4643                gametype = lhs.gametype;
    4744                romcount = lhs.romcount;
    4845                allsystems = lhs.allsystems;
    4946                publisher = lhs.publisher;
    50                 version = lhs.version;
    5147            }
    5248
    5349    virtual ~RomInfo() {}
     
    8480    int DiskCount() { return diskcount; }
    8581    void setDiskCount(const int &ldiskcount) { diskcount = ldiskcount; }
    8682
    87     QString CRC_VALUE() { return crc_value; }
    88     void setCRC_VALUE(const QString &lcrc_value) { crc_value = lcrc_value; }
    89 
    9083    QString ImagePath() { return imagepath; }
    9184    void setImagePath(const QString &limagepath) { imagepath = limagepath; }
    9285
    9386    QString Publisher() { return publisher; }
    9487    void setPublisher(const QString &lpublisher) { publisher = lpublisher; }
    9588
    96     QString Version() { return version; }
    97     void setVersion(const QString &lversion) { version = lversion; }
    98 
    9989
    10090    QString Year() { return year; }
    10191    void setYear(const QString &lyear) { year = lyear; }
     
    116106    QString genre;
    117107    QString imagepath;
    118108    QString country;
    119     QString crc_value;
    120109    QString gametype;
    121110    QString allsystems;
    122111    QString publisher;
    123     QString version;
    124112    int romcount;
    125113    int diskcount;
    126114    QString year;
  • rom_metadata.cpp

    diff -ruN mythgame.old/rom_metadata.cpp mythgame.new/rom_metadata.cpp
    old new  
    1 #include <qobject.h>
    2 #include <qptrlist.h>
    3 #include <qstringlist.h>
    4 #include <iostream>
    5 #include <qdir.h>
    6 #include <qstring.h>
    7 #include <qwidget.h>
    8 
    9 
    10 #include <mythtv/mythcontext.h>
    11 #include <mythtv/mythdbcon.h>
    12 #include <mythtv/mythdialogs.h>
    13 
    14 #include "rom_metadata.h"
    15 #include "unzip.h"
    16 
    17 int calcOffset(QString GameType, uLong filesize) {
    18     int result;
    19     uLong rom_size;
    20 
    21     result = 0;
    22 
    23     if (GameType == "NES") {
    24         result = 16;
    25     }
    26     else if (GameType == "SNES") {
    27          rom_size = (filesize / 0x2000) * 0x2000;
    28 
    29          if (rom_size < filesize)
    30              result = filesize - rom_size;
    31     }
    32     else if (GameType == "PCE") {
    33          if (filesize & 0x0FFF)
    34              result = filesize & 0x0FFF;
    35 
    36     }
    37 
    38     return result;
    39 }
    40 
    41 QString crcStr(uLong crc) {
    42     QString tmpcrc("");
    43 
    44     tmpcrc = QString("%1").arg( crc, 0, 16 );
    45     if (tmpcrc == "0")
    46         tmpcrc = "";
    47     else
    48         tmpcrc = tmpcrc.rightJustify( 8,'0');
    49 
    50     return tmpcrc;
    51 }
    52 
    53 // Return the crc32 info for this rom. (ripped mostly from the old neshandler.cpp source)
    54 QString crcinfo(QString romname, QString GameType, QString *key, RomDBMap *romDB)
    55 {
    56     // Get CRC of file
    57     char block[32768];
    58     uLong crc = crc32(0, Z_NULL, 0);
    59     QString crcRes;
    60     char filename_inzip[256];
    61     unz_file_info file_info;   
    62     int err;
    63     int offset;
    64     unzFile zf;
    65     int blocksize;
    66 
    67     blocksize = 8192;
    68 
    69     if ((zf = unzOpen(romname)))
    70     {
    71         int FoundFile;
    72         for (FoundFile = unzGoToFirstFile(zf); FoundFile == UNZ_OK;
    73              FoundFile = unzGoToNextFile(zf))
    74         {
    75             if (unzOpenCurrentFile(zf) == UNZ_OK)
    76             {
    77                 err = unzGetCurrentFileInfo(zf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
    78 
    79                 offset = calcOffset(GameType, file_info.uncompressed_size);
    80 
    81                 if (offset > 0)
    82                     unzReadCurrentFile(zf, block, offset);
    83 
    84                 // Get CRC of rom data
    85                 int count;
    86                 while ((count = unzReadCurrentFile(zf, block, blocksize)) > 0)
    87                 {
    88                     crc = crc32(crc, (Bytef *)block, (uInt)count);
    89                 }   
    90                 crcRes = crcStr(crc);
    91                 *key = QString("%1:%2")
    92                              .arg(crcRes)
    93                              .arg(filename_inzip);
    94 
    95                 if (romDB->contains(*key))
    96                 {
    97                     unzCloseCurrentFile(zf);
    98                     break;
    99                 }
    100 
    101                 unzCloseCurrentFile(zf);
    102             }   
    103         }   
    104         unzClose(zf);
    105     }   
    106     else
    107     {
    108         QFile f(romname);
    109 
    110         if (f.open(IO_ReadOnly))
    111         {
    112             offset = calcOffset(GameType, f.size());
    113 
    114             if (offset > 0)
    115                 f.readBlock(block, offset);
    116 
    117             // Get CRC of rom data
    118             Q_LONG count;
    119             while ((count = f.readBlock(block, blocksize)) > 0)
    120             {
    121                 crc = crc32(crc, (Bytef *)block, (uInt)count);
    122             }   
    123 
    124             crcRes = crcStr(crc);
    125             *key = QString("%1:").arg(crcRes);
    126             f.close();
    127         }   
    128     }   
    129 
    130     return crcRes;
    131 }
    132 
  • rom_metadata.h

    diff -ruN mythgame.old/rom_metadata.h mythgame.new/rom_metadata.h
    old new  
    1414#include <mythtv/mythdbcon.h>
    1515#include <mythtv/mythdialogs.h>
    1616
    17 #include "unzip.h"
    18 
    1917class RomData
    2018{
    2119public:
    22     RomData(QString lgenre = "", QString lyear = "",
    23             QString lcountry = "", QString lgamename = "",
    24             QString ldescription = "", QString lpublisher = "",
    25             QString lplatform = "", QString lversion = ""  )
     20    RomData(QString lgamename = "", QString lgenre = "", QString lyear = "",
     21            QString lpublisher = "", QString lcountry = "" )
    2622            {
     23                gamename = lgamename;
    2724                genre = lgenre;
    2825                year = lyear;
    29                 country = lcountry;
    30                 gamename = lgamename;
    31                 description = ldescription;
    3226                publisher = lpublisher;
    33                 platform = lplatform;
    34                 version = lversion;
     27                country = lcountry;
    3528            }
    3629
     30    QString GameName() const { return gamename; }
    3731    QString Genre() const { return genre; }
    3832    QString Year() const { return year; }
    39     QString Country() const { return country; }
    40     QString GameName() const { return gamename; }
    41     QString Description() const { return description; }
    4233    QString Publisher() const { return publisher; }
    43     QString Platform() const { return platform; }
    44     QString Version() const { return version; }
     34    QString Country() const { return country; }
    4535
    4636private:
     37    QString gamename;
    4738    QString genre;
    4839    QString year;
    49     QString country;
    50     QString gamename;
    51     QString description;
    5240    QString publisher;
    53     QString platform;
    54     QString version;
     41    QString country;
    5542};
    5643
    5744typedef QMap <QString, RomData> RomDBMap;
    5845
    59 QString crcStr(int crc);
    60 
    61 QString crcinfo(QString romname, QString GameType, QString *key, RomDBMap *romDB);
    62 
    6346#endif
  • mythgame.

    diff -ruN mythgame.old/unzip.c mythgame.new/unzip.c
    old new  
    1 /* unzip.c -- IO on .zip files using zlib
    2    Version 0.15 beta, Mar 19th, 1998,
    3 
    4    Read unzip.h for more info
    5 */
    6 
    7 
    8 #include <stdio.h>
    9 #include <stdlib.h>
    10 #include <string.h>
    11 #include "zlib.h"
    12 #include "unzip.h"
    13 
    14 #ifdef STDC
    15 #  include <stddef.h>
    16 #  include <string.h>
    17 #  include <stdlib.h>
    18 #endif
    19 #ifdef NO_ERRNO_H
    20     extern int errno;
    21 #else
    22 #   include <errno.h>
    23 #endif
    24 
    25 
    26 #ifndef local
    27 #  define local static
    28 #endif
    29 /* compile with -Dlocal if your debugger can't find static symbols */
    30 
    31 
    32 
    33 #if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
    34                       !defined(CASESENSITIVITYDEFAULT_NO)
    35 #define CASESENSITIVITYDEFAULT_NO
    36 #endif
    37 
    38 
    39 #ifndef UNZ_BUFSIZE
    40 #define UNZ_BUFSIZE (16384)
    41 #endif
    42 
    43 #ifndef UNZ_MAXFILENAMEINZIP
    44 #define UNZ_MAXFILENAMEINZIP (256)
    45 #endif
    46 
    47 #ifndef ALLOC
    48 # define ALLOC(size) (malloc(size))
    49 #endif
    50 #ifndef TRYFREE
    51 # define TRYFREE(p) {if (p) free(p);}
    52 #endif
    53 
    54 #define SIZECENTRALDIRITEM (0x2e)
    55 #define SIZEZIPLOCALHEADER (0x1e)
    56 
    57 
    58 /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
    59 
    60 #ifndef SEEK_CUR
    61 #define SEEK_CUR    1
    62 #endif
    63 
    64 #ifndef SEEK_END
    65 #define SEEK_END    2
    66 #endif
    67 
    68 #ifndef SEEK_SET
    69 #define SEEK_SET    0
    70 #endif
    71 
    72 const char unz_copyright[] =
    73    " unzip 0.15 Copyright 1998 Gilles Vollant ";
    74 
    75 /* unz_file_info_interntal contain internal info about a file in zipfile*/
    76 typedef struct unz_file_info_internal_s
    77 {
    78     uLong offset_curfile;/* relative offset of local header 4 bytes */
    79 } unz_file_info_internal;
    80 
    81 
    82 /* file_in_zip_read_info_s contain internal information about a file in zipfile,
    83     when reading and decompress it */
    84 typedef struct
    85 {
    86         char  *read_buffer;         /* internal buffer for compressed data */
    87         z_stream stream;            /* zLib stream structure for inflate */
    88 
    89         uLong pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
    90         uLong stream_initialised;   /* flag set if stream structure is initialised*/
    91 
    92         uLong offset_local_extrafield;/* offset of the local extra field */
    93         uInt  size_local_extrafield;/* size of the local extra field */
    94         uLong pos_local_extrafield;   /* position in the local extra field in read*/
    95 
    96         uLong crc32;                /* crc32 of all data uncompressed */
    97         uLong crc32_wait;           /* crc32 we must obtain after decompress all */
    98         uLong rest_read_compressed; /* number of byte to be decompressed */
    99         uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
    100         FILE* file;                 /* io structore of the zipfile */
    101         uLong compression_method;   /* compression method (0==store) */
    102         uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
    103 } file_in_zip_read_info_s;
    104 
    105 
    106 /* unz_s contain internal information about the zipfile
    107 */
    108 typedef struct
    109 {
    110         FILE* file;                 /* io structore of the zipfile */
    111         unz_global_info gi;       /* public global information */
    112         uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
    113         uLong num_file;             /* number of the current file in the zipfile*/
    114         uLong pos_in_central_dir;   /* pos of the current file in the central dir*/
    115         uLong current_file_ok;      /* flag about the usability of the current file*/
    116         uLong central_pos;          /* position of the beginning of the central dir*/
    117 
    118         uLong size_central_dir;     /* size of the central directory  */
    119         uLong offset_central_dir;   /* offset of start of central directory with
    120                                                                    respect to the starting disk number */
    121 
    122         unz_file_info cur_file_info; /* public info about the current file in zip*/
    123         unz_file_info_internal cur_file_info_internal; /* private info about it*/
    124     file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
    125                                             file if we are decompressing it */
    126 } unz_s;
    127 
    128 
    129 /* ===========================================================================
    130      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
    131    for end of file.
    132    IN assertion: the stream s has been sucessfully opened for reading.
    133 */
    134 
    135 
    136 local int unzlocal_getByte(fin,pi)
    137         FILE *fin;
    138         int *pi;
    139 {
    140     unsigned char c;
    141         int err = fread(&c, 1, 1, fin);
    142     if (err==1)
    143     {
    144         *pi = (int)c;
    145         return UNZ_OK;
    146     }
    147     else
    148     {
    149         if (ferror(fin))
    150             return UNZ_ERRNO;
    151         else
    152             return UNZ_EOF;
    153     }
    154 }
    155 
    156 
    157 /* ===========================================================================
    158    Reads a long in LSB order from the given gz_stream. Sets
    159 */
    160 local int unzlocal_getShort (fin,pX)
    161         FILE* fin;
    162     uLong *pX;
    163 {
    164     uLong x ;
    165     int i = 0;
    166     int err;
    167 
    168     err = unzlocal_getByte(fin,&i);
    169     x = (uLong)i;
    170    
    171     if (err==UNZ_OK)
    172         err = unzlocal_getByte(fin,&i);
    173     x += ((uLong)i)<<8;
    174    
    175     if (err==UNZ_OK)
    176         *pX = x;
    177     else
    178         *pX = 0;
    179     return err;
    180 }
    181 
    182 local int unzlocal_getLong (fin,pX)
    183         FILE* fin;
    184     uLong *pX;
    185 {
    186     uLong x ;
    187     int i = 0;
    188     int err;
    189 
    190     err = unzlocal_getByte(fin,&i);
    191     x = (uLong)i;
    192    
    193     if (err==UNZ_OK)
    194         err = unzlocal_getByte(fin,&i);
    195     x += ((uLong)i)<<8;
    196 
    197     if (err==UNZ_OK)
    198         err = unzlocal_getByte(fin,&i);
    199     x += ((uLong)i)<<16;
    200 
    201     if (err==UNZ_OK)
    202         err = unzlocal_getByte(fin,&i);
    203     x += ((uLong)i)<<24;
    204    
    205     if (err==UNZ_OK)
    206         *pX = x;
    207     else
    208         *pX = 0;
    209     return err;
    210 }
    211 
    212 
    213 /* My own strcmpi / strcasecmp */
    214 local int strcmpcasenosensitive_internal (fileName1,fileName2)
    215         const char* fileName1;
    216         const char* fileName2;
    217 {
    218         for (;;)
    219         {
    220                 char c1=*(fileName1++);
    221                 char c2=*(fileName2++);
    222                 if ((c1>='a') && (c1<='z'))
    223                         c1 -= 0x20;
    224                 if ((c2>='a') && (c2<='z'))
    225                         c2 -= 0x20;
    226                 if (c1=='\0')
    227                         return ((c2=='\0') ? 0 : -1);
    228                 if (c2=='\0')
    229                         return 1;
    230                 if (c1<c2)
    231                         return -1;
    232                 if (c1>c2)
    233                         return 1;
    234         }
    235 }
    236 
    237 
    238 #ifdef  CASESENSITIVITYDEFAULT_NO
    239 #define CASESENSITIVITYDEFAULTVALUE 2
    240 #else
    241 #define CASESENSITIVITYDEFAULTVALUE 1
    242 #endif
    243 
    244 #ifndef STRCMPCASENOSENTIVEFUNCTION
    245 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
    246 #endif
    247 
    248 /*
    249    Compare two filename (fileName1,fileName2).
    250    If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
    251    If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
    252                                                                 or strcasecmp)
    253    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
    254         (like 1 on Unix, 2 on Windows)
    255 
    256 */
    257 extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
    258         const char* fileName1;
    259         const char* fileName2;
    260         int iCaseSensitivity;
    261 {
    262         if (iCaseSensitivity==0)
    263                 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
    264 
    265         if (iCaseSensitivity==1)
    266                 return strcmp(fileName1,fileName2);
    267 
    268         return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
    269 }
    270 
    271 #define BUFREADCOMMENT (0x400)
    272 
    273 /*
    274   Locate the Central directory of a zipfile (at the end, just before
    275     the global comment)
    276 */
    277 local uLong unzlocal_SearchCentralDir(fin)
    278         FILE *fin;
    279 {
    280         unsigned char* buf;
    281         uLong uSizeFile;
    282         uLong uBackRead;
    283         uLong uMaxBack=0xffff; /* maximum size of global comment */
    284         uLong uPosFound=0;
    285        
    286         if (fseek(fin,0,SEEK_END) != 0)
    287                 return 0;
    288 
    289 
    290         uSizeFile = ftell( fin );
    291        
    292         if (uMaxBack>uSizeFile)
    293                 uMaxBack = uSizeFile;
    294 
    295         buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
    296         if (buf==NULL)
    297                 return 0;
    298 
    299         uBackRead = 4;
    300         while (uBackRead<uMaxBack)
    301         {
    302                 uLong uReadSize,uReadPos ;
    303                 int i;
    304                 if (uBackRead+BUFREADCOMMENT>uMaxBack)
    305                         uBackRead = uMaxBack;
    306                 else
    307                         uBackRead+=BUFREADCOMMENT;
    308                 uReadPos = uSizeFile-uBackRead ;
    309                
    310                 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
    311                      (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
    312                 if (fseek(fin,uReadPos,SEEK_SET)!=0)
    313                         break;
    314 
    315                 if (fread(buf,(uInt)uReadSize,1,fin)!=1)
    316                         break;
    317 
    318                 for (i=(int)uReadSize-3; (i--)>0;)
    319                         if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
    320                                 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
    321                         {
    322                                 uPosFound = uReadPos+i;
    323                                 break;
    324                         }
    325 
    326                 if (uPosFound!=0)
    327                         break;
    328         }
    329         TRYFREE(buf);
    330         return uPosFound;
    331 }
    332 
    333 /*
    334   Open a Zip file. path contain the full pathname (by example,
    335      on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
    336          "zlib/zlib109.zip".
    337          If the zipfile cannot be opened (file don't exist or in not valid), the
    338            return value is NULL.
    339      Else, the return value is a unzFile Handle, usable with other function
    340            of this unzip package.
    341 */
    342 extern unzFile ZEXPORT unzOpen (path)
    343         const char *path;
    344 {
    345         unz_s us;
    346         unz_s *s;
    347         uLong central_pos,uL;
    348         FILE * fin ;
    349 
    350         uLong number_disk;          /* number of the current dist, used for
    351                                                                    spaning ZIP, unsupported, always 0*/
    352         uLong number_disk_with_CD;  /* number the the disk with central dir, used
    353                                                                    for spaning ZIP, unsupported, always 0*/
    354         uLong number_entry_CD;      /* total number of entries in
    355                                        the central dir
    356                                        (same than number_entry on nospan) */
    357 
    358         int err=UNZ_OK;
    359 
    360     if (unz_copyright[0]!=' ')
    361         return NULL;
    362 
    363     fin=fopen(path,"rb");
    364         if (fin==NULL)
    365                 return NULL;
    366 
    367         central_pos = unzlocal_SearchCentralDir(fin);
    368         if (central_pos==0)
    369                 err=UNZ_ERRNO;
    370 
    371         if (fseek(fin,central_pos,SEEK_SET)!=0)
    372                 err=UNZ_ERRNO;
    373 
    374         /* the signature, already checked */
    375         if (unzlocal_getLong(fin,&uL)!=UNZ_OK)
    376                 err=UNZ_ERRNO;
    377 
    378         /* number of this disk */
    379         if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK)
    380                 err=UNZ_ERRNO;
    381 
    382         /* number of the disk with the start of the central directory */
    383         if (unzlocal_getShort(fin,&number_disk_with_CD)!=UNZ_OK)
    384                 err=UNZ_ERRNO;
    385 
    386         /* total number of entries in the central dir on this disk */
    387         if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK)
    388                 err=UNZ_ERRNO;
    389 
    390         /* total number of entries in the central dir */
    391         if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK)
    392                 err=UNZ_ERRNO;
    393 
    394         if ((number_entry_CD!=us.gi.number_entry) ||
    395                 (number_disk_with_CD!=0) ||
    396                 (number_disk!=0))
    397                 err=UNZ_BADZIPFILE;
    398 
    399         /* size of the central directory */
    400         if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK)
    401                 err=UNZ_ERRNO;
    402 
    403         /* offset of start of central directory with respect to the
    404               starting disk number */
    405         if (unzlocal_getLong(fin,&us.offset_central_dir)!=UNZ_OK)
    406                 err=UNZ_ERRNO;
    407 
    408         /* zipfile comment length */
    409         if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK)
    410                 err=UNZ_ERRNO;
    411 
    412         if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
    413                 (err==UNZ_OK))
    414                 err=UNZ_BADZIPFILE;
    415 
    416         if (err!=UNZ_OK)
    417         {
    418                 fclose(fin);
    419                 return NULL;
    420         }
    421 
    422         us.file=fin;
    423         us.byte_before_the_zipfile = central_pos -
    424                                     (us.offset_central_dir+us.size_central_dir);
    425         us.central_pos = central_pos;
    426     us.pfile_in_zip_read = NULL;
    427        
    428 
    429         s=(unz_s*)ALLOC(sizeof(unz_s));
    430         *s=us;
    431         unzGoToFirstFile((unzFile)s);   
    432         return (unzFile)s;     
    433 }
    434 
    435 
    436 /*
    437   Close a ZipFile opened with unzipOpen.
    438   If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
    439     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
    440   return UNZ_OK if there is no problem. */
    441 extern int ZEXPORT unzClose (file)
    442         unzFile file;
    443 {
    444         unz_s* s;
    445         if (file==NULL)
    446                 return UNZ_PARAMERROR;
    447         s=(unz_s*)file;
    448 
    449     if (s->pfile_in_zip_read!=NULL)
    450         unzCloseCurrentFile(file);
    451 
    452         fclose(s->file);
    453         TRYFREE(s);
    454         return UNZ_OK;
    455 }
    456 
    457 
    458 /*
    459   Write info about the ZipFile in the *pglobal_info structure.
    460   No preparation of the structure is needed
    461   return UNZ_OK if there is no problem. */
    462 extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
    463         unzFile file;
    464         unz_global_info *pglobal_info;
    465 {
    466         unz_s* s;
    467         if (file==NULL)
    468                 return UNZ_PARAMERROR;
    469         s=(unz_s*)file;
    470         *pglobal_info=s->gi;
    471         return UNZ_OK;
    472 }
    473 
    474 
    475 /*
    476    Translate date/time from Dos format to tm_unz (readable more easilty)
    477 */
    478 local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
    479     uLong ulDosDate;
    480     tm_unz* ptm;
    481 {
    482     uLong uDate;
    483     uDate = (uLong)(ulDosDate>>16);
    484     ptm->tm_mday = (uInt)(uDate&0x1f) ;
    485     ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
    486     ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
    487 
    488     ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
    489     ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
    490     ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
    491 }
    492 
    493 /*
    494   Get Info about the current file in the zipfile, with internal only info
    495 */
    496 local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
    497                                                   unz_file_info *pfile_info,
    498                                                   unz_file_info_internal
    499                                                   *pfile_info_internal,
    500                                                   char *szFileName,
    501                                                                                                   uLong fileNameBufferSize,
    502                                                   void *extraField,
    503                                                                                                   uLong extraFieldBufferSize,
    504                                                   char *szComment,
    505                                                                                                   uLong commentBufferSize));
    506 
    507 local int unzlocal_GetCurrentFileInfoInternal (file,
    508                                               pfile_info,
    509                                               pfile_info_internal,
    510                                               szFileName, fileNameBufferSize,
    511                                               extraField, extraFieldBufferSize,
    512                                               szComment,  commentBufferSize)
    513         unzFile file;
    514         unz_file_info *pfile_info;
    515         unz_file_info_internal *pfile_info_internal;
    516         char *szFileName;
    517         uLong fileNameBufferSize;
    518         void *extraField;
    519         uLong extraFieldBufferSize;
    520         char *szComment;
    521         uLong commentBufferSize;
    522 {
    523         unz_s* s;
    524         unz_file_info file_info;
    525         unz_file_info_internal file_info_internal;
    526         int err=UNZ_OK;
    527         uLong uMagic;
    528         long lSeek=0;
    529 
    530         if (file==NULL)
    531                 return UNZ_PARAMERROR;
    532         s=(unz_s*)file;
    533         if (fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0)
    534                 err=UNZ_ERRNO;
    535 
    536 
    537         /* we check the magic */
    538         if (err==UNZ_OK){
    539                 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK) {
    540                         err=UNZ_ERRNO;
    541                 } else if (uMagic!=0x02014b50) {
    542                         err=UNZ_BADZIPFILE;
    543                 }
    544         }
    545 
    546         if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK)
    547                 err=UNZ_ERRNO;
    548 
    549         if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK)
    550                 err=UNZ_ERRNO;
    551 
    552         if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK)
    553                 err=UNZ_ERRNO;
    554 
    555         if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK)
    556                 err=UNZ_ERRNO;
    557 
    558         if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK)
    559                 err=UNZ_ERRNO;
    560 
    561     unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
    562 
    563         if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK)
    564                 err=UNZ_ERRNO;
    565 
    566         if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK)
    567                 err=UNZ_ERRNO;
    568 
    569         if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK)
    570                 err=UNZ_ERRNO;
    571 
    572         if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK)
    573                 err=UNZ_ERRNO;
    574 
    575         if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK)
    576                 err=UNZ_ERRNO;
    577 
    578         if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK)
    579                 err=UNZ_ERRNO;
    580 
    581         if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK)
    582                 err=UNZ_ERRNO;
    583 
    584         if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK)
    585                 err=UNZ_ERRNO;
    586 
    587         if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK)
    588                 err=UNZ_ERRNO;
    589 
    590         if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK)
    591                 err=UNZ_ERRNO;
    592 
    593         lSeek+=file_info.size_filename;
    594         if ((err==UNZ_OK) && (szFileName!=NULL))
    595         {
    596                 uLong uSizeRead ;
    597                 if (file_info.size_filename<fileNameBufferSize)
    598                 {
    599                         *(szFileName+file_info.size_filename)='\0';
    600                         uSizeRead = file_info.size_filename;
    601                 } else {
    602                         uSizeRead = fileNameBufferSize;
    603                 }
    604 
    605                 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
    606                         if (fread(szFileName,(uInt)uSizeRead,1,s->file)!=1)
    607                                 err=UNZ_ERRNO;
    608                 lSeek -= uSizeRead;
    609         }
    610 
    611        
    612         if ((err==UNZ_OK) && (extraField!=NULL))
    613         {
    614                 uLong uSizeRead ;
    615                 if (file_info.size_file_extra<extraFieldBufferSize)
    616                         uSizeRead = file_info.size_file_extra;
    617                 else
    618                         uSizeRead = extraFieldBufferSize;
    619 
    620                 if (lSeek!=0) {
    621                         if (fseek(s->file,lSeek,SEEK_CUR)==0) {
    622                                 lSeek=0;
    623                         } else {
    624                                 err=UNZ_ERRNO;
    625                         }
    626                 }
    627                 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
    628                         if (fread(extraField,(uInt)uSizeRead,1,s->file)!=1)
    629                                 err=UNZ_ERRNO;
    630                 lSeek += file_info.size_file_extra - uSizeRead;
    631         }
    632         else
    633                 lSeek+=file_info.size_file_extra;
    634 
    635        
    636         if ((err==UNZ_OK) && (szComment!=NULL))
    637         {
    638                 uLong uSizeRead ;
    639                 if (file_info.size_file_comment<commentBufferSize)
    640                 {
    641                         *(szComment+file_info.size_file_comment)='\0';
    642                         uSizeRead = file_info.size_file_comment;
    643                 }
    644                 else
    645                         uSizeRead = commentBufferSize;
    646 
    647                 if (lSeek!=0) {
    648                         if (fseek(s->file,lSeek,SEEK_CUR)==0)
    649                             lSeek=0;
    650                         else
    651                             err=UNZ_ERRNO;
    652                 }
    653                 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
    654                         if (fread(szComment,(uInt)uSizeRead,1,s->file)!=1)
    655                                 err=UNZ_ERRNO;
    656                 lSeek+=file_info.size_file_comment - uSizeRead;
    657         }
    658         else
    659                 lSeek+=file_info.size_file_comment;
    660 
    661         if ((err==UNZ_OK) && (pfile_info!=NULL))
    662                 *pfile_info=file_info;
    663 
    664         if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
    665                 *pfile_info_internal=file_info_internal;
    666 
    667         return err;
    668 }
    669 
    670 
    671 
    672 /*
    673   Write info about the ZipFile in the *pglobal_info structure.
    674   No preparation of the structure is needed
    675   return UNZ_OK if there is no problem.
    676 */
    677 extern int ZEXPORT unzGetCurrentFileInfo (file,
    678                                                   pfile_info,
    679                                                   szFileName, fileNameBufferSize,
    680                                                   extraField, extraFieldBufferSize,
    681                                                   szComment,  commentBufferSize)
    682         unzFile file;
    683         unz_file_info *pfile_info;
    684         char *szFileName;
    685         uLong fileNameBufferSize;
    686         void *extraField;
    687         uLong extraFieldBufferSize;
    688         char *szComment;
    689         uLong commentBufferSize;
    690 {
    691         return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
    692                                                                                                 szFileName,fileNameBufferSize,
    693                                                                                                 extraField,extraFieldBufferSize,
    694                                                                                                 szComment,commentBufferSize);
    695 }
    696 
    697 /*
    698   Set the current file of the zipfile to the first file.
    699   return UNZ_OK if there is no problem
    700 */
    701 extern int ZEXPORT unzGoToFirstFile (file)
    702         unzFile file;
    703 {
    704         int err=UNZ_OK;
    705         unz_s* s;
    706         if (file==NULL)
    707                 return UNZ_PARAMERROR;
    708         s=(unz_s*)file;
    709         s->pos_in_central_dir=s->offset_central_dir;
    710         s->num_file=0;
    711         err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
    712                                                                                          &s->cur_file_info_internal,
    713                                                                                          NULL,0,NULL,0,NULL,0);
    714         s->current_file_ok = (err == UNZ_OK);
    715         return err;
    716 }
    717 
    718 
    719 /*
    720   Set the current file of the zipfile to the next file.
    721   return UNZ_OK if there is no problem
    722   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
    723 */
    724 extern int ZEXPORT unzGoToNextFile (file)
    725         unzFile file;
    726 {
    727         unz_s* s;       
    728         int err;
    729 
    730         if (file==NULL)
    731                 return UNZ_PARAMERROR;
    732         s=(unz_s*)file;
    733         if (!s->current_file_ok)
    734                 return UNZ_END_OF_LIST_OF_FILE;
    735         if (s->num_file+1==s->gi.number_entry)
    736                 return UNZ_END_OF_LIST_OF_FILE;
    737 
    738         s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
    739                         s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
    740         s->num_file++;
    741         err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
    742                                                                                            &s->cur_file_info_internal,
    743                                                                                            NULL,0,NULL,0,NULL,0);
    744         s->current_file_ok = (err == UNZ_OK);
    745         return err;
    746 }
    747 
    748 
    749 /*
    750   Try locate the file szFileName in the zipfile.
    751   For the iCaseSensitivity signification, see unzipStringFileNameCompare
    752 
    753   return value :
    754   UNZ_OK if the file is found. It becomes the current file.
    755   UNZ_END_OF_LIST_OF_FILE if the file is not found
    756 */
    757 extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
    758         unzFile file;
    759         const char *szFileName;
    760         int iCaseSensitivity;
    761 {
    762         unz_s* s;       
    763         int err;
    764 
    765        
    766         uLong num_fileSaved;
    767         uLong pos_in_central_dirSaved;
    768 
    769 
    770         if (file==NULL)
    771                 return UNZ_PARAMERROR;
    772 
    773     if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
    774         return UNZ_PARAMERROR;
    775 
    776         s=(unz_s*)file;
    777         if (!s->current_file_ok)
    778                 return UNZ_END_OF_LIST_OF_FILE;
    779 
    780         num_fileSaved = s->num_file;
    781         pos_in_central_dirSaved = s->pos_in_central_dir;
    782 
    783         err = unzGoToFirstFile(file);
    784 
    785         while (err == UNZ_OK)
    786         {
    787                 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
    788                 unzGetCurrentFileInfo(file,NULL,
    789                                                                 szCurrentFileName,sizeof(szCurrentFileName)-1,
    790                                                                 NULL,0,NULL,0);
    791                 if (unzStringFileNameCompare(szCurrentFileName,
    792                                                                                 szFileName,iCaseSensitivity)==0)
    793                         return UNZ_OK;
    794                 err = unzGoToNextFile(file);
    795         }
    796 
    797         s->num_file = num_fileSaved ;
    798         s->pos_in_central_dir = pos_in_central_dirSaved ;
    799         return err;
    800 }
    801 
    802 
    803 /*
    804   Read the local header of the current zipfile
    805   Check the coherency of the local header and info in the end of central
    806         directory about this file
    807   store in *piSizeVar the size of extra info in local header
    808         (filename and size of extra field data)
    809 */
    810 local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
    811                                                                                                         poffset_local_extrafield,
    812                                                                                                         psize_local_extrafield)
    813         unz_s* s;
    814         uInt* piSizeVar;
    815         uLong *poffset_local_extrafield;
    816         uInt  *psize_local_extrafield;
    817 {
    818         uLong uMagic,uData,uFlags;
    819         uLong size_filename;
    820         uLong size_extra_field;
    821         int err=UNZ_OK;
    822 
    823         *piSizeVar = 0;
    824         *poffset_local_extrafield = 0;
    825         *psize_local_extrafield = 0;
    826 
    827         if (fseek(s->file,s->cur_file_info_internal.offset_curfile +
    828                                                                 s->byte_before_the_zipfile,SEEK_SET)!=0)
    829                 return UNZ_ERRNO;
    830 
    831 
    832         if (err==UNZ_OK) {
    833                 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
    834                         err=UNZ_ERRNO;
    835                 else if (uMagic!=0x04034b50)
    836                         err=UNZ_BADZIPFILE;
    837         }
    838 
    839         if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
    840                 err=UNZ_ERRNO;
    841 /*
    842         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
    843                 err=UNZ_BADZIPFILE;
    844 */
    845         if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK)
    846                 err=UNZ_ERRNO;
    847 
    848         if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
    849                 err=UNZ_ERRNO;
    850         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
    851                 err=UNZ_BADZIPFILE;
    852 
    853     if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
    854                          (s->cur_file_info.compression_method!=Z_DEFLATED))
    855         err=UNZ_BADZIPFILE;
    856 
    857         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */
    858                 err=UNZ_ERRNO;
    859 
    860         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */
    861                 err=UNZ_ERRNO;
    862         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
    863                                       ((uFlags & 8)==0))
    864                 err=UNZ_BADZIPFILE;
    865 
    866         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */
    867                 err=UNZ_ERRNO;
    868         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
    869                                                           ((uFlags & 8)==0))
    870                 err=UNZ_BADZIPFILE;
    871 
    872         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */
    873                 err=UNZ_ERRNO;
    874         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
    875                                                           ((uFlags & 8)==0))
    876                 err=UNZ_BADZIPFILE;
    877 
    878 
    879         if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK)
    880                 err=UNZ_ERRNO;
    881         else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
    882                 err=UNZ_BADZIPFILE;
    883 
    884         *piSizeVar += (uInt)size_filename;
    885 
    886         if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK)
    887                 err=UNZ_ERRNO;
    888         *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
    889                                                                         SIZEZIPLOCALHEADER + size_filename;
    890         *psize_local_extrafield = (uInt)size_extra_field;
    891 
    892         *piSizeVar += (uInt)size_extra_field;
    893 
    894         return err;
    895 }
    896                                                                                                
    897 /*
    898   Open for reading data the current file in the zipfile.
    899   If there is no error and the file is opened, the return value is UNZ_OK.
    900 */
    901 extern int ZEXPORT unzOpenCurrentFile (file)
    902         unzFile file;
    903 {
    904         int err=UNZ_OK;
    905         int Store;
    906         uInt iSizeVar;
    907         unz_s* s;
    908         file_in_zip_read_info_s* pfile_in_zip_read_info;
    909         uLong offset_local_extrafield;  /* offset of the local extra field */
    910         uInt  size_local_extrafield;    /* size of the local extra field */
    911 
    912         if (file==NULL)
    913                 return UNZ_PARAMERROR;
    914         s=(unz_s*)file;
    915         if (!s->current_file_ok)
    916                 return UNZ_PARAMERROR;
    917 
    918     if (s->pfile_in_zip_read != NULL)
    919         unzCloseCurrentFile(file);
    920 
    921         if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
    922                                 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
    923                 return UNZ_BADZIPFILE;
    924 
    925         pfile_in_zip_read_info = (file_in_zip_read_info_s*)
    926                                                                             ALLOC(sizeof(file_in_zip_read_info_s));
    927         if (pfile_in_zip_read_info==NULL)
    928                 return UNZ_INTERNALERROR;
    929 
    930         pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
    931         pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
    932         pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
    933         pfile_in_zip_read_info->pos_local_extrafield=0;
    934 
    935         if (pfile_in_zip_read_info->read_buffer==NULL)
    936         {
    937                 TRYFREE(pfile_in_zip_read_info);
    938                 return UNZ_INTERNALERROR;
    939         }
    940 
    941         pfile_in_zip_read_info->stream_initialised=0;
    942        
    943         if ((s->cur_file_info.compression_method!=0) &&
    944         (s->cur_file_info.compression_method!=Z_DEFLATED))
    945                 err=UNZ_BADZIPFILE;
    946         Store = s->cur_file_info.compression_method==0;
    947 
    948         pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
    949         pfile_in_zip_read_info->crc32=0;
    950         pfile_in_zip_read_info->compression_method =
    951             s->cur_file_info.compression_method;
    952         pfile_in_zip_read_info->file=s->file;
    953         pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
    954 
    955     pfile_in_zip_read_info->stream.total_out = 0;
    956 
    957         if (!Store)
    958         {
    959           pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
    960           pfile_in_zip_read_info->stream.zfree = (free_func)0;
    961           pfile_in_zip_read_info->stream.opaque = (voidpf)0;
    962      
    963           err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
    964           if (err == Z_OK)
    965             pfile_in_zip_read_info->stream_initialised=1;
    966         /* windowBits is passed < 0 to tell that there is no zlib header.
    967          * Note that in this case inflate *requires* an extra "dummy" byte
    968          * after the compressed stream in order to complete decompression and
    969          * return Z_STREAM_END.
    970          * In unzip, i don't wait absolutely Z_STREAM_END because I known the
    971          * size of both compressed and uncompressed data
    972          */
    973         }
    974         pfile_in_zip_read_info->rest_read_compressed =
    975             s->cur_file_info.compressed_size ;
    976         pfile_in_zip_read_info->rest_read_uncompressed =
    977             s->cur_file_info.uncompressed_size ;
    978 
    979        
    980         pfile_in_zip_read_info->pos_in_zipfile =
    981             s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
    982                           iSizeVar;
    983        
    984         pfile_in_zip_read_info->stream.avail_in = (uInt)0;
    985 
    986 
    987         s->pfile_in_zip_read = pfile_in_zip_read_info;
    988     return UNZ_OK;
    989 }
    990 
    991 
    992 /*
    993   Read bytes from the current file.
    994   buf contain buffer where data must be copied
    995   len the size of buf.
    996 
    997   return the number of byte copied if somes bytes are copied
    998   return 0 if the end of file was reached
    999   return <0 with error code if there is an error
    1000     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
    1001 */
    1002 extern int ZEXPORT unzReadCurrentFile  (file, buf, len)
    1003         unzFile file;
    1004         voidp buf;
    1005         unsigned len;
    1006 {
    1007         int err=UNZ_OK;
    1008         uInt iRead = 0;
    1009         unz_s* s;
    1010         file_in_zip_read_info_s* pfile_in_zip_read_info;
    1011         if (file==NULL)
    1012                 return UNZ_PARAMERROR;
    1013         s=(unz_s*)file;
    1014     pfile_in_zip_read_info=s->pfile_in_zip_read;
    1015 
    1016         if (pfile_in_zip_read_info==NULL)
    1017                 return UNZ_PARAMERROR;
    1018 
    1019 
    1020         if ((pfile_in_zip_read_info->read_buffer == NULL))
    1021                 return UNZ_END_OF_LIST_OF_FILE;
    1022         if (len==0)
    1023                 return 0;
    1024 
    1025         pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
    1026 
    1027         pfile_in_zip_read_info->stream.avail_out = (uInt)len;
    1028        
    1029         if (len>pfile_in_zip_read_info->rest_read_uncompressed)
    1030                 pfile_in_zip_read_info->stream.avail_out =
    1031                   (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
    1032 
    1033         while (pfile_in_zip_read_info->stream.avail_out>0)
    1034         {
    1035                 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
    1036             (pfile_in_zip_read_info->rest_read_compressed>0))
    1037                 {
    1038                         uInt uReadThis = UNZ_BUFSIZE;
    1039                         if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
    1040                                 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
    1041                         if (uReadThis == 0)
    1042                                 return UNZ_EOF;
    1043                         if (fseek(pfile_in_zip_read_info->file,
    1044                       pfile_in_zip_read_info->pos_in_zipfile +
    1045                          pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0)
    1046                                 return UNZ_ERRNO;
    1047                         if (fread(pfile_in_zip_read_info->read_buffer,uReadThis,1,
    1048                          pfile_in_zip_read_info->file)!=1)
    1049                                 return UNZ_ERRNO;
    1050                         pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
    1051 
    1052                         pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
    1053                        
    1054                         pfile_in_zip_read_info->stream.next_in =
    1055                 (Bytef*)pfile_in_zip_read_info->read_buffer;
    1056                         pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
    1057                 }
    1058 
    1059                 if (pfile_in_zip_read_info->compression_method==0)
    1060                 {
    1061                         uInt uDoCopy,i ;
    1062                         if (pfile_in_zip_read_info->stream.avail_out <
    1063                             pfile_in_zip_read_info->stream.avail_in)
    1064                                 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
    1065                         else
    1066                                 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
    1067                                
    1068                         for (i=0;i<uDoCopy;i++)
    1069                                 *(pfile_in_zip_read_info->stream.next_out+i) =
    1070                         *(pfile_in_zip_read_info->stream.next_in+i);
    1071                                        
    1072                         pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
    1073                                                                 pfile_in_zip_read_info->stream.next_out,
    1074                                                                 uDoCopy);
    1075                         pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
    1076                         pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
    1077                         pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
    1078                         pfile_in_zip_read_info->stream.next_out += uDoCopy;
    1079                         pfile_in_zip_read_info->stream.next_in += uDoCopy;
    1080             pfile_in_zip_read_info->stream.total_out += uDoCopy;
    1081                         iRead += uDoCopy;
    1082                 }
    1083                 else
    1084                 {
    1085                         uLong uTotalOutBefore,uTotalOutAfter;
    1086                         const Bytef *bufBefore;
    1087                         uLong uOutThis;
    1088                         int flush=Z_SYNC_FLUSH;
    1089 
    1090                         uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
    1091                         bufBefore = pfile_in_zip_read_info->stream.next_out;
    1092 
    1093                         /*
    1094                         if ((pfile_in_zip_read_info->rest_read_uncompressed ==
    1095                                  pfile_in_zip_read_info->stream.avail_out) &&
    1096                                 (pfile_in_zip_read_info->rest_read_compressed == 0))
    1097                                 flush = Z_FINISH;
    1098                         */
    1099                         err=inflate(&pfile_in_zip_read_info->stream,flush);
    1100 
    1101                         uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
    1102                         uOutThis = uTotalOutAfter-uTotalOutBefore;
    1103                        
    1104                         pfile_in_zip_read_info->crc32 =
    1105                 crc32(pfile_in_zip_read_info->crc32,bufBefore,
    1106                         (uInt)(uOutThis));
    1107 
    1108                         pfile_in_zip_read_info->rest_read_uncompressed -=
    1109                 uOutThis;
    1110 
    1111                         iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
    1112            
    1113                         if (err==Z_STREAM_END)
    1114                                 return (iRead==0) ? UNZ_EOF : iRead;
    1115                         if (err!=Z_OK)
    1116                                 break;
    1117                 }
    1118         }
    1119 
    1120         if (err==Z_OK)
    1121                 return iRead;
    1122         return err;
    1123 }
    1124 
    1125 
    1126 /*
    1127   Give the current position in uncompressed data
    1128 */
    1129 extern z_off_t ZEXPORT unztell (file)
    1130         unzFile file;
    1131 {
    1132         unz_s* s;
    1133         file_in_zip_read_info_s* pfile_in_zip_read_info;
    1134         if (file==NULL)
    1135                 return UNZ_PARAMERROR;
    1136         s=(unz_s*)file;
    1137     pfile_in_zip_read_info=s->pfile_in_zip_read;
    1138 
    1139         if (pfile_in_zip_read_info==NULL)
    1140                 return UNZ_PARAMERROR;
    1141 
    1142         return (z_off_t)pfile_in_zip_read_info->stream.total_out;
    1143 }
    1144 
    1145 
    1146 /*
    1147   return 1 if the end of file was reached, 0 elsewhere
    1148 */
    1149 extern int ZEXPORT unzeof (file)
    1150         unzFile file;
    1151 {
    1152         unz_s* s;
    1153         file_in_zip_read_info_s* pfile_in_zip_read_info;
    1154         if (file==NULL)
    1155                 return UNZ_PARAMERROR;
    1156         s=(unz_s*)file;
    1157     pfile_in_zip_read_info=s->pfile_in_zip_read;
    1158 
    1159         if (pfile_in_zip_read_info==NULL)
    1160                 return UNZ_PARAMERROR;
    1161        
    1162         if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
    1163                 return 1;
    1164         else
    1165                 return 0;
    1166 }
    1167 
    1168 
    1169 
    1170 /*
    1171   Read extra field from the current file (opened by unzOpenCurrentFile)
    1172   This is the local-header version of the extra field (sometimes, there is
    1173     more info in the local-header version than in the central-header)
    1174 
    1175   if buf==NULL, it return the size of the local extra field that can be read
    1176 
    1177   if buf!=NULL, len is the size of the buffer, the extra header is copied in
    1178         buf.
    1179   the return value is the number of bytes copied in buf, or (if <0)
    1180         the error code
    1181 */
    1182 extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
    1183         unzFile file;
    1184         voidp buf;
    1185         unsigned len;
    1186 {
    1187         unz_s* s;
    1188         file_in_zip_read_info_s* pfile_in_zip_read_info;
    1189         uInt read_now;
    1190         uLong size_to_read;
    1191 
    1192         if (file==NULL)
    1193                 return UNZ_PARAMERROR;
    1194         s=(unz_s*)file;
    1195     pfile_in_zip_read_info=s->pfile_in_zip_read;
    1196 
    1197         if (pfile_in_zip_read_info==NULL)
    1198                 return UNZ_PARAMERROR;
    1199 
    1200         size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
    1201                                 pfile_in_zip_read_info->pos_local_extrafield);
    1202 
    1203         if (buf==NULL)
    1204                 return (int)size_to_read;
    1205        
    1206         if (len>size_to_read)
    1207                 read_now = (uInt)size_to_read;
    1208         else
    1209                 read_now = (uInt)len ;
    1210 
    1211         if (read_now==0)
    1212                 return 0;
    1213        
    1214         if (fseek(pfile_in_zip_read_info->file,
    1215               pfile_in_zip_read_info->offset_local_extrafield +
    1216                           pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
    1217                 return UNZ_ERRNO;
    1218 
    1219         if (fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
    1220                 return UNZ_ERRNO;
    1221 
    1222         return (int)read_now;
    1223 }
    1224 
    1225 /*
    1226   Close the file in zip opened with unzipOpenCurrentFile
    1227   Return UNZ_CRCERROR if all the file was read but the CRC is not good
    1228 */
    1229 extern int ZEXPORT unzCloseCurrentFile (file)
    1230         unzFile file;
    1231 {
    1232         int err=UNZ_OK;
    1233 
    1234         unz_s* s;
    1235         file_in_zip_read_info_s* pfile_in_zip_read_info;
    1236         if (file==NULL)
    1237                 return UNZ_PARAMERROR;
    1238         s=(unz_s*)file;
    1239     pfile_in_zip_read_info=s->pfile_in_zip_read;
    1240 
    1241         if (pfile_in_zip_read_info==NULL)
    1242                 return UNZ_PARAMERROR;
    1243 
    1244 
    1245         if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
    1246         {
    1247                 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
    1248                         err=UNZ_CRCERROR;
    1249         }
    1250 
    1251 
    1252         TRYFREE(pfile_in_zip_read_info->read_buffer);
    1253         pfile_in_zip_read_info->read_buffer = NULL;
    1254         if (pfile_in_zip_read_info->stream_initialised)
    1255                 inflateEnd(&pfile_in_zip_read_info->stream);
    1256 
    1257         pfile_in_zip_read_info->stream_initialised = 0;
    1258         TRYFREE(pfile_in_zip_read_info);
    1259 
    1260     s->pfile_in_zip_read=NULL;
    1261 
    1262         return err;
    1263 }
    1264 
    1265 
    1266 /*
    1267   Get the global comment string of the ZipFile, in the szComment buffer.
    1268   uSizeBuf is the size of the szComment buffer.
    1269   return the number of byte copied or an error code <0
    1270 */
    1271 extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
    1272         unzFile file;
    1273         char *szComment;
    1274         uLong uSizeBuf;
    1275 {
    1276 //      int err=UNZ_OK;
    1277         unz_s* s;
    1278         uLong uReadThis ;
    1279         if (file==NULL)
    1280                 return UNZ_PARAMERROR;
    1281         s=(unz_s*)file;
    1282 
    1283         uReadThis = uSizeBuf;
    1284         if (uReadThis>s->gi.size_comment)
    1285                 uReadThis = s->gi.size_comment;
    1286 
    1287         if (fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
    1288                 return UNZ_ERRNO;
    1289 
    1290         if (uReadThis>0)
    1291     {
    1292       *szComment='\0';
    1293           if (fread(szComment,(uInt)uReadThis,1,s->file)!=1)
    1294                 return UNZ_ERRNO;
    1295     }
    1296 
    1297         if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
    1298                 *(szComment+s->gi.size_comment)='\0';
    1299         return (int)uReadThis;
    1300 }
  • mythgame.

    diff -ruN mythgame.old/unzip.h mythgame.new/unzip.h
    old new  
    1 /* unzip.h -- IO for uncompress .zip files using zlib
    2    Version 0.15 beta, Mar 19th, 1998,
    3 
    4    Copyright (C) 1998 Gilles Vollant
    5 
    6    This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
    7      WinZip, InfoZip tools and compatible.
    8    Encryption and multi volume ZipFile (span) are not supported.
    9    Old compressions used by old PKZip 1.x are not supported
    10 
    11    THIS IS AN ALPHA VERSION. AT THIS STAGE OF DEVELOPPEMENT, SOMES API OR STRUCTURE
    12    CAN CHANGE IN FUTURE VERSION !!
    13    I WAIT FEEDBACK at mail info@winimage.com
    14    Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
    15 
    16    Condition of use and distribution are the same than zlib :
    17 
    18   This software is provided 'as-is', without any express or implied
    19   warranty.  In no event will the authors be held liable for any damages
    20   arising from the use of this software.
    21 
    22   Permission is granted to anyone to use this software for any purpose,
    23   including commercial applications, and to alter it and redistribute it
    24   freely, subject to the following restrictions:
    25 
    26   1. The origin of this software must not be misrepresented; you must not
    27      claim that you wrote the original software. If you use this software
    28      in a product, an acknowledgment in the product documentation would be
    29      appreciated but is not required.
    30   2. Altered source versions must be plainly marked as such, and must not be
    31      misrepresented as being the original software.
    32   3. This notice may not be removed or altered from any source distribution.
    33 
    34 
    35 */
    36 /* for more info about .ZIP format, see
    37       ftp://ftp.cdrom.com/pub/infozip/doc/appnote-970311-iz.zip
    38    PkWare has also a specification at :
    39       ftp://ftp.pkware.com/probdesc.zip */
    40 
    41 #ifndef _unz_H
    42 #define _unz_H
    43 
    44 #ifdef __cplusplus
    45 extern "C" {
    46 #endif
    47 
    48 #ifndef _ZLIB_H
    49 #include "zlib.h"
    50 #endif
    51 
    52 #if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
    53 /* like the STRICT of WIN32, we define a pointer that cannot be converted
    54     from (void*) without cast */
    55 typedef struct TagunzFile__ { int unused; } unzFile__;
    56 typedef unzFile__ *unzFile;
    57 #else
    58 typedef voidp unzFile;
    59 #endif
    60 
    61 
    62 #define UNZ_OK                                  (0)
    63 #define UNZ_END_OF_LIST_OF_FILE (-100)
    64 #define UNZ_ERRNO               (Z_ERRNO)
    65 #define UNZ_EOF                 (0)
    66 #define UNZ_PARAMERROR                  (-102)
    67 #define UNZ_BADZIPFILE                  (-103)
    68 #define UNZ_INTERNALERROR               (-104)
    69 #define UNZ_CRCERROR                    (-105)
    70 
    71 /* tm_unz contain date/time info */
    72 typedef struct tm_unz_s
    73 {
    74         uInt tm_sec;            /* seconds after the minute - [0,59] */
    75         uInt tm_min;            /* minutes after the hour - [0,59] */
    76         uInt tm_hour;           /* hours since midnight - [0,23] */
    77         uInt tm_mday;           /* day of the month - [1,31] */
    78         uInt tm_mon;            /* months since January - [0,11] */
    79         uInt tm_year;           /* years - [1980..2044] */
    80 } tm_unz;
    81 
    82 /* unz_global_info structure contain global data about the ZIPfile
    83    These data comes from the end of central dir */
    84 typedef struct unz_global_info_s
    85 {
    86         uLong number_entry;         /* total number of entries in
    87                                        the central dir on this disk */
    88         uLong size_comment;         /* size of the global comment of the zipfile */
    89 } unz_global_info;
    90 
    91 
    92 /* unz_file_info contain information about a file in the zipfile */
    93 typedef struct unz_file_info_s
    94 {
    95     uLong version;              /* version made by                 2 bytes */
    96     uLong version_needed;       /* version needed to extract       2 bytes */
    97     uLong flag;                 /* general purpose bit flag        2 bytes */
    98     uLong compression_method;   /* compression method              2 bytes */
    99     uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
    100     uLong crc;                  /* crc-32                          4 bytes */
    101     uLong compressed_size;      /* compressed size                 4 bytes */
    102     uLong uncompressed_size;    /* uncompressed size               4 bytes */
    103     uLong size_filename;        /* filename length                 2 bytes */
    104     uLong size_file_extra;      /* extra field length              2 bytes */
    105     uLong size_file_comment;    /* file comment length             2 bytes */
    106 
    107     uLong disk_num_start;       /* disk number start               2 bytes */
    108     uLong internal_fa;          /* internal file attributes        2 bytes */
    109     uLong external_fa;          /* external file attributes        4 bytes */
    110 
    111     tm_unz tmu_date;
    112 } unz_file_info;
    113 
    114 extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
    115                                                                                                  const char* fileName2,
    116                                                                                                  int iCaseSensitivity));
    117 /*
    118    Compare two filename (fileName1,fileName2).
    119    If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
    120    If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
    121                                                                 or strcasecmp)
    122    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
    123         (like 1 on Unix, 2 on Windows)
    124 */
    125 
    126 
    127 extern unzFile ZEXPORT unzOpen OF((const char *path));
    128 /*
    129   Open a Zip file. path contain the full pathname (by example,
    130      on a Windows NT computer "c:\\zlib\\zlib111.zip" or on an Unix computer
    131          "zlib/zlib111.zip".
    132          If the zipfile cannot be opened (file don't exist or in not valid), the
    133            return value is NULL.
    134      Else, the return value is a unzFile Handle, usable with other function
    135            of this unzip package.
    136 */
    137 
    138 extern int ZEXPORT unzClose OF((unzFile file));
    139 /*
    140   Close a ZipFile opened with unzipOpen.
    141   If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
    142     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
    143   return UNZ_OK if there is no problem. */
    144 
    145 extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
    146                                         unz_global_info *pglobal_info));
    147 /*
    148   Write info about the ZipFile in the *pglobal_info structure.
    149   No preparation of the structure is needed
    150   return UNZ_OK if there is no problem. */
    151 
    152 
    153 extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
    154                                                                                    char *szComment,
    155                                            uLong uSizeBuf));
    156 /*
    157   Get the global comment string of the ZipFile, in the szComment buffer.
    158   uSizeBuf is the size of the szComment buffer.
    159   return the number of byte copied or an error code <0
    160 */
    161 
    162 
    163 /***************************************************************************/
    164 /* Unzip package allow you browse the directory of the zipfile */
    165 
    166 extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
    167 /*
    168   Set the current file of the zipfile to the first file.
    169   return UNZ_OK if there is no problem
    170 */
    171 
    172 extern int ZEXPORT unzGoToNextFile OF((unzFile file));
    173 /*
    174   Set the current file of the zipfile to the next file.
    175   return UNZ_OK if there is no problem
    176   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
    177 */
    178 
    179 extern int ZEXPORT unzLocateFile OF((unzFile file,
    180                                      const char *szFileName,
    181                                      int iCaseSensitivity));
    182 /*
    183   Try locate the file szFileName in the zipfile.
    184   For the iCaseSensitivity signification, see unzStringFileNameCompare
    185 
    186   return value :
    187   UNZ_OK if the file is found. It becomes the current file.
    188   UNZ_END_OF_LIST_OF_FILE if the file is not found
    189 */
    190 
    191 
    192 extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
    193                                              unz_file_info *pfile_info,
    194                                              char *szFileName,
    195                                              uLong fileNameBufferSize,
    196                                              void *extraField,
    197                                              uLong extraFieldBufferSize,
    198                                              char *szComment,
    199                                              uLong commentBufferSize));
    200 /*
    201   Get Info about the current file
    202   if pfile_info!=NULL, the *pfile_info structure will contain somes info about
    203             the current file
    204   if szFileName!=NULL, the filemane string will be copied in szFileName
    205                         (fileNameBufferSize is the size of the buffer)
    206   if extraField!=NULL, the extra field information will be copied in extraField
    207                         (extraFieldBufferSize is the size of the buffer).
    208                         This is the Central-header version of the extra field
    209   if szComment!=NULL, the comment string of the file will be copied in szComment
    210                         (commentBufferSize is the size of the buffer)
    211 */
    212 
    213 /***************************************************************************/
    214 /* for reading the content of the current zipfile, you can open it, read data
    215    from it, and close it (you can close it before reading all the file)
    216    */
    217 
    218 extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
    219 /*
    220   Open for reading data the current file in the zipfile.
    221   If there is no error, the return value is UNZ_OK.
    222 */
    223 
    224 extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
    225 /*
    226   Close the file in zip opened with unzOpenCurrentFile
    227   Return UNZ_CRCERROR if all the file was read but the CRC is not good
    228 */
    229 
    230                                                                                                
    231 extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
    232                                           voidp buf,
    233                                           unsigned len));
    234 /*
    235   Read bytes from the current file (opened by unzOpenCurrentFile)
    236   buf contain buffer where data must be copied
    237   len the size of buf.
    238 
    239   return the number of byte copied if somes bytes are copied
    240   return 0 if the end of file was reached
    241   return <0 with error code if there is an error
    242     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
    243 */
    244 
    245 extern z_off_t ZEXPORT unztell OF((unzFile file));
    246 /*
    247   Give the current position in uncompressed data
    248 */
    249 
    250 extern int ZEXPORT unzeof OF((unzFile file));
    251 /*
    252   return 1 if the end of file was reached, 0 elsewhere
    253 */
    254 
    255 extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
    256                                                                                          voidp buf,
    257                                                                                          unsigned len));
    258 /*
    259   Read extra field from the current file (opened by unzOpenCurrentFile)
    260   This is the local-header version of the extra field (sometimes, there is
    261     more info in the local-header version than in the central-header)
    262 
    263   if buf==NULL, it return the size of the local extra field
    264 
    265   if buf!=NULL, len is the size of the buffer, the extra header is copied in
    266         buf.
    267   the return value is the number of bytes copied in buf, or (if <0)
    268         the error code
    269 */
    270 
    271 #ifdef __cplusplus
    272 }
    273 #endif
    274 
    275 #endif /* _unz_H */