Ticket #9030: iphone-scummvm-url-handler.patch

File iphone-scummvm-url-handler.patch, 195.7 KB (added by SF/notzcoolx, 14 years ago)

scummvm:// handler for iPhone backend

  • dists/iphone/scummvm.xcodeproj/project.pbxproj

     
    2121/* End PBXAggregateTarget section */
    2222
    2323/* Begin PBXBuildFile section */
     24                6556A25E0FF699D000318BE2 /* GameFileURLHandler.m in Sources */ = {isa = PBXBuildFile; fileRef = 6556A25D0FF699D000318BE2 /* GameFileURLHandler.m */; };
     25                6556A25F0FF699D000318BE2 /* GameFileURLHandler.m in Sources */ = {isa = PBXBuildFile; fileRef = 6556A25D0FF699D000318BE2 /* GameFileURLHandler.m */; };
     26                6556A2600FF699D000318BE2 /* GameFileURLHandler.m in Sources */ = {isa = PBXBuildFile; fileRef = 6556A25D0FF699D000318BE2 /* GameFileURLHandler.m */; };
     27                6556A2C80FF6D91C00318BE2 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 6556A2C70FF6D91C00318BE2 /* CoreGraphics.framework */; };
     28                655941510FF5A6CB003785DB /* NuZip.m in Sources */ = {isa = PBXBuildFile; fileRef = 655941500FF5A6CB003785DB /* NuZip.m */; };
     29                655941520FF5A6CB003785DB /* NuZip.m in Sources */ = {isa = PBXBuildFile; fileRef = 655941500FF5A6CB003785DB /* NuZip.m */; };
     30                655941530FF5A6CB003785DB /* NuZip.m in Sources */ = {isa = PBXBuildFile; fileRef = 655941500FF5A6CB003785DB /* NuZip.m */; };
     31                655941600FF5AF66003785DB /* ioapi.c in Sources */ = {isa = PBXBuildFile; fileRef = 655941580FF5AF66003785DB /* ioapi.c */; };
     32                655941610FF5AF66003785DB /* mztools.c in Sources */ = {isa = PBXBuildFile; fileRef = 6559415A0FF5AF66003785DB /* mztools.c */; };
     33                655941620FF5AF66003785DB /* unzip.c in Sources */ = {isa = PBXBuildFile; fileRef = 6559415C0FF5AF66003785DB /* unzip.c */; };
     34                655941630FF5AF66003785DB /* zip.c in Sources */ = {isa = PBXBuildFile; fileRef = 6559415E0FF5AF66003785DB /* zip.c */; };
     35                655941640FF5AF66003785DB /* ioapi.c in Sources */ = {isa = PBXBuildFile; fileRef = 655941580FF5AF66003785DB /* ioapi.c */; };
     36                655941650FF5AF66003785DB /* mztools.c in Sources */ = {isa = PBXBuildFile; fileRef = 6559415A0FF5AF66003785DB /* mztools.c */; };
     37                655941660FF5AF66003785DB /* unzip.c in Sources */ = {isa = PBXBuildFile; fileRef = 6559415C0FF5AF66003785DB /* unzip.c */; };
     38                655941670FF5AF66003785DB /* zip.c in Sources */ = {isa = PBXBuildFile; fileRef = 6559415E0FF5AF66003785DB /* zip.c */; };
     39                655941680FF5AF66003785DB /* ioapi.c in Sources */ = {isa = PBXBuildFile; fileRef = 655941580FF5AF66003785DB /* ioapi.c */; };
     40                655941690FF5AF66003785DB /* mztools.c in Sources */ = {isa = PBXBuildFile; fileRef = 6559415A0FF5AF66003785DB /* mztools.c */; };
     41                6559416A0FF5AF66003785DB /* unzip.c in Sources */ = {isa = PBXBuildFile; fileRef = 6559415C0FF5AF66003785DB /* unzip.c */; };
     42                6559416B0FF5AF66003785DB /* zip.c in Sources */ = {isa = PBXBuildFile; fileRef = 6559415E0FF5AF66003785DB /* zip.c */; };
     43                6559417B0FF5B07D003785DB /* expression.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941730FF5B07D003785DB /* expression.cpp */; };
     44                6559417C0FF5B07D003785DB /* resources.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941750FF5B07D003785DB /* resources.cpp */; };
     45                6559417D0FF5B07D003785DB /* script.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941770FF5B07D003785DB /* script.cpp */; };
     46                6559417E0FF5B07D003785DB /* totfile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941790FF5B07D003785DB /* totfile.cpp */; };
     47                6559417F0FF5B07D003785DB /* expression.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941730FF5B07D003785DB /* expression.cpp */; };
     48                655941800FF5B07D003785DB /* resources.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941750FF5B07D003785DB /* resources.cpp */; };
     49                655941810FF5B07D003785DB /* script.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941770FF5B07D003785DB /* script.cpp */; };
     50                655941820FF5B07D003785DB /* totfile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941790FF5B07D003785DB /* totfile.cpp */; };
     51                655941830FF5B07D003785DB /* expression.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941730FF5B07D003785DB /* expression.cpp */; };
     52                655941840FF5B07D003785DB /* resources.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941750FF5B07D003785DB /* resources.cpp */; };
     53                655941850FF5B07D003785DB /* script.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941770FF5B07D003785DB /* script.cpp */; };
     54                655941860FF5B07D003785DB /* totfile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655941790FF5B07D003785DB /* totfile.cpp */; };
    2455                DF093E5F0F63CAD4002D821E /* pn.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF093E5C0F63CAD4002D821E /* pn.cpp */; };
    2556                DF093E600F63CAD4002D821E /* script_pn.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF093E5D0F63CAD4002D821E /* script_pn.cpp */; };
    2657                DF093E610F63CAD4002D821E /* vga_pn.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF093E5E0F63CAD4002D821E /* vga_pn.cpp */; };
     
    301332                DF093F910F63CB26002D821E /* mult_v1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF8421490E7BA6A700F5680E /* mult_v1.cpp */; };
    302333                DF093F920F63CB26002D821E /* mult_v2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84214A0E7BA6A700F5680E /* mult_v2.cpp */; };
    303334                DF093F930F63CB26002D821E /* palanim.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84214C0E7BA6A700F5680E /* palanim.cpp */; };
    304                 DF093F940F63CB26002D821E /* parse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84214E0E7BA6A700F5680E /* parse.cpp */; };
    305335                DF093F9B0F63CB26002D821E /* scenery.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF8421570E7BA6A700F5680E /* scenery.cpp */; };
    306336                DF093F9C0F63CB26002D821E /* scenery_v1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF8421590E7BA6A700F5680E /* scenery_v1.cpp */; };
    307337                DF093F9D0F63CB26002D821E /* scenery_v2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84215A0E7BA6A700F5680E /* scenery_v2.cpp */; };
     
    13101340                DF8426000E7BA6AC00F5680E /* mult_v1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF8421490E7BA6A700F5680E /* mult_v1.cpp */; };
    13111341                DF8426010E7BA6AC00F5680E /* mult_v2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84214A0E7BA6A700F5680E /* mult_v2.cpp */; };
    13121342                DF8426030E7BA6AC00F5680E /* palanim.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84214C0E7BA6A700F5680E /* palanim.cpp */; };
    1313                 DF8426040E7BA6AC00F5680E /* parse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84214E0E7BA6A700F5680E /* parse.cpp */; };
    13141343                DF84260B0E7BA6AC00F5680E /* scenery.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF8421570E7BA6A700F5680E /* scenery.cpp */; };
    13151344                DF84260C0E7BA6AC00F5680E /* scenery_v1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF8421590E7BA6A700F5680E /* scenery_v1.cpp */; };
    13161345                DF84260D0E7BA6AC00F5680E /* scenery_v2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84215A0E7BA6A700F5680E /* scenery_v2.cpp */; };
     
    22422271                DFF95A270FB22D5700A3EC78 /* mult_v1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF8421490E7BA6A700F5680E /* mult_v1.cpp */; };
    22432272                DFF95A280FB22D5700A3EC78 /* mult_v2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84214A0E7BA6A700F5680E /* mult_v2.cpp */; };
    22442273                DFF95A290FB22D5700A3EC78 /* palanim.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84214C0E7BA6A700F5680E /* palanim.cpp */; };
    2245                 DFF95A2A0FB22D5700A3EC78 /* parse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84214E0E7BA6A700F5680E /* parse.cpp */; };
    22462274                DFF95A310FB22D5700A3EC78 /* scenery.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF8421570E7BA6A700F5680E /* scenery.cpp */; };
    22472275                DFF95A320FB22D5700A3EC78 /* scenery_v1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF8421590E7BA6A700F5680E /* scenery_v1.cpp */; };
    22482276                DFF95A330FB22D5700A3EC78 /* scenery_v2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF84215A0E7BA6A700F5680E /* scenery_v2.cpp */; };
     
    29312959
    29322960/* Begin PBXFileReference section */
    29332961                1D6058910D05DD3D006BFB54 /* ScummVM.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = ScummVM.app; sourceTree = BUILT_PRODUCTS_DIR; };
     2962                651027890FDD89F400D3035C /* opl_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = opl_impl.h; sourceTree = "<group>"; };
     2963                6510278A0FDD89F400D3035C /* opl_inc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = opl_inc.h; sourceTree = "<group>"; };
     2964                6556A25C0FF699D000318BE2 /* GameFileURLHandler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GameFileURLHandler.h; sourceTree = "<group>"; };
     2965                6556A25D0FF699D000318BE2 /* GameFileURLHandler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GameFileURLHandler.m; sourceTree = "<group>"; };
     2966                6556A2C70FF6D91C00318BE2 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = System/Library/Frameworks/CoreGraphics.framework; sourceTree = SDKROOT; };
     2967                6559414F0FF5A6CB003785DB /* NuZip.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NuZip.h; sourceTree = "<group>"; };
     2968                655941500FF5A6CB003785DB /* NuZip.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NuZip.m; sourceTree = "<group>"; };
     2969                655941570FF5AF66003785DB /* crypt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = crypt.h; sourceTree = "<group>"; };
     2970                655941580FF5AF66003785DB /* ioapi.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = ioapi.c; sourceTree = "<group>"; };
     2971                655941590FF5AF66003785DB /* ioapi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ioapi.h; sourceTree = "<group>"; };
     2972                6559415A0FF5AF66003785DB /* mztools.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = mztools.c; sourceTree = "<group>"; };
     2973                6559415B0FF5AF66003785DB /* mztools.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mztools.h; sourceTree = "<group>"; };
     2974                6559415C0FF5AF66003785DB /* unzip.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = unzip.c; sourceTree = "<group>"; };
     2975                6559415D0FF5AF66003785DB /* unzip.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unzip.h; sourceTree = "<group>"; };
     2976                6559415E0FF5AF66003785DB /* zip.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = zip.c; sourceTree = "<group>"; };
     2977                6559415F0FF5AF66003785DB /* zip.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = zip.h; sourceTree = "<group>"; };
     2978                655941730FF5B07D003785DB /* expression.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = expression.cpp; sourceTree = "<group>"; };
     2979                655941740FF5B07D003785DB /* expression.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = expression.h; sourceTree = "<group>"; };
     2980                655941750FF5B07D003785DB /* resources.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = resources.cpp; sourceTree = "<group>"; };
     2981                655941760FF5B07D003785DB /* resources.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = resources.h; sourceTree = "<group>"; };
     2982                655941770FF5B07D003785DB /* script.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = script.cpp; sourceTree = "<group>"; };
     2983                655941780FF5B07D003785DB /* script.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = script.h; sourceTree = "<group>"; };
     2984                655941790FF5B07D003785DB /* totfile.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = totfile.cpp; sourceTree = "<group>"; };
     2985                6559417A0FF5B07D003785DB /* totfile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = totfile.h; sourceTree = "<group>"; };
    29342986                8D1107310486CEB800E47090 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
    29352987                DF093E5C0F63CAD4002D821E /* pn.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pn.cpp; sourceTree = "<group>"; };
    29362988                DF093E5D0F63CAD4002D821E /* script_pn.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = script_pn.cpp; sourceTree = "<group>"; };
     
    34493501                DF84214A0E7BA6A700F5680E /* mult_v2.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mult_v2.cpp; sourceTree = "<group>"; };
    34503502                DF84214C0E7BA6A700F5680E /* palanim.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = palanim.cpp; sourceTree = "<group>"; };
    34513503                DF84214D0E7BA6A700F5680E /* palanim.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = palanim.h; sourceTree = "<group>"; };
    3452                 DF84214E0E7BA6A700F5680E /* parse.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = parse.cpp; sourceTree = "<group>"; };
    3453                 DF84214F0E7BA6A700F5680E /* parse.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parse.h; sourceTree = "<group>"; };
    34543504                DF8421570E7BA6A700F5680E /* scenery.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = scenery.cpp; sourceTree = "<group>"; };
    34553505                DF8421580E7BA6A700F5680E /* scenery.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = scenery.h; sourceTree = "<group>"; };
    34563506                DF8421590E7BA6A700F5680E /* scenery_v1.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = scenery_v1.cpp; sourceTree = "<group>"; };
     
    46434693                                DFF95CC00FB22D5700A3EC78 /* AudioToolbox.framework in Frameworks */,
    46444694                                DFF95CC10FB22D5700A3EC78 /* QuartzCore.framework in Frameworks */,
    46454695                                DF224E050FB23BC500C8E453 /* OpenGLES.framework in Frameworks */,
     4696                                6556A2C80FF6D91C00318BE2 /* CoreGraphics.framework in Frameworks */,
    46464697                        );
    46474698                        runOnlyForDeploymentPostprocessing = 0;
    46484699                };
     
    47014752                                29B97317FDCFA39411CA2CEA /* Resources */,
    47024753                                29B97323FDCFA39411CA2CEA /* Frameworks */,
    47034754                                19C28FACFE9D520D11CA2CBB /* Products */,
     4755                                6556A2C70FF6D91C00318BE2 /* CoreGraphics.framework */,
    47044756                        );
    47054757                        name = CustomTemplate;
    47064758                        sourceTree = "<group>";
     
    47324784                        name = Frameworks;
    47334785                        sourceTree = "<group>";
    47344786                };
     4787                6559414E0FF5A6A9003785DB /* nuzip */ = {
     4788                        isa = PBXGroup;
     4789                        children = (
     4790                                655941570FF5AF66003785DB /* crypt.h */,
     4791                                655941580FF5AF66003785DB /* ioapi.c */,
     4792                                655941590FF5AF66003785DB /* ioapi.h */,
     4793                                6559415A0FF5AF66003785DB /* mztools.c */,
     4794                                6559415B0FF5AF66003785DB /* mztools.h */,
     4795                                6559415C0FF5AF66003785DB /* unzip.c */,
     4796                                6559415D0FF5AF66003785DB /* unzip.h */,
     4797                                6559415E0FF5AF66003785DB /* zip.c */,
     4798                                6559415F0FF5AF66003785DB /* zip.h */,
     4799                                6559414F0FF5A6CB003785DB /* NuZip.h */,
     4800                                655941500FF5A6CB003785DB /* NuZip.m */,
     4801                        );
     4802                        path = nuzip;
     4803                        sourceTree = "<group>";
     4804                };
    47354805                DF09422F0F63CB9A002D821E /* sdl */ = {
    47364806                        isa = PBXGroup;
    47374807                        children = (
     
    51715241                DF8421170E7BA6A700F5680E /* gob */ = {
    51725242                        isa = PBXGroup;
    51735243                        children = (
     5244                                655941730FF5B07D003785DB /* expression.cpp */,
     5245                                655941740FF5B07D003785DB /* expression.h */,
     5246                                655941750FF5B07D003785DB /* resources.cpp */,
     5247                                655941760FF5B07D003785DB /* resources.h */,
     5248                                655941770FF5B07D003785DB /* script.cpp */,
     5249                                655941780FF5B07D003785DB /* script.h */,
     5250                                655941790FF5B07D003785DB /* totfile.cpp */,
     5251                                6559417A0FF5B07D003785DB /* totfile.h */,
    51745252                                DF6118780FE3A9AA0042AD3F /* save */,
    51755253                                DF6118590FE3A9020042AD3F /* helper.h */,
    51765254                                DF09CC060FAC4E1900A5AFD7 /* demos */,
     
    52275305                                DF84214A0E7BA6A700F5680E /* mult_v2.cpp */,
    52285306                                DF84214C0E7BA6A700F5680E /* palanim.cpp */,
    52295307                                DF84214D0E7BA6A700F5680E /* palanim.h */,
    5230                                 DF84214E0E7BA6A700F5680E /* parse.cpp */,
    5231                                 DF84214F0E7BA6A700F5680E /* parse.h */,
    52325308                                DF8421570E7BA6A700F5680E /* scenery.cpp */,
    52335309                                DF8421580E7BA6A700F5680E /* scenery.h */,
    52345310                                DF8421590E7BA6A700F5680E /* scenery_v1.cpp */,
     
    65726648                DFE471D70D81F4E700B6D1FB /* iphone */ = {
    65736649                        isa = PBXGroup;
    65746650                        children = (
     6651                                6559414E0FF5A6A9003785DB /* nuzip */,
    65756652                                DF8428960E7BAAAB00F5680E /* blit.cpp */,
    65766653                                DF841FD90E7BA61800F5680E /* iphone_keyboard.m */,
    65776654                                DF841FDA0E7BA61800F5680E /* iphone_video.h */,
     
    65826659                                DFE471E10D81F4E700B6D1FB /* iphone_main.m */,
    65836660                                DFE471E60D81F4E700B6D1FB /* osys_iphone.cpp */,
    65846661                                DFE471E70D81F4E700B6D1FB /* osys_iphone.h */,
     6662                                6556A25C0FF699D000318BE2 /* GameFileURLHandler.h */,
     6663                                6556A25D0FF699D000318BE2 /* GameFileURLHandler.m */,
    65856664                        );
    65866665                        path = iphone;
    65876666                        sourceTree = "<group>";
     
    69196998                        children = (
    69206999                                DF6118CF0FE3AB560042AD3F /* mame.cpp */,
    69217000                                DF6118D00FE3AB560042AD3F /* mame.h */,
     7001                                651027890FDD89F400D3035C /* opl_impl.h */,
     7002                                6510278A0FDD89F400D3035C /* opl_inc.h */,
    69227003                                DFF958A90FB222F300A3EC78 /* dosbox.cpp */,
    69237004                                DFF958AA0FB222F300A3EC78 /* dosbox.h */,
    69247005                        );
     
    73547435                                DF8426000E7BA6AC00F5680E /* mult_v1.cpp in Sources */,
    73557436                                DF8426010E7BA6AC00F5680E /* mult_v2.cpp in Sources */,
    73567437                                DF8426030E7BA6AC00F5680E /* palanim.cpp in Sources */,
    7357                                 DF8426040E7BA6AC00F5680E /* parse.cpp in Sources */,
    73587438                                DF84260B0E7BA6AC00F5680E /* scenery.cpp in Sources */,
    73597439                                DF84260C0E7BA6AC00F5680E /* scenery_v1.cpp in Sources */,
    73607440                                DF84260D0E7BA6AC00F5680E /* scenery_v2.cpp in Sources */,
     
    80118091                                DF6118BF0FE3AA280042AD3F /* text_lol.cpp in Sources */,
    80128092                                DF6118C80FE3AABD0042AD3F /* player_v2cms.cpp in Sources */,
    80138093                                DF6118D30FE3AB560042AD3F /* mame.cpp in Sources */,
     8094                                655941510FF5A6CB003785DB /* NuZip.m in Sources */,
     8095                                655941600FF5AF66003785DB /* ioapi.c in Sources */,
     8096                                655941610FF5AF66003785DB /* mztools.c in Sources */,
     8097                                655941620FF5AF66003785DB /* unzip.c in Sources */,
     8098                                655941630FF5AF66003785DB /* zip.c in Sources */,
     8099                                6559417B0FF5B07D003785DB /* expression.cpp in Sources */,
     8100                                6559417C0FF5B07D003785DB /* resources.cpp in Sources */,
     8101                                6559417D0FF5B07D003785DB /* script.cpp in Sources */,
     8102                                6559417E0FF5B07D003785DB /* totfile.cpp in Sources */,
     8103                                6556A25F0FF699D000318BE2 /* GameFileURLHandler.m in Sources */,
    80148104                        );
    80158105                        runOnlyForDeploymentPostprocessing = 0;
    80168106                };
     
    82888378                                DF093F910F63CB26002D821E /* mult_v1.cpp in Sources */,
    82898379                                DF093F920F63CB26002D821E /* mult_v2.cpp in Sources */,
    82908380                                DF093F930F63CB26002D821E /* palanim.cpp in Sources */,
    8291                                 DF093F940F63CB26002D821E /* parse.cpp in Sources */,
    82928381                                DF093F9B0F63CB26002D821E /* scenery.cpp in Sources */,
    82938382                                DF093F9C0F63CB26002D821E /* scenery_v1.cpp in Sources */,
    82948383                                DF093F9D0F63CB26002D821E /* scenery_v2.cpp in Sources */,
     
    89529041                                DF6118C70FE3AABD0042AD3F /* player_v2cms.cpp in Sources */,
    89539042                                DF6118CC0FE3AAFD0042AD3F /* hardwarekeys.cpp in Sources */,
    89549043                                DF6118D10FE3AB560042AD3F /* mame.cpp in Sources */,
     9044                                655941520FF5A6CB003785DB /* NuZip.m in Sources */,
     9045                                655941640FF5AF66003785DB /* ioapi.c in Sources */,
     9046                                655941650FF5AF66003785DB /* mztools.c in Sources */,
     9047                                655941660FF5AF66003785DB /* unzip.c in Sources */,
     9048                                655941670FF5AF66003785DB /* zip.c in Sources */,
     9049                                6559417F0FF5B07D003785DB /* expression.cpp in Sources */,
     9050                                655941800FF5B07D003785DB /* resources.cpp in Sources */,
     9051                                655941810FF5B07D003785DB /* script.cpp in Sources */,
     9052                                655941820FF5B07D003785DB /* totfile.cpp in Sources */,
     9053                                6556A2600FF699D000318BE2 /* GameFileURLHandler.m in Sources */,
    89559054                        );
    89569055                        runOnlyForDeploymentPostprocessing = 0;
    89579056                };
     
    92339332                                DFF95A270FB22D5700A3EC78 /* mult_v1.cpp in Sources */,
    92349333                                DFF95A280FB22D5700A3EC78 /* mult_v2.cpp in Sources */,
    92359334                                DFF95A290FB22D5700A3EC78 /* palanim.cpp in Sources */,
    9236                                 DFF95A2A0FB22D5700A3EC78 /* parse.cpp in Sources */,
    92379335                                DFF95A310FB22D5700A3EC78 /* scenery.cpp in Sources */,
    92389336                                DFF95A320FB22D5700A3EC78 /* scenery_v1.cpp in Sources */,
    92399337                                DFF95A330FB22D5700A3EC78 /* scenery_v2.cpp in Sources */,
     
    98909988                                DF6118C30FE3AA280042AD3F /* text_lol.cpp in Sources */,
    98919989                                DF6118C90FE3AABD0042AD3F /* player_v2cms.cpp in Sources */,
    98929990                                DF6118D20FE3AB560042AD3F /* mame.cpp in Sources */,
     9991                                655941530FF5A6CB003785DB /* NuZip.m in Sources */,
     9992                                655941680FF5AF66003785DB /* ioapi.c in Sources */,
     9993                                655941690FF5AF66003785DB /* mztools.c in Sources */,
     9994                                6559416A0FF5AF66003785DB /* unzip.c in Sources */,
     9995                                6559416B0FF5AF66003785DB /* zip.c in Sources */,
     9996                                655941830FF5B07D003785DB /* expression.cpp in Sources */,
     9997                                655941840FF5B07D003785DB /* resources.cpp in Sources */,
     9998                                655941850FF5B07D003785DB /* script.cpp in Sources */,
     9999                                655941860FF5B07D003785DB /* totfile.cpp in Sources */,
     10000                                6556A25E0FF699D000318BE2 /* GameFileURLHandler.m in Sources */,
    989310001                        );
    989410002                        runOnlyForDeploymentPostprocessing = 0;
    989510003                };
     
    1036810476                                );
    1036910477                                GCC_THUMB_SUPPORT = NO;
    1037010478                                GCC_UNROLL_LOOPS = YES;
    10371                                 INFOPLIST_FILE = "/Users/oystein/iphone/scummvm/dists/iphone/Info copy 2.plist";
     10479                                INFOPLIST_FILE = Info.plist;
    1037210480                                LIBRARY_SEARCH_PATHS = (
    1037310481                                        "$(inherited)",
    1037410482                                        "\\\"$(SRCROOT)/../../sound/softsynth/mt32\\\"",
     
    1043610544                                );
    1043710545                                GCC_THUMB_SUPPORT = NO;
    1043810546                                GCC_UNROLL_LOOPS = YES;
    10439                                 INFOPLIST_FILE = "/Users/oystein/iphone/scummvm/dists/iphone/Info copy 2.plist";
     10547                                INFOPLIST_FILE = Info.plist;
    1044010548                                LIBRARY_SEARCH_PATHS = (
    1044110549                                        "$(inherited)",
    1044210550                                        "\\\"$(SRCROOT)/../../sound/softsynth/mt32\\\"",
  • dists/iphone/Info.plist.in

     
    2626        <string>icon.png</string>
    2727        <key>UIPrerenderedIcon</key>
    2828        <true/>
     29  <key>CFBundleURLTypes</key>
     30        <array>
     31                <dict>
     32                        <key>CFBundleURLName</key>
     33                        <string>org.scummvm.scummvm</string>
     34                        <key>CFBundleURLSchemes</key>
     35                        <array>
     36                                <string>scummvm</string>
     37                        </array>
     38                </dict>
     39        </array>
    2940</dict>
    3041</plist>
  • backends/platform/iphone/GameFileURLHandler.h

     
     1/* ScummVM - Graphic Adventure Engine
     2 *
     3 * ScummVM is the legal property of its developers, whose names
     4 * are too numerous to list here. Please refer to the COPYRIGHT
     5 * file distributed with this source distribution.
     6 *
     7 * This program is free software; you can redistribute it and/or
     8 * modify it under the terms of the GNU General Public License
     9 * as published by the Free Software Foundation; either version 2
     10 * of the License, or (at your option) any later version.
     11 
     12 * This program is distributed in the hope that it will be useful,
     13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
     14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     15 * GNU General Public License for more details.
     16 
     17 * You should have received a copy of the GNU General Public License
     18 * along with this program; if not, write to the Free Software
     19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
     20 *
     21 * $URL$
     22 * $Id$
     23 *
     24 */
     25
     26#import <UIKit/UIKit.h>
     27
     28@class ActivityIndicatorOverlay;
     29
     30@interface GameFileURLHandler : NSObject <UIAlertViewDelegate> {
     31 @private
     32  NSURL *originalUrl_;
     33  NSString *originalFileName_;
     34  NSString *finalDirectoryPath_;
     35  NSString *temporalFilePath_;
     36  NSURL *httpUrl_;
     37  UIView *mainView;
     38  ActivityIndicatorOverlay *overlay;
     39 
     40  BOOL done;
     41}
     42
     43- (id)initWithURL:(NSURL *)url;
     44
     45- (BOOL)executeHandler;
     46
     47+ (id)handlerWithURL:(NSURL *)url;
     48
     49@end
  • backends/platform/iphone/iphone_main.m

     
    2727#import <Foundation/NSThread.h>
    2828
    2929#include "iphone_video.h"
     30#include "GameFileURLHandler.h"
    3031
    3132void iphone_main(int argc, char *argv[]);
    3233
     
    119120    [self setStatusBarHidden:YES animated:YES];
    120121}
    121122
     123- (BOOL)application:(UIApplication *)application handleOpenURL:(NSURL *)url {
     124  if (!url) {
     125    return NO;
     126  }
     127 
     128  if ([[url scheme] isEqualToString:@"scummvm"]) {
     129    return [(GameFileURLHandler *)[GameFileURLHandler handlerWithURL:url]
     130            executeHandler];
     131  } else {
     132    return NO;
     133  }
     134}
     135
    122136- (void)didRotate:(NSNotification *)notification {
    123137        int screenOrientation = [[UIDevice currentDevice] orientation];
    124138        [_view deviceOrientationChanged: screenOrientation];
  • backends/platform/iphone/GameFileURLHandler.m

     
     1/* ScummVM - Graphic Adventure Engine
     2 *
     3 * ScummVM is the legal property of its developers, whose names
     4 * are too numerous to list here. Please refer to the COPYRIGHT
     5 * file distributed with this source distribution.
     6 *
     7 * This program is free software; you can redistribute it and/or
     8 * modify it under the terms of the GNU General Public License
     9 * as published by the Free Software Foundation; either version 2
     10 * of the License, or (at your option) any later version.
     11 
     12 * This program is distributed in the hope that it will be useful,
     13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
     14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     15 * GNU General Public License for more details.
     16 
     17 * You should have received a copy of the GNU General Public License
     18 * along with this program; if not, write to the Free Software
     19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
     20 *
     21 * $URL$
     22 * $Id$
     23 *
     24 */
     25
     26#import "GameFileURLHandler.h"
     27#import "NuZip/NuZip.h"
     28
     29#import <QuartzCore/QuartzCore.h>
     30
     31@interface GameFileURLHandler ()
     32
     33@property (nonatomic, retain, readonly) NSURL *httpUrl;
     34@property (nonatomic, retain, readonly) NSString *fileName;
     35@property (nonatomic, retain, readonly) NSString *finalDirectoryPath;
     36@property (nonatomic, retain, readonly) NSString *temporalFilePath;
     37
     38- (void)startDownloadingGameFile;
     39- (void)makePlaceForGameFile;
     40- (void)unzipGameFile;
     41- (void)cleanTemporalFile;
     42
     43- (void)showErrorMessage:(NSString *)errorMessage andError:(NSError *)error;
     44
     45@end
     46
     47
     48
     49// Don't bark about this method.
     50@interface UIApplication (iPhoneMainAdditions)
     51
     52- (UIView *)getView;
     53
     54@end
     55
     56
     57@interface ActivityIndicatorOverlay : UIView { }
     58
     59+ (id)overlayForView:(UIView *)view;
     60
     61- (void)fadeOverlay;
     62
     63@end
     64
     65
     66
     67
     68@implementation GameFileURLHandler
     69
     70- (id)initWithURL:(NSURL *)url {
     71  if (self = [super init]) {
     72    self->originalUrl_ = [url retain];
     73    // FIXME: Very, very coupled
     74    self->mainView = [[UIApplication sharedApplication] getView];
     75    self->done = NO;
     76  }
     77 
     78  return self;
     79}
     80
     81+ (id)handlerWithURL:(NSURL *)url {
     82  return [[[self alloc] initWithURL:url] autorelease];
     83}
     84
     85
     86- (BOOL)executeHandler {
     87  if (!self.httpUrl) {
     88    return NO;
     89  }
     90 
     91  overlay = [ActivityIndicatorOverlay overlayForView:mainView];
     92 
     93  [NSThread detachNewThreadSelector:@selector(startDownloadingGameFile)
     94                           toTarget:self
     95                         withObject:nil];
     96  // From this point, all happens in another thread, while not blocking the UI.
     97 
     98  return YES;
     99}
     100
     101#pragma mark Private methods implementation
     102
     103- (void)startDownloadingGameFile {
     104  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
     105  [self retain];
     106  NSError *error;
     107 
     108  NSData *remoteData = [[NSData alloc] initWithContentsOfURL:self.httpUrl
     109                                                     options:0
     110                                                       error:&error];
     111  if (!remoteData) {
     112    [self showErrorMessage:@"Error downloading game file" andError:error];
     113  } else {
     114    [remoteData writeToFile:self.temporalFilePath atomically:NO];
     115    [self makePlaceForGameFile];
     116  }
     117 
     118  do {
     119    CFRunLoopRunInMode(kCFRunLoopDefaultMode,
     120                       0.25,
     121                       false);
     122  } while (!done);
     123 
     124  [self release];
     125 
     126  [pool release];
     127}
     128
     129- (void)makePlaceForGameFile {
     130  NSFileManager *fileMgr = [NSFileManager defaultManager];
     131
     132  // Test if the destination path exist
     133  if ([fileMgr fileExistsAtPath:self.finalDirectoryPath]) {
     134    NSString *message = [NSString stringWithFormat:@"'%@' does already exist in"
     135                         @" your Documents directory."
     136                         @"Do you want to overwrite it?",
     137                         [self.finalDirectoryPath lastPathComponent]];
     138    UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Overwrite destination"
     139                                                       message:message
     140                                                      delegate:self
     141                                             cancelButtonTitle:@"No"
     142                                             otherButtonTitles:@"Overwrite", nil];
     143    [alertView show];
     144    [alertView release];
     145  } else {
     146    [self unzipGameFile];
     147  }
     148}
     149 
     150- (void)unzipGameFile {
     151  NSFileManager *fileMgr = [NSFileManager defaultManager];
     152  NSError *error = nil;
     153 
     154  // Erase directory contents if it already exists
     155  if ([fileMgr fileExistsAtPath:self.finalDirectoryPath]) {
     156    if (![fileMgr removeItemAtPath:self.finalDirectoryPath
     157                            error:&error]) {
     158      [self showErrorMessage:@"Error removing directory" andError:error];
     159    }
     160  }
     161 
     162  error = nil;
     163  if ([fileMgr createDirectoryAtPath:self.finalDirectoryPath
     164         withIntermediateDirectories:YES
     165                          attributes:nil
     166                               error:&error]) {
     167    // Unzip in that directory
     168    NSString *command = [[NSString alloc] initWithFormat:@"\"%@\" -d \"%@\"",
     169                         self.temporalFilePath,
     170                         self.finalDirectoryPath];
     171    if ([NuZip unzip:command] != 0) {
     172      [self showErrorMessage:@"Error uncompressing game file" andError:nil];
     173    } else {
     174      [overlay fadeOverlay];
     175    }
     176  } else {
     177    // The directory has not been created.
     178    [self showErrorMessage:@"Error creating directory" andError:error];
     179  }
     180 
     181  [self cleanTemporalFile];
     182 
     183  done = YES;
     184}
     185
     186- (void)cleanTemporalFile {
     187  NSError *error = nil;
     188  if (![[NSFileManager defaultManager] removeItemAtPath:self.temporalFilePath
     189                                                  error:&error]) {
     190    // User don't mind, but log something, just in case
     191    NSLog(@"Error removing temporal file (%@)", error);
     192  }
     193}
     194
     195- (void)showErrorMessage:(NSString *)errorMessage andError:(NSError *)error {
     196  [overlay fadeOverlay];
     197 
     198  NSString *message;
     199  if (error != nil) {
     200    message = [NSString stringWithFormat:@"%@ (%@).",
     201               errorMessage,
     202               error.localizedDescription];
     203  } else {
     204    message = [NSString stringWithFormat:@"%@.", errorMessage];
     205  }
     206  UIAlertView *alerView = [[UIAlertView alloc] initWithTitle:@"Error"
     207                                                     message:errorMessage
     208                                                    delegate:nil
     209                                           cancelButtonTitle:nil
     210                                           otherButtonTitles:@"OK", nil];
     211  [alerView show];
     212  [alerView release];
     213 
     214  done = YES;
     215}
     216
     217- (NSURL *)httpUrl {
     218  static const unichar kSlash = 0x002F;
     219  if (!httpUrl_) {
     220    NSString *urlString = [originalUrl_ absoluteString];
     221    // Remove the protocol, the colon and the resource specifier (if there is one)
     222    if ([urlString characterAtIndex:8] == kSlash &&
     223        [urlString characterAtIndex:9] == kSlash) {
     224      urlString = [urlString substringFromIndex:10];
     225    } else {
     226      urlString = [urlString substringFromIndex:8];
     227    }
     228   
     229    httpUrl_ = [[NSURL alloc] initWithString:
     230                [NSString stringWithFormat:@"http://%@", urlString]];
     231  }
     232 
     233  return httpUrl_;
     234}
     235
     236- (NSString *)fileName {
     237  if (!originalFileName_) {
     238    originalFileName_ = [[self.httpUrl path] lastPathComponent];
     239  }
     240 
     241  return originalFileName_;
     242}
     243
     244- (NSString *)finalDirectoryPath {
     245  if (!finalDirectoryPath_) {
     246    // Search for a good place to unzip the results
     247    NSArray *documentPaths =
     248      NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,
     249                                          NSUserDomainMask,
     250                                          YES);
     251    NSString *directoryName = [self.fileName stringByDeletingPathExtension];
     252    if ([documentPaths count] != 0) {
     253      finalDirectoryPath_ = [[documentPaths objectAtIndex:0]
     254                             stringByAppendingPathComponent:directoryName];
     255    } else {
     256      // Unzip in temp directory, but the user will not look for it there
     257      finalDirectoryPath_ = [NSTemporaryDirectory() stringByAppendingPathComponent:
     258                             directoryName];
     259    }
     260  }
     261 
     262  return finalDirectoryPath_;
     263}
     264
     265- (NSString *)temporalFilePath {
     266  if (!temporalFilePath_) {
     267    temporalFilePath_ = [NSTemporaryDirectory()
     268                         stringByAppendingPathComponent:self.fileName];
     269  }
     270 
     271  return temporalFilePath_;
     272}
     273
     274#pragma mark UIAlerViewDelegate implementation
     275
     276- (void)alertView:(UIAlertView *)alerView
     277clickedButtonAtIndex:(NSInteger)buttonIndex {
     278  if (buttonIndex == 0) { // Cancel
     279    [self cleanTemporalFile];
     280  } else if (buttonIndex == 1) { // Overwrite
     281    [self unzipGameFile];
     282  }
     283}
     284
     285@end
     286
     287
     288// The part below uses code from a third party, and this copyright notice is
     289// needed.
     290
     291//  Copyright Matt Gallagher 2009. All rights reserved.
     292//
     293//  Permission is given to use this source code file, free of charge, in any
     294//  project, commercial or otherwise, entirely at your risk, with the condition
     295//  that any redistribution (in part or whole) of source code must retain
     296//  this copyright and permission notice. Attribution in compiled projects is
     297//  appreciated but not required.
     298//
     299
     300@implementation ActivityIndicatorOverlay
     301
     302+ (id)overlayForView:(UIView *)view {
     303  ActivityIndicatorOverlay *overlay = [[[ActivityIndicatorOverlay alloc]
     304                                        initWithFrame:[view bounds]]
     305                                       autorelease];
     306  if (!overlay) {
     307    return nil;
     308  }
     309 
     310  overlay.opaque = NO;
     311  overlay.autoresizingMask = UIViewAutoresizingFlexibleWidth;
     312  overlay.autoresizingMask |= UIViewAutoresizingFlexibleHeight;
     313  [view addSubview:overlay];
     314 
     315  UIActivityIndicatorView *activityIndicator =
     316    [[[UIActivityIndicatorView alloc]
     317      initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge]
     318     autorelease];
     319  [overlay addSubview:activityIndicator];
     320  activityIndicator.autoresizingMask = UIViewAutoresizingFlexibleLeftMargin;
     321  activityIndicator.autoresizingMask |= UIViewAutoresizingFlexibleRightMargin;
     322  activityIndicator.autoresizingMask |= UIViewAutoresizingFlexibleTopMargin;
     323  activityIndicator.autoresizingMask |= UIViewAutoresizingFlexibleBottomMargin;
     324  [activityIndicator startAnimating];
     325 
     326  CGRect activityIndicatorRect = activityIndicator.frame;
     327  activityIndicatorRect.origin.x =
     328    0.5 * (overlay.frame.size.width - activityIndicatorRect.size.width);
     329  activityIndicatorRect.origin.y =
     330    0.5 * (overlay.frame.size.height - activityIndicatorRect.size.height);
     331  activityIndicator.frame = activityIndicatorRect;
     332 
     333  CATransition *animation = [CATransition animation];
     334  [animation setType:kCATransitionFade];
     335  [[view layer] addAnimation:animation forKey:@"layerAnimation"];
     336 
     337  return overlay;
     338}
     339
     340- (void)fadeOverlay {
     341  UIView *view = [self superview];
     342  [super removeFromSuperview];
     343 
     344  CATransition *animation = [CATransition animation];
     345  [animation setType:kCATransitionFade];
     346  [[view layer] addAnimation:animation forKey:@"layerAnimation"];
     347}
     348
     349- (void)drawRect:(CGRect)rect {
     350  rect.size.height -= 1;
     351  rect.size.width -= 1;
     352 
     353  static const CGFloat kRectPadding = 8.0;
     354  rect = CGRectInset(rect, kRectPadding, kRectPadding);
     355 
     356  CGContextRef context = UIGraphicsGetCurrentContext();
     357 
     358  static const CGFloat kBackgroundOpacity = 0.85;
     359  CGContextSetRGBFillColor(context, 0, 0, 0, kBackgroundOpacity);
     360  CGContextFillRect(context, rect);
     361 
     362  static const CGFloat kStrokeOpacity = 0.25;
     363  CGContextSetRGBStrokeColor(context, 1, 1, 1, kStrokeOpacity);
     364  CGContextStrokeRect(context, rect);
     365}
     366
     367@end
     368
  • backends/platform/iphone/nuzip/NuZip.m

     
     1/*!
     2 @file NuZip.m
     3 @discussion Objective-C wrapper for Gilles Vollant's Minizip library.
     4 @copyright Copyright (c) 2008 Neon Design Technology, Inc.
     5 
     6 Licensed under the Apache License, Version 2.0 (the "License");
     7 you may not use this file except in compliance with the License.
     8 You may obtain a copy of the License at
     9 
     10 http://www.apache.org/licenses/LICENSE-2.0
     11 
     12 Unless required by applicable law or agreed to in writing, software
     13 distributed under the License is distributed on an "AS IS" BASIS,
     14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     15 See the License for the specific language governing permissions and
     16 limitations under the License.
     17 */
     18
     19#import "NuZip.h"
     20
     21static int opt_quiet = 0;
     22int nuzip_printf(const char *format, ...)
     23{
     24  if (!opt_quiet) {
     25    va_list ap;
     26    va_start(ap, format);
     27    vprintf(format, ap);
     28    va_end(ap);
     29  }
     30}
     31
     32int unzip_main(int argc, char *argv[]);
     33
     34int zip_main(int argc, char *argv[]);
     35
     36@interface NSString (NZShellSplit)
     37
     38/*
     39 * Split a string as a shell command line.
     40 * Split the string using the common rules used by shells. It will use
     41 * spaces as shell separators, unless those spaces are in a single or
     42 * double quoted argument. It will also avoid using escaped quotes as
     43 * the start or end of a quoted argument.
     44 */
     45- (NSArray *)componentsSeparatedByShell;
     46
     47@end
     48
     49
     50
     51@implementation NuZip
     52
     53+ (int) unzip:(NSString *) command
     54{
     55  NSArray *args = [command componentsSeparatedByShell];
     56  int argc = [args count];
     57  char **argv = (char **) malloc ([args count] * sizeof (char *));
     58  int i;
     59  for (i = 0; i < argc; i++) {
     60    argv[i] = strdup([[args objectAtIndex:i] cStringUsingEncoding:NSUTF8StringEncoding]);
     61  }
     62  int result = unzip_main(argc, argv);
     63  for (i = 0; i < argc; i++) {
     64    free(argv[i]);
     65  }
     66  free(argv);
     67  return result;
     68}
     69
     70+ (int) zip:(NSString *) command
     71{
     72  NSArray *args = [command componentsSeparatedByString:@" "];
     73  int argc = [args count];
     74  char **argv = (char **) malloc ([args count] * sizeof (char *));
     75  int i;
     76  for (i = 0; i < argc; i++) {
     77    argv[i] = strdup([[args objectAtIndex:i] cStringUsingEncoding:NSUTF8StringEncoding]);
     78  }
     79  int result = zip_main(argc, argv);
     80  for (i = 0; i < argc; i++) {
     81    free(argv[i]);
     82  }
     83  free(argv);
     84  return result;
     85}
     86
     87@end
     88
     89
     90
     91static const unichar kSpace = 0x0020;
     92static const unichar kDoubleQuote = 0x0022;
     93static const unichar kSingleQuote = 0x0027;
     94static const unichar kBackslash = 0x005C;
     95
     96@implementation NSString (NZShellSplit)
     97
     98- (NSArray *)componentsSeparatedByShell {
     99  NSUInteger current = 0;
     100  NSUInteger length = [self length];
     101  NSMutableArray *arguments = [[NSMutableArray alloc] init];
     102  unichar ch, endingQuote;
     103 
     104  while (current < length) {
     105    NSMutableString *argument = [[NSMutableString alloc] init];
     106   
     107    while (current < length) {
     108      ch = [self characterAtIndex:current++];
     109     
     110      CFMutableStringRef part = CFStringCreateMutable(NULL, 0);
     111      if (ch == kDoubleQuote || ch == kSingleQuote) {
     112        endingQuote = ch;
     113       
     114        while (current < length) {
     115          ch = [self characterAtIndex:current++];
     116         
     117          if (ch == endingQuote) {
     118            break;
     119          } else if (ch == kBackslash) {
     120            if (current < length) { // Slash at the end of the string?
     121              ch = [self characterAtIndex:current++];
     122            }
     123            CFStringAppendCharacters(part, &ch, 1);
     124          } else {
     125            CFStringAppendCharacters(part, &ch, 1);
     126          }
     127        }
     128       
     129        if (current >= length && ch != endingQuote) {
     130          NSString *reason =
     131          [NSString stringWithFormat:@"Unmatched quote <%C>",
     132           endingQuote];
     133          @throw [NSException exceptionWithName:NSInvalidArgumentException
     134                                         reason:reason
     135                                       userInfo:nil];
     136        }
     137      } else if (ch == kBackslash) {
     138        if (current >= length) { // Slash at the end of the string
     139          ch = kBackslash;
     140        } else {
     141          ch = [self characterAtIndex:current++];
     142        }
     143        CFStringAppendCharacters(part, &ch, 1);
     144      } else if (ch != kSpace && ch != kBackslash &&
     145                 ch != kDoubleQuote && ch != kSingleQuote) {
     146        CFStringAppendCharacters(part, &ch, 1);
     147        while (current < length) {
     148          ch = [self characterAtIndex:current++];
     149          if (ch == kSpace || ch == kBackslash ||
     150              ch == kDoubleQuote || ch == kSingleQuote) {
     151            current--; // Otherwise we will jump over the character.
     152            break;
     153          } else {
     154            CFStringAppendCharacters(part, &ch, 1);
     155          }
     156        }
     157      } else { // it has to be a space (or more), ignore them
     158        while (current < length &&
     159               ((ch = [self characterAtIndex:current++]) == kSpace)) {
     160          // do nothing
     161        }
     162        if (current < length) {
     163          current--; // Unread last read character.
     164        }
     165        CFRelease(part);
     166        break;
     167      }
     168     
     169      [argument appendString:(NSString *)part];
     170      CFRelease(part);
     171    }
     172   
     173    [arguments addObject:[[argument copy] autorelease]];
     174    [argument release];
     175  }
     176 
     177  NSArray *returnValue = [arguments copy];
     178  [arguments release];
     179  return [returnValue autorelease];
     180}
     181
     182@end
     183
     184
     185
     186/*
     187 miniunz.c
     188 Version 1.01e, February 12th, 2005
     189 
     190 Copyright (C) 1998-2005 Gilles Vollant
     191 */
     192
     193#include <stdio.h>
     194#include <stdlib.h>
     195#include <string.h>
     196#include <time.h>
     197#include <errno.h>
     198#include <fcntl.h>
     199# include <sys/stat.h>
     200
     201# include <unistd.h>
     202# include <utime.h>
     203
     204#include "unzip.h"
     205#include "zip.h"
     206
     207#define CASESENSITIVITY (0)
     208#define MAXFILENAME (256)
     209#define WRITEBUFFERSIZE (16384)
     210
     211/*
     212 mini unzip, demo of unzip package
     213 
     214 usage :
     215 Usage : miniunz [-exvlo] file.zip [file_to_extract] [-d extractdir]
     216 
     217 list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT
     218 if it exists
     219 */
     220
     221/* change_file_date : change the date/time of a file
     222 filename : the filename of the file where date/time must be modified
     223 dosdate : the new date at the MSDos format (4 bytes)
     224 tmu_date : the SAME new date at the tm_unz format */
     225void change_file_date(const char *filename, uLong dosdate, tm_unz tmu_date)
     226{
     227  struct utimbuf ut;
     228  struct tm newdate;
     229  newdate.tm_sec = tmu_date.tm_sec;
     230  newdate.tm_min=tmu_date.tm_min;
     231  newdate.tm_hour=tmu_date.tm_hour;
     232  newdate.tm_mday=tmu_date.tm_mday;
     233  newdate.tm_mon=tmu_date.tm_mon;
     234  if (tmu_date.tm_year > 1900)
     235    newdate.tm_year=tmu_date.tm_year - 1900;
     236  else
     237    newdate.tm_year=tmu_date.tm_year ;
     238  newdate.tm_isdst=-1;
     239 
     240  ut.actime=ut.modtime=mktime(&newdate);
     241  utime(filename,&ut);
     242}
     243
     244/* mymkdir and change_file_date are not 100 % portable
     245 As I don't know well Unix, I wait feedback for the unix portion */
     246
     247int mymkdir(const char *dirname)
     248{
     249  int ret=0;
     250  ret = mkdir (dirname,0775);
     251  return ret;
     252}
     253
     254int makedir (char *newdir)
     255{
     256  char *buffer ;
     257  char *p;
     258  int  len = (int)strlen(newdir);
     259 
     260  if (len <= 0)
     261    return 0;
     262 
     263  buffer = (char*)malloc(len+1);
     264  strcpy(buffer,newdir);
     265 
     266  if (buffer[len-1] == '/') {
     267    buffer[len-1] = '\0';
     268  }
     269  if (mymkdir(buffer) == 0) {
     270    free(buffer);
     271    return 1;
     272  }
     273 
     274  p = buffer+1;
     275  while (1) {
     276    char hold;
     277   
     278    while(*p && *p != '\\' && *p != '/')
     279      p++;
     280    hold = *p;
     281    *p = 0;
     282    if ((mymkdir(buffer) == -1) && (errno == ENOENT)) {
     283      nuzip_printf("couldn't create directory %s\n",buffer);
     284      free(buffer);
     285      return 0;
     286    }
     287    if (hold == 0)
     288      break;
     289    *p++ = hold;
     290  }
     291  free(buffer);
     292  return 1;
     293}
     294
     295void do_unzip_banner()
     296{
     297  nuzip_printf("MiniUnz 1.01b, demo of zLib + Unz package written by Gilles Vollant\n");
     298  nuzip_printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
     299}
     300
     301void do_unzip_help()
     302{
     303  nuzip_printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.] [-d extractdir]\n\n" \
     304               "  -e  Extract without pathname (junk paths)\n" \
     305               "  -x  Extract with pathname\n" \
     306               "  -v  list files\n" \
     307               "  -l  list files\n" \
     308               "  -d  directory to extract into\n" \
     309               "  -o  overwrite files without prompting\n" \
     310               "  -p  extract crypted file using password\n\n");
     311}
     312
     313int do_list(unzFile uf)
     314{
     315  uLong i;
     316  unz_global_info gi;
     317  int err;
     318 
     319  err = unzGetGlobalInfo (uf,&gi);
     320  if (err!=UNZ_OK)
     321    nuzip_printf("error %d with zipfile in unzGetGlobalInfo \n",err);
     322  nuzip_printf(" Length  Method   Size  Ratio   Date    Time   CRC-32     Name\n");
     323  nuzip_printf(" ------  ------   ----  -----   ----    ----   ------     ----\n");
     324  for (i=0;i<gi.number_entry;i++) {
     325    char filename_inzip[256];
     326    unz_file_info file_info;
     327    uLong ratio=0;
     328    const char *string_method;
     329    char charCrypt=' ';
     330    err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
     331    if (err!=UNZ_OK) {
     332      nuzip_printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
     333      break;
     334    }
     335    if (file_info.uncompressed_size>0)
     336      ratio = (file_info.compressed_size*100)/file_info.uncompressed_size;
     337   
     338    /* display a '*' if the file is crypted */
     339    if ((file_info.flag & 1) != 0)
     340      charCrypt='*';
     341   
     342    if (file_info.compression_method==0)
     343      string_method="Stored";
     344    else
     345      if (file_info.compression_method==Z_DEFLATED) {
     346        uInt iLevel=(uInt)((file_info.flag & 0x6)/2);
     347        if (iLevel==0)
     348          string_method="Defl:N";
     349        else if (iLevel==1)
     350          string_method="Defl:X";
     351        else if ((iLevel==2) || (iLevel==3))
     352          string_method="Defl:F";           /* 2:fast , 3 : extra fast*/
     353      }
     354      else
     355        string_method="Unkn. ";
     356   
     357    nuzip_printf("%7lu  %6s%c%7lu %3lu%%  %2.2lu-%2.2lu-%2.2lu  %2.2lu:%2.2lu  %8.8lx   %s\n",
     358                 file_info.uncompressed_size,string_method,
     359                 charCrypt,
     360                 file_info.compressed_size,
     361                 ratio,
     362                 (uLong)file_info.tmu_date.tm_mon + 1,
     363                 (uLong)file_info.tmu_date.tm_mday,
     364                 (uLong)file_info.tmu_date.tm_year % 100,
     365                 (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min,
     366                 (uLong)file_info.crc,filename_inzip);
     367    if ((i+1)<gi.number_entry) {
     368      err = unzGoToNextFile(uf);
     369      if (err!=UNZ_OK) {
     370        nuzip_printf("error %d with zipfile in unzGoToNextFile\n",err);
     371        break;
     372      }
     373    }
     374  }
     375 
     376  return 0;
     377}
     378
     379int do_extract_currentfile(unzFile uf, const int *popt_extract_without_path, int *popt_overwrite, const char *password)
     380{
     381  char filename_inzip[256];
     382  char* filename_withoutpath;
     383  char* p;
     384  int err=UNZ_OK;
     385  FILE *fout=NULL;
     386  void* buf;
     387  uInt size_buf;
     388 
     389  unz_file_info file_info;
     390  uLong ratio=0;
     391  err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
     392 
     393  if (err!=UNZ_OK) {
     394    nuzip_printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
     395    return err;
     396  }
     397 
     398  size_buf = WRITEBUFFERSIZE;
     399  buf = (void*)malloc(size_buf);
     400  if (buf==NULL) {
     401    nuzip_printf("Error allocating memory\n");
     402    return UNZ_INTERNALERROR;
     403  }
     404 
     405  p = filename_withoutpath = filename_inzip;
     406  while ((*p) != '\0') {
     407    if (((*p)=='/') || ((*p)=='\\'))
     408      filename_withoutpath = p+1;
     409    p++;
     410  }
     411 
     412  if ((*filename_withoutpath)=='\0') {
     413    if ((*popt_extract_without_path)==0) {
     414      nuzip_printf("creating directory: %s\n",filename_inzip);
     415      mymkdir(filename_inzip);
     416    }
     417  }
     418  else {
     419    char* write_filename;
     420    int skip=0;
     421   
     422    if ((*popt_extract_without_path)==0)
     423      write_filename = filename_inzip;
     424    else
     425      write_filename = filename_withoutpath;
     426   
     427    err = unzOpenCurrentFilePassword(uf,password);
     428    if (err!=UNZ_OK) {
     429      nuzip_printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
     430    }
     431   
     432    if (((*popt_overwrite)==0) && (err==UNZ_OK)) {
     433      char rep=0;
     434      FILE* ftestexist;
     435      ftestexist = fopen(write_filename,"rb");
     436      if (ftestexist!=NULL) {
     437        fclose(ftestexist);
     438        do {
     439          char answer[128];
     440          int ret;
     441         
     442          nuzip_printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
     443          ret = scanf("%1s",answer);
     444          if (ret != 1) {
     445            return(EXIT_FAILURE);
     446          }
     447          rep = answer[0] ;
     448          if ((rep>='a') && (rep<='z'))
     449            rep -= 0x20;
     450        }
     451        while ((rep!='Y') && (rep!='N') && (rep!='A'));
     452      }
     453     
     454      if (rep == 'N')
     455        skip = 1;
     456     
     457      if (rep == 'A')
     458        *popt_overwrite=1;
     459    }
     460   
     461    if ((skip==0) && (err==UNZ_OK)) {
     462      fout=fopen(write_filename,"wb");
     463     
     464      /* some zipfile don't contain directory alone before file */
     465      if ((fout==NULL) && ((*popt_extract_without_path)==0) &&
     466          (filename_withoutpath!=(char*)filename_inzip)) {
     467        char c=*(filename_withoutpath-1);
     468        *(filename_withoutpath-1)='\0';
     469        makedir(write_filename);
     470        *(filename_withoutpath-1)=c;
     471        fout=fopen(write_filename,"wb");
     472      }
     473     
     474      if (fout==NULL) {
     475        nuzip_printf("error opening %s\n",write_filename);
     476      }
     477    }
     478   
     479    if (fout!=NULL) {
     480      nuzip_printf(" extracting: %s\n",write_filename);
     481     
     482      do {
     483        err = unzReadCurrentFile(uf,buf,size_buf);
     484        if (err<0) {
     485          nuzip_printf("error %d with zipfile in unzReadCurrentFile\n",err);
     486          break;
     487        }
     488        if (err>0)
     489          if (fwrite(buf,err,1,fout)!=1) {
     490            nuzip_printf("error in writing extracted file\n");
     491            err=UNZ_ERRNO;
     492            break;
     493          }
     494      }
     495      while (err>0);
     496      if (fout)
     497        fclose(fout);
     498     
     499      if (err==0)
     500        change_file_date(write_filename,file_info.dosDate,
     501                         file_info.tmu_date);
     502    }
     503   
     504    if (err==UNZ_OK) {
     505      err = unzCloseCurrentFile (uf);
     506      if (err!=UNZ_OK) {
     507        nuzip_printf("error %d with zipfile in unzCloseCurrentFile\n",err);
     508      }
     509    }
     510    else
     511      unzCloseCurrentFile(uf);              /* don't lose the error */
     512  }
     513 
     514  free(buf);
     515  return err;
     516}
     517
     518int do_extract(unzFile uf, int opt_extract_without_path, int opt_overwrite, const char *password)
     519{
     520  uLong i;
     521  unz_global_info gi;
     522  int err;
     523  FILE* fout=NULL;
     524 
     525  err = unzGetGlobalInfo (uf,&gi);
     526  if (err!=UNZ_OK)
     527    nuzip_printf("error %d with zipfile in unzGetGlobalInfo \n",err);
     528 
     529  for (i=0;i<gi.number_entry;i++) {
     530    if (do_extract_currentfile(uf,&opt_extract_without_path,
     531                               &opt_overwrite,
     532                               password) != UNZ_OK)
     533      break;
     534   
     535    if ((i+1)<gi.number_entry) {
     536      err = unzGoToNextFile(uf);
     537      if (err!=UNZ_OK) {
     538        nuzip_printf("error %d with zipfile in unzGoToNextFile\n",err);
     539        break;
     540      }
     541    }
     542  }
     543 
     544  return 0;
     545}
     546
     547int do_extract_onefile(unzFile uf, const char *filename, int opt_extract_without_path, int opt_overwrite, const char *password)
     548{
     549  int err = UNZ_OK;
     550  if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK) {
     551    nuzip_printf("file %s not found in the zipfile\n",filename);
     552    return 2;
     553  }
     554 
     555  if (do_extract_currentfile(uf,&opt_extract_without_path,
     556                             &opt_overwrite,
     557                             password) == UNZ_OK)
     558    return 0;
     559  else
     560    return 1;
     561}
     562
     563int unzip_main(int argc, char *argv[])
     564{
     565  const char *zipfilename=NULL;
     566  const char *filename_to_extract=NULL;
     567  const char *password=NULL;
     568  char filename_try[MAXFILENAME+16] = "";
     569  int i;
     570  int opt_do_list=0;
     571  int opt_do_extract=1;
     572  int opt_do_extract_withoutpath=0;
     573  int opt_overwrite=0;
     574  int opt_extractdir=0;
     575  const char *dirname=NULL;
     576  unzFile uf=NULL;
     577  opt_quiet = 0;
     578 
     579  if (argc==0) {
     580    do_unzip_help();
     581    return 0;
     582  }
     583  else {
     584    for (i=0;i<argc;i++) {
     585      if ((*argv[i])=='-') {
     586        const char *p=argv[i]+1;
     587       
     588        while ((*p)!='\0') {
     589          char c=*(p++);;
     590          if ((c=='q') || (c=='Q'))
     591            opt_quiet = 1;
     592          if ((c=='l') || (c=='L'))
     593            opt_do_list = 1;
     594          if ((c=='v') || (c=='V'))
     595            opt_do_list = 1;
     596          if ((c=='x') || (c=='X'))
     597            opt_do_extract = 1;
     598          if ((c=='e') || (c=='E'))
     599            opt_do_extract = opt_do_extract_withoutpath = 1;
     600          if ((c=='o') || (c=='O'))
     601            opt_overwrite=1;
     602          if ((c=='d') || (c=='D')) {
     603            opt_extractdir=1;
     604            dirname=argv[i+1];
     605          }
     606         
     607          if (((c=='p') || (c=='P')) && (i+1<argc)) {
     608            password=argv[i+1];
     609            i++;
     610          }
     611        }
     612      }
     613      else {
     614        if (zipfilename == NULL)
     615          zipfilename = argv[i];
     616        else if ((filename_to_extract==NULL) && (!opt_extractdir))
     617          filename_to_extract = argv[i] ;
     618      }
     619    }
     620  }
     621 
     622  if (zipfilename!=NULL) {
     623    strncpy(filename_try, zipfilename,MAXFILENAME-1);
     624    /* strncpy doesnt append the trailing NULL, of the string is too long. */
     625    filename_try[ MAXFILENAME ] = '\0';
     626    uf = unzOpen(zipfilename);
     627    if (uf==NULL) {
     628      strcat(filename_try,".zip");
     629     
     630      uf = unzOpen(filename_try);
     631    }
     632  }
     633 
     634  if (uf == NULL) {
     635    nuzip_printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename);
     636    return 1;
     637  }
     638  nuzip_printf("%s opened\n",filename_try);
     639 
     640  if (opt_do_list==1)
     641    return do_list(uf);
     642  else if (opt_do_extract==1) {
     643    char originaldirname[1024];               // watch out!
     644    if (opt_extractdir)
     645      getcwd(originaldirname, 1024);
     646    if (opt_extractdir && chdir(dirname)) {
     647      nuzip_printf("Error changing into %s, aborting\n", dirname);
     648      return(-1);
     649    }
     650    int result;
     651    if (filename_to_extract == NULL)
     652      result = do_extract(uf, opt_do_extract_withoutpath, opt_overwrite,password);
     653    else
     654      result = do_extract_onefile(uf, filename_to_extract, opt_do_extract_withoutpath,opt_overwrite,password);
     655    if (opt_extractdir) {
     656      chdir(originaldirname);
     657    }
     658    return result;
     659   
     660  }
     661  unzCloseCurrentFile(uf);
     662 
     663  return 0;
     664}
     665
     666/*
     667 minizip.c
     668 Version 1.01e, February 12th, 2005
     669 
     670 Copyright (C) 1998-2005 Gilles Vollant
     671 */
     672
     673uLong filetime(char *f, tm_zip *tmzip, uLong *dt)
     674{
     675  int ret=0;
     676  struct stat s;                                /* results of stat() */
     677  struct tm* filedate;
     678  time_t tm_t=0;
     679 
     680  if (strcmp(f,"-")!=0) {
     681    char name[MAXFILENAME+1];
     682    int len = strlen(f);
     683    if (len > MAXFILENAME)
     684      len = MAXFILENAME;
     685   
     686    strncpy(name, f,MAXFILENAME-1);
     687    /* strncpy doesnt append the trailing NULL, of the string is too long. */
     688    name[ MAXFILENAME ] = '\0';
     689   
     690    if (name[len - 1] == '/')
     691      name[len - 1] = '\0';
     692    /* not all systems allow stat'ing a file with / appended */
     693    if (stat(name,&s)==0) {
     694      tm_t = s.st_mtime;
     695      ret = 1;
     696    }
     697  }
     698  filedate = localtime(&tm_t);
     699 
     700  tmzip->tm_sec  = filedate->tm_sec;
     701  tmzip->tm_min  = filedate->tm_min;
     702  tmzip->tm_hour = filedate->tm_hour;
     703  tmzip->tm_mday = filedate->tm_mday;
     704  tmzip->tm_mon  = filedate->tm_mon ;
     705  tmzip->tm_year = filedate->tm_year;
     706 
     707  return ret;
     708}
     709
     710int check_exist_file(const char *filename)
     711{
     712  FILE* ftestexist;
     713  int ret = 1;
     714  ftestexist = fopen(filename,"rb");
     715  if (ftestexist==NULL)
     716    ret = 0;
     717  else
     718    fclose(ftestexist);
     719  return ret;
     720}
     721
     722void do_zip_help()
     723{
     724  nuzip_printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \
     725               "  -o  Overwrite existing file.zip\n" \
     726               "  -a  Append to existing file.zip\n" \
     727               "  -0  Store only\n" \
     728               "  -1  Compress faster\n" \
     729               "  -9  Compress better\n\n");
     730}
     731
     732/* calculate the CRC32 of a file,
     733 because to encrypt a file, we need known the CRC32 of the file before */
     734int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
     735{
     736  unsigned long calculate_crc=0;
     737  int err=ZIP_OK;
     738  FILE * fin = fopen(filenameinzip,"rb");
     739  unsigned long size_read = 0;
     740  unsigned long total_read = 0;
     741  if (fin==NULL) {
     742    err = ZIP_ERRNO;
     743  }
     744 
     745  if (err == ZIP_OK)
     746    do {
     747      err = ZIP_OK;
     748      size_read = (int)fread(buf,1,size_buf,fin);
     749      if (size_read < size_buf)
     750        if (feof(fin)==0) {
     751          nuzip_printf("error in reading %s\n",filenameinzip);
     752          err = ZIP_ERRNO;
     753        }
     754     
     755      if (size_read>0)
     756        calculate_crc = crc32(calculate_crc,buf,size_read);
     757      total_read += size_read;
     758     
     759    } while ((err == ZIP_OK) && (size_read>0));
     760 
     761  if (fin)
     762    fclose(fin);
     763 
     764  *result_crc=calculate_crc;
     765  nuzip_printf("file %s crc %x\n",filenameinzip,calculate_crc);
     766  return err;
     767}
     768
     769int zip_main(int argc,char *argv[])
     770{
     771  int i;
     772  int opt_overwrite=0;
     773  int opt_compress_level=Z_DEFAULT_COMPRESSION;
     774  int zipfilenamearg = 0;
     775  opt_quiet = 0;
     776  char filename_try[MAXFILENAME+16];
     777  int zipok;
     778  int err=0;
     779  int size_buf=0;
     780  void* buf=NULL;
     781  const char* password=NULL;
     782 
     783  if (argc==0) {
     784    do_zip_help();
     785    return 0;
     786  }
     787  else {
     788    for (i=0;i<argc;i++) {
     789      if ((*argv[i])=='-') {
     790        const char *p=argv[i]+1;
     791       
     792        while ((*p)!='\0') {
     793          char c=*(p++);;
     794          if ((c=='q') || (c=='Q'))
     795            opt_quiet = 1;
     796          if ((c=='o') || (c=='O'))
     797            opt_overwrite = 1;
     798          if ((c=='a') || (c=='A'))
     799            opt_overwrite = 2;
     800          if ((c>='0') && (c<='9'))
     801            opt_compress_level = c-'0';
     802         
     803          if (((c=='p') || (c=='P')) && (i+1<argc)) {
     804            password=argv[i+1];
     805            i++;
     806          }
     807        }
     808      }
     809      else
     810        if (zipfilenamearg == 0)
     811          zipfilenamearg = i ;
     812    }
     813  }
     814 
     815  size_buf = WRITEBUFFERSIZE;
     816  buf = (void*)malloc(size_buf);
     817  if (buf==NULL) {
     818    nuzip_printf("Error allocating memory\n");
     819    return ZIP_INTERNALERROR;
     820  }
     821 
     822  if (zipfilenamearg==0)
     823    zipok=0;
     824  else {
     825    int i,len;
     826    int dot_found=0;
     827   
     828    zipok = 1 ;
     829    strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
     830    /* strncpy doesnt append the trailing NULL, of the string is too long. */
     831    filename_try[ MAXFILENAME ] = '\0';
     832   
     833    len=(int)strlen(filename_try);
     834    for (i=0;i<len;i++)
     835      if (filename_try[i]=='.')
     836        dot_found=1;
     837   
     838    if (dot_found==0)
     839      strcat(filename_try,".zip");
     840   
     841    if (opt_overwrite==2) {
     842      /* if the file don't exist, we not append file */
     843      if (check_exist_file(filename_try)==0)
     844        opt_overwrite=1;
     845    }
     846    else
     847      if (opt_overwrite==0)
     848        if (check_exist_file(filename_try)!=0) {
     849          char rep=0;
     850          do {
     851            char answer[128];
     852            int ret;
     853            nuzip_printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
     854            ret = scanf("%1s",answer);
     855            if (ret != 1) {
     856              exit(EXIT_FAILURE);
     857            }
     858            rep = answer[0] ;
     859            if ((rep>='a') && (rep<='z'))
     860              rep -= 0x20;
     861          }
     862          while ((rep!='Y') && (rep!='N') && (rep!='A'));
     863          if (rep=='N')
     864            zipok = 0;
     865          if (rep=='A')
     866            opt_overwrite = 2;
     867        }
     868  }
     869 
     870  if (zipok==1) {
     871    zipFile zf;
     872    int errclose;
     873   
     874    zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
     875   
     876    if (zf == NULL) {
     877      nuzip_printf("error opening %s\n",filename_try);
     878      err= ZIP_ERRNO;
     879    }
     880    else
     881      nuzip_printf("creating %s\n",filename_try);
     882   
     883    for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++) {
     884      if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) &&
     885            ((argv[i][1]=='o') || (argv[i][1]=='O') ||
     886             (argv[i][1]=='a') || (argv[i][1]=='A') ||
     887             (argv[i][1]=='p') || (argv[i][1]=='P') ||
     888             ((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
     889            (strlen(argv[i]) == 2))) {
     890        FILE * fin;
     891        int size_read;
     892        char* filenameinzip = argv[i];
     893        zip_fileinfo zi;
     894        unsigned long crcFile=0;
     895       
     896        zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
     897        zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
     898        zi.dosDate = 0;
     899        zi.internal_fa = 0;
     900        zi.external_fa = 0;
     901        filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
     902       
     903        /*
     904         err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
     905         NULL,0,NULL,0,NULL / * comment * /,
     906         (opt_compress_level != 0) ? Z_DEFLATED : 0,
     907         opt_compress_level);
     908         */
     909        if ((password != NULL) && (err==ZIP_OK))
     910          err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
     911       
     912        err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
     913                                   NULL,0,NULL,0,NULL /* comment*/,
     914                                   (opt_compress_level != 0) ? Z_DEFLATED : 0,
     915                                   opt_compress_level,0,
     916                                   /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
     917                                   -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
     918                                   password,crcFile);
     919       
     920        if (err != ZIP_OK)
     921          nuzip_printf("error in opening %s in zipfile\n",filenameinzip);
     922        else {
     923          fin = fopen(filenameinzip,"rb");
     924          if (fin==NULL) {
     925            err=ZIP_ERRNO;
     926            nuzip_printf("error in opening %s for reading\n",filenameinzip);
     927          }
     928        }
     929       
     930        if (err == ZIP_OK)
     931          do {
     932            err = ZIP_OK;
     933            size_read = (int)fread(buf,1,size_buf,fin);
     934            if (size_read < size_buf)
     935              if (feof(fin)==0) {
     936                nuzip_printf("error in reading %s\n",filenameinzip);
     937                err = ZIP_ERRNO;
     938              }
     939           
     940            if (size_read>0) {
     941              err = zipWriteInFileInZip (zf,buf,size_read);
     942              if (err<0) {
     943                nuzip_printf("error in writing %s in the zipfile\n",
     944                             filenameinzip);
     945              }
     946             
     947            }
     948          } while ((err == ZIP_OK) && (size_read>0));
     949       
     950        if (fin)
     951          fclose(fin);
     952       
     953        if (err<0)
     954          err=ZIP_ERRNO;
     955        else {
     956          err = zipCloseFileInZip(zf);
     957          if (err!=ZIP_OK)
     958            nuzip_printf("error in closing %s in the zipfile\n",
     959                         filenameinzip);
     960        }
     961      }
     962    }
     963    errclose = zipClose(zf,NULL);
     964    if (errclose != ZIP_OK)
     965      nuzip_printf("error in closing %s\n",filename_try);
     966  }
     967  else {
     968    do_zip_help();
     969  }
     970 
     971  free(buf);
     972  return 0;
     973}
  • backends/platform/iphone/nuzip/ioapi.c

     
     1/* ioapi.c -- IO base function header for compress/uncompress .zip
     2   files using zlib + zip or unzip API
     3
     4   Version 1.01e, February 12th, 2005
     5
     6   Copyright (C) 1998-2005 Gilles Vollant
     7*/
     8
     9#include <stdio.h>
     10#include <stdlib.h>
     11#include <string.h>
     12
     13#include <zlib.h>
     14#include "ioapi.h"
     15
     16
     17
     18/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
     19
     20#ifndef SEEK_CUR
     21#define SEEK_CUR    1
     22#endif
     23
     24#ifndef SEEK_END
     25#define SEEK_END    2
     26#endif
     27
     28#ifndef SEEK_SET
     29#define SEEK_SET    0
     30#endif
     31
     32voidpf ZCALLBACK fopen_file_func OF((
     33   voidpf opaque,
     34   const char* filename,
     35   int mode));
     36
     37uLong ZCALLBACK fread_file_func OF((
     38   voidpf opaque,
     39   voidpf stream,
     40   void* buf,
     41   uLong size));
     42
     43uLong ZCALLBACK fwrite_file_func OF((
     44   voidpf opaque,
     45   voidpf stream,
     46   const void* buf,
     47   uLong size));
     48
     49long ZCALLBACK ftell_file_func OF((
     50   voidpf opaque,
     51   voidpf stream));
     52
     53long ZCALLBACK fseek_file_func OF((
     54   voidpf opaque,
     55   voidpf stream,
     56   uLong offset,
     57   int origin));
     58
     59int ZCALLBACK fclose_file_func OF((
     60   voidpf opaque,
     61   voidpf stream));
     62
     63int ZCALLBACK ferror_file_func OF((
     64   voidpf opaque,
     65   voidpf stream));
     66
     67
     68voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
     69   voidpf opaque;
     70   const char* filename;
     71   int mode;
     72{
     73    FILE* file = NULL;
     74    const char* mode_fopen = NULL;
     75    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
     76        mode_fopen = "rb";
     77    else
     78    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
     79        mode_fopen = "r+b";
     80    else
     81    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
     82        mode_fopen = "wb";
     83
     84    if ((filename!=NULL) && (mode_fopen != NULL))
     85        file = fopen(filename, mode_fopen);
     86    return file;
     87}
     88
     89
     90uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
     91   voidpf opaque;
     92   voidpf stream;
     93   void* buf;
     94   uLong size;
     95{
     96    uLong ret;
     97    ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
     98    return ret;
     99}
     100
     101
     102uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
     103   voidpf opaque;
     104   voidpf stream;
     105   const void* buf;
     106   uLong size;
     107{
     108    uLong ret;
     109    ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
     110    return ret;
     111}
     112
     113long ZCALLBACK ftell_file_func (opaque, stream)
     114   voidpf opaque;
     115   voidpf stream;
     116{
     117    long ret;
     118    ret = ftell((FILE *)stream);
     119    return ret;
     120}
     121
     122long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
     123   voidpf opaque;
     124   voidpf stream;
     125   uLong offset;
     126   int origin;
     127{
     128    int fseek_origin=0;
     129    long ret;
     130    switch (origin)
     131    {
     132    case ZLIB_FILEFUNC_SEEK_CUR :
     133        fseek_origin = SEEK_CUR;
     134        break;
     135    case ZLIB_FILEFUNC_SEEK_END :
     136        fseek_origin = SEEK_END;
     137        break;
     138    case ZLIB_FILEFUNC_SEEK_SET :
     139        fseek_origin = SEEK_SET;
     140        break;
     141    default: return -1;
     142    }
     143    ret = 0;
     144    fseek((FILE *)stream, offset, fseek_origin);
     145    return ret;
     146}
     147
     148int ZCALLBACK fclose_file_func (opaque, stream)
     149   voidpf opaque;
     150   voidpf stream;
     151{
     152    int ret;
     153    ret = fclose((FILE *)stream);
     154    return ret;
     155}
     156
     157int ZCALLBACK ferror_file_func (opaque, stream)
     158   voidpf opaque;
     159   voidpf stream;
     160{
     161    int ret;
     162    ret = ferror((FILE *)stream);
     163    return ret;
     164}
     165
     166void fill_fopen_filefunc (pzlib_filefunc_def)
     167  zlib_filefunc_def* pzlib_filefunc_def;
     168{
     169    pzlib_filefunc_def->zopen_file = fopen_file_func;
     170    pzlib_filefunc_def->zread_file = fread_file_func;
     171    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
     172    pzlib_filefunc_def->ztell_file = ftell_file_func;
     173    pzlib_filefunc_def->zseek_file = fseek_file_func;
     174    pzlib_filefunc_def->zclose_file = fclose_file_func;
     175    pzlib_filefunc_def->zerror_file = ferror_file_func;
     176    pzlib_filefunc_def->opaque = NULL;
     177}
  • backends/platform/iphone/nuzip/zip.c

     
     1/* zip.c -- IO on .zip files using zlib
     2   Version 1.01e, February 12th, 2005
     3
     4   27 Dec 2004 Rolf Kalbermatter
     5   Modification to zipOpen2 to support globalComment retrieval.
     6
     7   Copyright (C) 1998-2005 Gilles Vollant
     8
     9   Read zip.h for more info
     10*/
     11
     12
     13#include <stdio.h>
     14#include <stdlib.h>
     15#include <string.h>
     16#include <time.h>
     17#include <zlib.h>
     18#include "zip.h"
     19
     20#ifdef STDC
     21#  include <stddef.h>
     22#  include <string.h>
     23#  include <stdlib.h>
     24#endif
     25#ifdef NO_ERRNO_H
     26    extern int errno;
     27#else
     28#   include <errno.h>
     29#endif
     30
     31
     32#ifndef local
     33#  define local static
     34#endif
     35/* compile with -Dlocal if your debugger can't find static symbols */
     36
     37#ifndef VERSIONMADEBY
     38# define VERSIONMADEBY   (0x0) /* platform depedent */
     39#endif
     40
     41#ifndef Z_BUFSIZE
     42#define Z_BUFSIZE (16384)
     43#endif
     44
     45#ifndef Z_MAXFILENAMEINZIP
     46#define Z_MAXFILENAMEINZIP (256)
     47#endif
     48
     49#ifndef ALLOC
     50# define ALLOC(size) (malloc(size))
     51#endif
     52#ifndef TRYFREE
     53# define TRYFREE(p) {if (p) free(p);}
     54#endif
     55
     56/*
     57#define SIZECENTRALDIRITEM (0x2e)
     58#define SIZEZIPLOCALHEADER (0x1e)
     59*/
     60
     61/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
     62
     63#ifndef SEEK_CUR
     64#define SEEK_CUR    1
     65#endif
     66
     67#ifndef SEEK_END
     68#define SEEK_END    2
     69#endif
     70
     71#ifndef SEEK_SET
     72#define SEEK_SET    0
     73#endif
     74
     75#ifndef DEF_MEM_LEVEL
     76#if MAX_MEM_LEVEL >= 8
     77#  define DEF_MEM_LEVEL 8
     78#else
     79#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
     80#endif
     81#endif
     82const char zip_copyright[] =
     83   " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
     84
     85
     86#define SIZEDATA_INDATABLOCK (4096-(4*4))
     87
     88#define LOCALHEADERMAGIC    (0x04034b50)
     89#define CENTRALHEADERMAGIC  (0x02014b50)
     90#define ENDHEADERMAGIC      (0x06054b50)
     91
     92#define FLAG_LOCALHEADER_OFFSET (0x06)
     93#define CRC_LOCALHEADER_OFFSET  (0x0e)
     94
     95#define SIZECENTRALHEADER (0x2e) /* 46 */
     96
     97typedef struct linkedlist_datablock_internal_s
     98{
     99  struct linkedlist_datablock_internal_s* next_datablock;
     100  uLong  avail_in_this_block;
     101  uLong  filled_in_this_block;
     102  uLong  unused; /* for future use and alignement */
     103  unsigned char data[SIZEDATA_INDATABLOCK];
     104} linkedlist_datablock_internal;
     105
     106typedef struct linkedlist_data_s
     107{
     108    linkedlist_datablock_internal* first_block;
     109    linkedlist_datablock_internal* last_block;
     110} linkedlist_data;
     111
     112
     113typedef struct
     114{
     115    z_stream stream;            /* zLib stream structure for inflate */
     116    int  stream_initialised;    /* 1 is stream is initialised */
     117    uInt pos_in_buffered_data;  /* last written byte in buffered_data */
     118
     119    uLong pos_local_header;     /* offset of the local header of the file
     120                                     currenty writing */
     121    char* central_header;       /* central header data for the current file */
     122    uLong size_centralheader;   /* size of the central header for cur file */
     123    uLong flag;                 /* flag of the file currently writing */
     124
     125    int  method;                /* compression method of file currenty wr.*/
     126    int  raw;                   /* 1 for directly writing raw data */
     127    Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
     128    uLong dosDate;
     129    uLong crc32;
     130    int  encrypt;
     131#ifndef NOCRYPT
     132    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
     133    const unsigned long* pcrc_32_tab;
     134    int crypt_header_size;
     135#endif
     136} curfile_info;
     137
     138typedef struct
     139{
     140    zlib_filefunc_def z_filefunc;
     141    voidpf filestream;        /* io structore of the zipfile */
     142    linkedlist_data central_dir;/* datablock with central dir in construction*/
     143    int  in_opened_file_inzip;  /* 1 if a file in the zip is currently writ.*/
     144    curfile_info ci;            /* info on the file curretly writing */
     145
     146    uLong begin_pos;            /* position of the beginning of the zipfile */
     147    uLong add_position_when_writting_offset;
     148    uLong number_entry;
     149#ifndef NO_ADDFILEINEXISTINGZIP
     150    char *globalcomment;
     151#endif
     152} zip_internal;
     153
     154
     155
     156#ifndef NOCRYPT
     157#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
     158#include "crypt.h"
     159#endif
     160
     161local linkedlist_datablock_internal* allocate_new_datablock()
     162{
     163    linkedlist_datablock_internal* ldi;
     164    ldi = (linkedlist_datablock_internal*)
     165                 ALLOC(sizeof(linkedlist_datablock_internal));
     166    if (ldi!=NULL)
     167    {
     168        ldi->next_datablock = NULL ;
     169        ldi->filled_in_this_block = 0 ;
     170        ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
     171    }
     172    return ldi;
     173}
     174
     175local void free_datablock(ldi)
     176    linkedlist_datablock_internal* ldi;
     177{
     178    while (ldi!=NULL)
     179    {
     180        linkedlist_datablock_internal* ldinext = ldi->next_datablock;
     181        TRYFREE(ldi);
     182        ldi = ldinext;
     183    }
     184}
     185
     186local void init_linkedlist(ll)
     187    linkedlist_data* ll;
     188{
     189    ll->first_block = ll->last_block = NULL;
     190}
     191
     192local void free_linkedlist(ll)
     193    linkedlist_data* ll;
     194{
     195    free_datablock(ll->first_block);
     196    ll->first_block = ll->last_block = NULL;
     197}
     198
     199
     200local int add_data_in_datablock(ll,buf,len)
     201    linkedlist_data* ll;
     202    const void* buf;
     203    uLong len;
     204{
     205    linkedlist_datablock_internal* ldi;
     206    const unsigned char* from_copy;
     207
     208    if (ll==NULL)
     209        return ZIP_INTERNALERROR;
     210
     211    if (ll->last_block == NULL)
     212    {
     213        ll->first_block = ll->last_block = allocate_new_datablock();
     214        if (ll->first_block == NULL)
     215            return ZIP_INTERNALERROR;
     216    }
     217
     218    ldi = ll->last_block;
     219    from_copy = (unsigned char*)buf;
     220
     221    while (len>0)
     222    {
     223        uInt copy_this;
     224        uInt i;
     225        unsigned char* to_copy;
     226
     227        if (ldi->avail_in_this_block==0)
     228        {
     229            ldi->next_datablock = allocate_new_datablock();
     230            if (ldi->next_datablock == NULL)
     231                return ZIP_INTERNALERROR;
     232            ldi = ldi->next_datablock ;
     233            ll->last_block = ldi;
     234        }
     235
     236        if (ldi->avail_in_this_block < len)
     237            copy_this = (uInt)ldi->avail_in_this_block;
     238        else
     239            copy_this = (uInt)len;
     240
     241        to_copy = &(ldi->data[ldi->filled_in_this_block]);
     242
     243        for (i=0;i<copy_this;i++)
     244            *(to_copy+i)=*(from_copy+i);
     245
     246        ldi->filled_in_this_block += copy_this;
     247        ldi->avail_in_this_block -= copy_this;
     248        from_copy += copy_this ;
     249        len -= copy_this;
     250    }
     251    return ZIP_OK;
     252}
     253
     254
     255
     256/****************************************************************************/
     257
     258#ifndef NO_ADDFILEINEXISTINGZIP
     259/* ===========================================================================
     260   Inputs a long in LSB order to the given file
     261   nbByte == 1, 2 or 4 (byte, short or long)
     262*/
     263
     264local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def,
     265                                voidpf filestream, uLong x, int nbByte));
     266local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
     267    const zlib_filefunc_def* pzlib_filefunc_def;
     268    voidpf filestream;
     269    uLong x;
     270    int nbByte;
     271{
     272    unsigned char buf[4];
     273    int n;
     274    for (n = 0; n < nbByte; n++)
     275    {
     276        buf[n] = (unsigned char)(x & 0xff);
     277        x >>= 8;
     278    }
     279    if (x != 0)
     280      {     /* data overflow - hack for ZIP64 (X Roche) */
     281      for (n = 0; n < nbByte; n++)
     282        {
     283          buf[n] = 0xff;
     284        }
     285      }
     286
     287    if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
     288        return ZIP_ERRNO;
     289    else
     290        return ZIP_OK;
     291}
     292
     293local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte));
     294local void ziplocal_putValue_inmemory (dest, x, nbByte)
     295    void* dest;
     296    uLong x;
     297    int nbByte;
     298{
     299    unsigned char* buf=(unsigned char*)dest;
     300    int n;
     301    for (n = 0; n < nbByte; n++) {
     302        buf[n] = (unsigned char)(x & 0xff);
     303        x >>= 8;
     304    }
     305
     306    if (x != 0)
     307    {     /* data overflow - hack for ZIP64 */
     308       for (n = 0; n < nbByte; n++)
     309       {
     310          buf[n] = 0xff;
     311       }
     312    }
     313}
     314
     315/****************************************************************************/
     316
     317
     318local uLong ziplocal_TmzDateToDosDate(ptm,dosDate)
     319    const tm_zip* ptm;
     320    uLong dosDate;
     321{
     322    uLong year = (uLong)ptm->tm_year;
     323    if (year>1980)
     324        year-=1980;
     325    else if (year>80)
     326        year-=80;
     327    return
     328      (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
     329        ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
     330}
     331
     332
     333/****************************************************************************/
     334
     335local int ziplocal_getByte OF((
     336    const zlib_filefunc_def* pzlib_filefunc_def,
     337    voidpf filestream,
     338    int *pi));
     339
     340local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi)
     341    const zlib_filefunc_def* pzlib_filefunc_def;
     342    voidpf filestream;
     343    int *pi;
     344{
     345    unsigned char c;
     346    int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
     347    if (err==1)
     348    {
     349        *pi = (int)c;
     350        return ZIP_OK;
     351    }
     352    else
     353    {
     354        if (ZERROR(*pzlib_filefunc_def,filestream))
     355            return ZIP_ERRNO;
     356        else
     357            return ZIP_EOF;
     358    }
     359}
     360
     361
     362/* ===========================================================================
     363   Reads a long in LSB order from the given gz_stream. Sets
     364*/
     365local int ziplocal_getShort OF((
     366    const zlib_filefunc_def* pzlib_filefunc_def,
     367    voidpf filestream,
     368    uLong *pX));
     369
     370local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX)
     371    const zlib_filefunc_def* pzlib_filefunc_def;
     372    voidpf filestream;
     373    uLong *pX;
     374{
     375    uLong x ;
     376    int i;
     377    int err;
     378
     379    err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     380    x = (uLong)i;
     381
     382    if (err==ZIP_OK)
     383        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     384    x += ((uLong)i)<<8;
     385
     386    if (err==ZIP_OK)
     387        *pX = x;
     388    else
     389        *pX = 0;
     390    return err;
     391}
     392
     393local int ziplocal_getLong OF((
     394    const zlib_filefunc_def* pzlib_filefunc_def,
     395    voidpf filestream,
     396    uLong *pX));
     397
     398local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX)
     399    const zlib_filefunc_def* pzlib_filefunc_def;
     400    voidpf filestream;
     401    uLong *pX;
     402{
     403    uLong x ;
     404    int i;
     405    int err;
     406
     407    err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     408    x = (uLong)i;
     409
     410    if (err==ZIP_OK)
     411        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     412    x += ((uLong)i)<<8;
     413
     414    if (err==ZIP_OK)
     415        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     416    x += ((uLong)i)<<16;
     417
     418    if (err==ZIP_OK)
     419        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
     420    x += ((uLong)i)<<24;
     421
     422    if (err==ZIP_OK)
     423        *pX = x;
     424    else
     425        *pX = 0;
     426    return err;
     427}
     428
     429#ifndef BUFREADCOMMENT
     430#define BUFREADCOMMENT (0x400)
     431#endif
     432/*
     433  Locate the Central directory of a zipfile (at the end, just before
     434    the global comment)
     435*/
     436local uLong ziplocal_SearchCentralDir OF((
     437    const zlib_filefunc_def* pzlib_filefunc_def,
     438    voidpf filestream));
     439
     440local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
     441    const zlib_filefunc_def* pzlib_filefunc_def;
     442    voidpf filestream;
     443{
     444    unsigned char* buf;
     445    uLong uSizeFile;
     446    uLong uBackRead;
     447    uLong uMaxBack=0xffff; /* maximum size of global comment */
     448    uLong uPosFound=0;
     449
     450    if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
     451        return 0;
     452
     453
     454    uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
     455
     456    if (uMaxBack>uSizeFile)
     457        uMaxBack = uSizeFile;
     458
     459    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
     460    if (buf==NULL)
     461        return 0;
     462
     463    uBackRead = 4;
     464    while (uBackRead<uMaxBack)
     465    {
     466        uLong uReadSize,uReadPos ;
     467        int i;
     468        if (uBackRead+BUFREADCOMMENT>uMaxBack)
     469            uBackRead = uMaxBack;
     470        else
     471            uBackRead+=BUFREADCOMMENT;
     472        uReadPos = uSizeFile-uBackRead ;
     473
     474        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
     475                     (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
     476        if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
     477            break;
     478
     479        if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
     480            break;
     481
     482        for (i=(int)uReadSize-3; (i--)>0;)
     483            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
     484                ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
     485            {
     486                uPosFound = uReadPos+i;
     487                break;
     488            }
     489
     490        if (uPosFound!=0)
     491            break;
     492    }
     493    TRYFREE(buf);
     494    return uPosFound;
     495}
     496#endif /* !NO_ADDFILEINEXISTINGZIP*/
     497
     498/************************************************************/
     499extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def)
     500    const char *pathname;
     501    int append;
     502    zipcharpc* globalcomment;
     503    zlib_filefunc_def* pzlib_filefunc_def;
     504{
     505    zip_internal ziinit;
     506    zip_internal* zi;
     507    int err=ZIP_OK;
     508
     509
     510    if (pzlib_filefunc_def==NULL)
     511        fill_fopen_filefunc(&ziinit.z_filefunc);
     512    else
     513        ziinit.z_filefunc = *pzlib_filefunc_def;
     514
     515    ziinit.filestream = (*(ziinit.z_filefunc.zopen_file))
     516                 (ziinit.z_filefunc.opaque,
     517                  pathname,
     518                  (append == APPEND_STATUS_CREATE) ?
     519                  (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
     520                    (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
     521
     522    if (ziinit.filestream == NULL)
     523        return NULL;
     524    ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream);
     525    ziinit.in_opened_file_inzip = 0;
     526    ziinit.ci.stream_initialised = 0;
     527    ziinit.number_entry = 0;
     528    ziinit.add_position_when_writting_offset = 0;
     529    init_linkedlist(&(ziinit.central_dir));
     530
     531
     532    zi = (zip_internal*)ALLOC(sizeof(zip_internal));
     533    if (zi==NULL)
     534    {
     535        ZCLOSE(ziinit.z_filefunc,ziinit.filestream);
     536        return NULL;
     537    }
     538
     539    /* now we add file in a zipfile */
     540#    ifndef NO_ADDFILEINEXISTINGZIP
     541    ziinit.globalcomment = NULL;
     542    if (append == APPEND_STATUS_ADDINZIP)
     543    {
     544        uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
     545
     546        uLong size_central_dir;     /* size of the central directory  */
     547        uLong offset_central_dir;   /* offset of start of central directory */
     548        uLong central_pos,uL;
     549
     550        uLong number_disk;          /* number of the current dist, used for
     551                                    spaning ZIP, unsupported, always 0*/
     552        uLong number_disk_with_CD;  /* number the the disk with central dir, used
     553                                    for spaning ZIP, unsupported, always 0*/
     554        uLong number_entry;
     555        uLong number_entry_CD;      /* total number of entries in
     556                                    the central dir
     557                                    (same than number_entry on nospan) */
     558        uLong size_comment;
     559
     560        central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);
     561        if (central_pos==0)
     562            err=ZIP_ERRNO;
     563
     564        if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
     565                                        central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
     566            err=ZIP_ERRNO;
     567
     568        /* the signature, already checked */
     569        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK)
     570            err=ZIP_ERRNO;
     571
     572        /* number of this disk */
     573        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK)
     574            err=ZIP_ERRNO;
     575
     576        /* number of the disk with the start of the central directory */
     577        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK)
     578            err=ZIP_ERRNO;
     579
     580        /* total number of entries in the central dir on this disk */
     581        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK)
     582            err=ZIP_ERRNO;
     583
     584        /* total number of entries in the central dir */
     585        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK)
     586            err=ZIP_ERRNO;
     587
     588        if ((number_entry_CD!=number_entry) ||
     589            (number_disk_with_CD!=0) ||
     590            (number_disk!=0))
     591            err=ZIP_BADZIPFILE;
     592
     593        /* size of the central directory */
     594        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK)
     595            err=ZIP_ERRNO;
     596
     597        /* offset of start of central directory with respect to the
     598            starting disk number */
     599        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK)
     600            err=ZIP_ERRNO;
     601
     602        /* zipfile global comment length */
     603        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK)
     604            err=ZIP_ERRNO;
     605
     606        if ((central_pos<offset_central_dir+size_central_dir) &&
     607            (err==ZIP_OK))
     608            err=ZIP_BADZIPFILE;
     609
     610        if (err!=ZIP_OK)
     611        {
     612            ZCLOSE(ziinit.z_filefunc, ziinit.filestream);
     613            return NULL;
     614        }
     615
     616        if (size_comment>0)
     617        {
     618            ziinit.globalcomment = ALLOC(size_comment+1);
     619            if (ziinit.globalcomment)
     620            {
     621               size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment);
     622               ziinit.globalcomment[size_comment]=0;
     623            }
     624        }
     625
     626        byte_before_the_zipfile = central_pos -
     627                                (offset_central_dir+size_central_dir);
     628        ziinit.add_position_when_writting_offset = byte_before_the_zipfile;
     629
     630        {
     631            uLong size_central_dir_to_read = size_central_dir;
     632            size_t buf_size = SIZEDATA_INDATABLOCK;
     633            void* buf_read = (void*)ALLOC(buf_size);
     634            if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
     635                  offset_central_dir + byte_before_the_zipfile,
     636                  ZLIB_FILEFUNC_SEEK_SET) != 0)
     637                  err=ZIP_ERRNO;
     638
     639            while ((size_central_dir_to_read>0) && (err==ZIP_OK))
     640            {
     641                uLong read_this = SIZEDATA_INDATABLOCK;
     642                if (read_this > size_central_dir_to_read)
     643                    read_this = size_central_dir_to_read;
     644                if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this)
     645                    err=ZIP_ERRNO;
     646
     647                if (err==ZIP_OK)
     648                    err = add_data_in_datablock(&ziinit.central_dir,buf_read,
     649                                                (uLong)read_this);
     650                size_central_dir_to_read-=read_this;
     651            }
     652            TRYFREE(buf_read);
     653        }
     654        ziinit.begin_pos = byte_before_the_zipfile;
     655        ziinit.number_entry = number_entry_CD;
     656
     657        if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
     658                  offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
     659            err=ZIP_ERRNO;
     660    }
     661
     662    if (globalcomment)
     663    {
     664      *globalcomment = ziinit.globalcomment;
     665    }
     666#    endif /* !NO_ADDFILEINEXISTINGZIP*/
     667
     668    if (err != ZIP_OK)
     669    {
     670#    ifndef NO_ADDFILEINEXISTINGZIP
     671        TRYFREE(ziinit.globalcomment);
     672#    endif /* !NO_ADDFILEINEXISTINGZIP*/
     673        TRYFREE(zi);
     674        return NULL;
     675    }
     676    else
     677    {
     678        *zi = ziinit;
     679        return (zipFile)zi;
     680    }
     681}
     682
     683extern zipFile ZEXPORT zipOpen (pathname, append)
     684    const char *pathname;
     685    int append;
     686{
     687    return zipOpen2(pathname,append,NULL,NULL);
     688}
     689
     690extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
     691                                         extrafield_local, size_extrafield_local,
     692                                         extrafield_global, size_extrafield_global,
     693                                         comment, method, level, raw,
     694                                         windowBits, memLevel, strategy,
     695                                         password, crcForCrypting)
     696    zipFile file;
     697    const char* filename;
     698    const zip_fileinfo* zipfi;
     699    const void* extrafield_local;
     700    uInt size_extrafield_local;
     701    const void* extrafield_global;
     702    uInt size_extrafield_global;
     703    const char* comment;
     704    int method;
     705    int level;
     706    int raw;
     707    int windowBits;
     708    int memLevel;
     709    int strategy;
     710    const char* password;
     711    uLong crcForCrypting;
     712{
     713    zip_internal* zi;
     714    uInt size_filename;
     715    uInt size_comment;
     716    uInt i;
     717    int err = ZIP_OK;
     718
     719#    ifdef NOCRYPT
     720    if (password != NULL)
     721        return ZIP_PARAMERROR;
     722#    endif
     723
     724    if (file == NULL)
     725        return ZIP_PARAMERROR;
     726    if ((method!=0) && (method!=Z_DEFLATED))
     727        return ZIP_PARAMERROR;
     728
     729    zi = (zip_internal*)file;
     730
     731    if (zi->in_opened_file_inzip == 1)
     732    {
     733        err = zipCloseFileInZip (file);
     734        if (err != ZIP_OK)
     735            return err;
     736    }
     737
     738
     739    if (filename==NULL)
     740        filename="-";
     741
     742    if (comment==NULL)
     743        size_comment = 0;
     744    else
     745        size_comment = (uInt)strlen(comment);
     746
     747    size_filename = (uInt)strlen(filename);
     748
     749    if (zipfi == NULL)
     750        zi->ci.dosDate = 0;
     751    else
     752    {
     753        if (zipfi->dosDate != 0)
     754            zi->ci.dosDate = zipfi->dosDate;
     755        else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate);
     756    }
     757
     758    zi->ci.flag = 0;
     759    if ((level==8) || (level==9))
     760      zi->ci.flag |= 2;
     761    if ((level==2))
     762      zi->ci.flag |= 4;
     763    if ((level==1))
     764      zi->ci.flag |= 6;
     765    if (password != NULL)
     766      zi->ci.flag |= 1;
     767
     768    zi->ci.crc32 = 0;
     769    zi->ci.method = method;
     770    zi->ci.encrypt = 0;
     771    zi->ci.stream_initialised = 0;
     772    zi->ci.pos_in_buffered_data = 0;
     773    zi->ci.raw = raw;
     774    zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ;
     775    zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename +
     776                                      size_extrafield_global + size_comment;
     777    zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader);
     778
     779    ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
     780    /* version info */
     781    ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2);
     782    ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
     783    ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
     784    ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
     785    ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
     786    ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
     787    ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
     788    ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
     789    ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
     790    ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
     791    ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
     792    ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
     793
     794    if (zipfi==NULL)
     795        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
     796    else
     797        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
     798
     799    if (zipfi==NULL)
     800        ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
     801    else
     802        ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
     803
     804    ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4);
     805
     806    for (i=0;i<size_filename;i++)
     807        *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
     808
     809    for (i=0;i<size_extrafield_global;i++)
     810        *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
     811              *(((const char*)extrafield_global)+i);
     812
     813    for (i=0;i<size_comment;i++)
     814        *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
     815              size_extrafield_global+i) = *(comment+i);
     816    if (zi->ci.central_header == NULL)
     817        return ZIP_INTERNALERROR;
     818
     819    /* write the local header */
     820    err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4);
     821
     822    if (err==ZIP_OK)
     823        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
     824    if (err==ZIP_OK)
     825        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
     826
     827    if (err==ZIP_OK)
     828        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
     829
     830    if (err==ZIP_OK)
     831        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
     832
     833    if (err==ZIP_OK)
     834        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
     835    if (err==ZIP_OK)
     836        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
     837    if (err==ZIP_OK)
     838        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
     839
     840    if (err==ZIP_OK)
     841        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
     842
     843    if (err==ZIP_OK)
     844        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2);
     845
     846    if ((err==ZIP_OK) && (size_filename>0))
     847        if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
     848                err = ZIP_ERRNO;
     849
     850    if ((err==ZIP_OK) && (size_extrafield_local>0))
     851        if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local)
     852                                                                           !=size_extrafield_local)
     853                err = ZIP_ERRNO;
     854
     855    zi->ci.stream.avail_in = (uInt)0;
     856    zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
     857    zi->ci.stream.next_out = zi->ci.buffered_data;
     858    zi->ci.stream.total_in = 0;
     859    zi->ci.stream.total_out = 0;
     860
     861    if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
     862    {
     863        zi->ci.stream.zalloc = (alloc_func)0;
     864        zi->ci.stream.zfree = (free_func)0;
     865        zi->ci.stream.opaque = (voidpf)0;
     866
     867        if (windowBits>0)
     868            windowBits = -windowBits;
     869
     870        err = deflateInit2(&zi->ci.stream, level,
     871               Z_DEFLATED, windowBits, memLevel, strategy);
     872
     873        if (err==Z_OK)
     874            zi->ci.stream_initialised = 1;
     875    }
     876#    ifndef NOCRYPT
     877    zi->ci.crypt_header_size = 0;
     878    if ((err==Z_OK) && (password != NULL))
     879    {
     880        unsigned char bufHead[RAND_HEAD_LEN];
     881        unsigned int sizeHead;
     882        zi->ci.encrypt = 1;
     883        zi->ci.pcrc_32_tab = get_crc_table();
     884        /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
     885
     886        sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
     887        zi->ci.crypt_header_size = sizeHead;
     888
     889        if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
     890                err = ZIP_ERRNO;
     891    }
     892#    endif
     893
     894    if (err==Z_OK)
     895        zi->in_opened_file_inzip = 1;
     896    return err;
     897}
     898
     899extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
     900                                        extrafield_local, size_extrafield_local,
     901                                        extrafield_global, size_extrafield_global,
     902                                        comment, method, level, raw)
     903    zipFile file;
     904    const char* filename;
     905    const zip_fileinfo* zipfi;
     906    const void* extrafield_local;
     907    uInt size_extrafield_local;
     908    const void* extrafield_global;
     909    uInt size_extrafield_global;
     910    const char* comment;
     911    int method;
     912    int level;
     913    int raw;
     914{
     915    return zipOpenNewFileInZip3 (file, filename, zipfi,
     916                                 extrafield_local, size_extrafield_local,
     917                                 extrafield_global, size_extrafield_global,
     918                                 comment, method, level, raw,
     919                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
     920                                 NULL, 0);
     921}
     922
     923extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
     924                                        extrafield_local, size_extrafield_local,
     925                                        extrafield_global, size_extrafield_global,
     926                                        comment, method, level)
     927    zipFile file;
     928    const char* filename;
     929    const zip_fileinfo* zipfi;
     930    const void* extrafield_local;
     931    uInt size_extrafield_local;
     932    const void* extrafield_global;
     933    uInt size_extrafield_global;
     934    const char* comment;
     935    int method;
     936    int level;
     937{
     938    return zipOpenNewFileInZip2 (file, filename, zipfi,
     939                                 extrafield_local, size_extrafield_local,
     940                                 extrafield_global, size_extrafield_global,
     941                                 comment, method, level, 0);
     942}
     943
     944local int zipFlushWriteBuffer(zi)
     945  zip_internal* zi;
     946{
     947    int err=ZIP_OK;
     948
     949    if (zi->ci.encrypt != 0)
     950    {
     951#ifndef NOCRYPT
     952        uInt i;
     953        int t;
     954        for (i=0;i<zi->ci.pos_in_buffered_data;i++)
     955            zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab,
     956                                       zi->ci.buffered_data[i],t);
     957#endif
     958    }
     959    if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data)
     960                                                                    !=zi->ci.pos_in_buffered_data)
     961      err = ZIP_ERRNO;
     962    zi->ci.pos_in_buffered_data = 0;
     963    return err;
     964}
     965
     966extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
     967    zipFile file;
     968    const void* buf;
     969    unsigned len;
     970{
     971    zip_internal* zi;
     972    int err=ZIP_OK;
     973
     974    if (file == NULL)
     975        return ZIP_PARAMERROR;
     976    zi = (zip_internal*)file;
     977
     978    if (zi->in_opened_file_inzip == 0)
     979        return ZIP_PARAMERROR;
     980
     981    zi->ci.stream.next_in = (void*)buf;
     982    zi->ci.stream.avail_in = len;
     983    zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
     984
     985    while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
     986    {
     987        if (zi->ci.stream.avail_out == 0)
     988        {
     989            if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
     990                err = ZIP_ERRNO;
     991            zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
     992            zi->ci.stream.next_out = zi->ci.buffered_data;
     993        }
     994
     995
     996        if(err != ZIP_OK)
     997            break;
     998
     999        if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
     1000        {
     1001            uLong uTotalOutBefore = zi->ci.stream.total_out;
     1002            err=deflate(&zi->ci.stream,  Z_NO_FLUSH);
     1003            zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
     1004
     1005        }
     1006        else
     1007        {
     1008            uInt copy_this,i;
     1009            if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
     1010                copy_this = zi->ci.stream.avail_in;
     1011            else
     1012                copy_this = zi->ci.stream.avail_out;
     1013            for (i=0;i<copy_this;i++)
     1014                *(((char*)zi->ci.stream.next_out)+i) =
     1015                    *(((const char*)zi->ci.stream.next_in)+i);
     1016            {
     1017                zi->ci.stream.avail_in -= copy_this;
     1018                zi->ci.stream.avail_out-= copy_this;
     1019                zi->ci.stream.next_in+= copy_this;
     1020                zi->ci.stream.next_out+= copy_this;
     1021                zi->ci.stream.total_in+= copy_this;
     1022                zi->ci.stream.total_out+= copy_this;
     1023                zi->ci.pos_in_buffered_data += copy_this;
     1024            }
     1025        }
     1026    }
     1027
     1028    return err;
     1029}
     1030
     1031extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
     1032    zipFile file;
     1033    uLong uncompressed_size;
     1034    uLong crc32;
     1035{
     1036    zip_internal* zi;
     1037    uLong compressed_size;
     1038    int err=ZIP_OK;
     1039
     1040    if (file == NULL)
     1041        return ZIP_PARAMERROR;
     1042    zi = (zip_internal*)file;
     1043
     1044    if (zi->in_opened_file_inzip == 0)
     1045        return ZIP_PARAMERROR;
     1046    zi->ci.stream.avail_in = 0;
     1047
     1048    if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
     1049        while (err==ZIP_OK)
     1050    {
     1051        uLong uTotalOutBefore;
     1052        if (zi->ci.stream.avail_out == 0)
     1053        {
     1054            if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
     1055                err = ZIP_ERRNO;
     1056            zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
     1057            zi->ci.stream.next_out = zi->ci.buffered_data;
     1058        }
     1059        uTotalOutBefore = zi->ci.stream.total_out;
     1060        err=deflate(&zi->ci.stream,  Z_FINISH);
     1061        zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
     1062    }
     1063
     1064    if (err==Z_STREAM_END)
     1065        err=ZIP_OK; /* this is normal */
     1066
     1067    if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
     1068        if (zipFlushWriteBuffer(zi)==ZIP_ERRNO)
     1069            err = ZIP_ERRNO;
     1070
     1071    if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
     1072    {
     1073        err=deflateEnd(&zi->ci.stream);
     1074        zi->ci.stream_initialised = 0;
     1075    }
     1076
     1077    if (!zi->ci.raw)
     1078    {
     1079        crc32 = (uLong)zi->ci.crc32;
     1080        uncompressed_size = (uLong)zi->ci.stream.total_in;
     1081    }
     1082    compressed_size = (uLong)zi->ci.stream.total_out;
     1083#    ifndef NOCRYPT
     1084    compressed_size += zi->ci.crypt_header_size;
     1085#    endif
     1086
     1087    ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
     1088    ziplocal_putValue_inmemory(zi->ci.central_header+20,
     1089                                compressed_size,4); /*compr size*/
     1090    if (zi->ci.stream.data_type == Z_ASCII)
     1091        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
     1092    ziplocal_putValue_inmemory(zi->ci.central_header+24,
     1093                                uncompressed_size,4); /*uncompr size*/
     1094
     1095    if (err==ZIP_OK)
     1096        err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header,
     1097                                       (uLong)zi->ci.size_centralheader);
     1098    free(zi->ci.central_header);
     1099
     1100    if (err==ZIP_OK)
     1101    {
     1102        long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
     1103        if (ZSEEK(zi->z_filefunc,zi->filestream,
     1104                  zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
     1105            err = ZIP_ERRNO;
     1106
     1107        if (err==ZIP_OK)
     1108            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
     1109
     1110        if (err==ZIP_OK) /* compressed size, unknown */
     1111            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
     1112
     1113        if (err==ZIP_OK) /* uncompressed size, unknown */
     1114            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
     1115
     1116        if (ZSEEK(zi->z_filefunc,zi->filestream,
     1117                  cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
     1118            err = ZIP_ERRNO;
     1119    }
     1120
     1121    zi->number_entry ++;
     1122    zi->in_opened_file_inzip = 0;
     1123
     1124    return err;
     1125}
     1126
     1127extern int ZEXPORT zipCloseFileInZip (file)
     1128    zipFile file;
     1129{
     1130    return zipCloseFileInZipRaw (file,0,0);
     1131}
     1132
     1133extern int ZEXPORT zipClose (file, global_comment)
     1134    zipFile file;
     1135    const char* global_comment;
     1136{
     1137    zip_internal* zi;
     1138    int err = 0;
     1139    uLong size_centraldir = 0;
     1140    uLong centraldir_pos_inzip;
     1141    uInt size_global_comment;
     1142    if (file == NULL)
     1143        return ZIP_PARAMERROR;
     1144    zi = (zip_internal*)file;
     1145
     1146    if (zi->in_opened_file_inzip == 1)
     1147    {
     1148        err = zipCloseFileInZip (file);
     1149    }
     1150
     1151#ifndef NO_ADDFILEINEXISTINGZIP
     1152    if (global_comment==NULL)
     1153        global_comment = zi->globalcomment;
     1154#endif
     1155    if (global_comment==NULL)
     1156        size_global_comment = 0;
     1157    else
     1158        size_global_comment = (uInt)strlen(global_comment);
     1159
     1160    centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
     1161    if (err==ZIP_OK)
     1162    {
     1163        linkedlist_datablock_internal* ldi = zi->central_dir.first_block ;
     1164        while (ldi!=NULL)
     1165        {
     1166            if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
     1167                if (ZWRITE(zi->z_filefunc,zi->filestream,
     1168                           ldi->data,ldi->filled_in_this_block)
     1169                              !=ldi->filled_in_this_block )
     1170                    err = ZIP_ERRNO;
     1171
     1172            size_centraldir += ldi->filled_in_this_block;
     1173            ldi = ldi->next_datablock;
     1174        }
     1175    }
     1176    free_datablock(zi->central_dir.first_block);
     1177
     1178    if (err==ZIP_OK) /* Magic End */
     1179        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
     1180
     1181    if (err==ZIP_OK) /* number of this disk */
     1182        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
     1183
     1184    if (err==ZIP_OK) /* number of the disk with the start of the central directory */
     1185        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
     1186
     1187    if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
     1188        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
     1189
     1190    if (err==ZIP_OK) /* total number of entries in the central dir */
     1191        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
     1192
     1193    if (err==ZIP_OK) /* size of the central directory */
     1194        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
     1195
     1196    if (err==ZIP_OK) /* offset of start of central directory with respect to the
     1197                            starting disk number */
     1198        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,
     1199                                (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
     1200
     1201    if (err==ZIP_OK) /* zipfile comment length */
     1202        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
     1203
     1204    if ((err==ZIP_OK) && (size_global_comment>0))
     1205        if (ZWRITE(zi->z_filefunc,zi->filestream,
     1206                   global_comment,size_global_comment) != size_global_comment)
     1207                err = ZIP_ERRNO;
     1208
     1209    if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0)
     1210        if (err == ZIP_OK)
     1211            err = ZIP_ERRNO;
     1212
     1213#ifndef NO_ADDFILEINEXISTINGZIP
     1214    TRYFREE(zi->globalcomment);
     1215#endif
     1216    TRYFREE(zi);
     1217
     1218    return err;
     1219}
  • backends/platform/iphone/nuzip/unzip.c

     
     1/* unzip.c -- IO for uncompress .zip files using zlib
     2   Version 1.01e, February 12th, 2005
     3
     4   Copyright (C) 1998-2005 Gilles Vollant
     5
     6   Read unzip.h for more info
     7*/
     8
     9/* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
     10compatibility with older software. The following is from the original crypt.c. Code
     11woven in by Terry Thorsen 1/2003.
     12*/
     13/*
     14  Copyright (c) 1990-2000 Info-ZIP.  All rights reserved.
     15
     16  See the accompanying file LICENSE, version 2000-Apr-09 or later
     17  (the contents of which are also included in zip.h) for terms of use.
     18  If, for some reason, all these files are missing, the Info-ZIP license
     19  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
     20*/
     21/*
     22  crypt.c (full version) by Info-ZIP.      Last revised:  [see crypt.h]
     23
     24  The encryption/decryption parts of this source code (as opposed to the
     25  non-echoing password parts) were originally written in Europe.  The
     26  whole source package can be freely distributed, including from the USA.
     27  (Prior to January 2000, re-export from the US was a violation of US law.)
     28 */
     29
     30/*
     31  This encryption code is a direct transcription of the algorithm from
     32  Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
     33  file (appnote.txt) is distributed with the PKZIP program (even in the
     34  version without encryption capabilities).
     35 */
     36
     37
     38#include <stdio.h>
     39#include <stdlib.h>
     40#include <string.h>
     41#include <zlib.h>
     42#include "unzip.h"
     43
     44#ifdef STDC
     45#  include <stddef.h>
     46#  include <string.h>
     47#  include <stdlib.h>
     48#endif
     49#ifdef NO_ERRNO_H
     50    extern int errno;
     51#else
     52#   include <errno.h>
     53#endif
     54
     55
     56#ifndef local
     57#  define local static
     58#endif
     59/* compile with -Dlocal if your debugger can't find static symbols */
     60
     61
     62#ifndef CASESENSITIVITYDEFAULT_NO
     63#  if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
     64#    define CASESENSITIVITYDEFAULT_NO
     65#  endif
     66#endif
     67
     68
     69#ifndef UNZ_BUFSIZE
     70#define UNZ_BUFSIZE (16384)
     71#endif
     72
     73#ifndef UNZ_MAXFILENAMEINZIP
     74#define UNZ_MAXFILENAMEINZIP (256)
     75#endif
     76
     77#ifndef ALLOC
     78# define ALLOC(size) (malloc(size))
     79#endif
     80#ifndef TRYFREE
     81# define TRYFREE(p) {if (p) free(p);}
     82#endif
     83
     84#define SIZECENTRALDIRITEM (0x2e)
     85#define SIZEZIPLOCALHEADER (0x1e)
     86
     87
     88
     89
     90const char unz_copyright[] =
     91   " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
     92
     93/* unz_file_info_interntal contain internal info about a file in zipfile*/
     94typedef struct unz_file_info_internal_s
     95{
     96    uLong offset_curfile;/* relative offset of local header 4 bytes */
     97} unz_file_info_internal;
     98
     99
     100/* file_in_zip_read_info_s contain internal information about a file in zipfile,
     101    when reading and decompress it */
     102typedef struct
     103{
     104    char  *read_buffer;         /* internal buffer for compressed data */
     105    z_stream stream;            /* zLib stream structure for inflate */
     106
     107    uLong pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
     108    uLong stream_initialised;   /* flag set if stream structure is initialised*/
     109
     110    uLong offset_local_extrafield;/* offset of the local extra field */
     111    uInt  size_local_extrafield;/* size of the local extra field */
     112    uLong pos_local_extrafield;   /* position in the local extra field in read*/
     113
     114    uLong crc32;                /* crc32 of all data uncompressed */
     115    uLong crc32_wait;           /* crc32 we must obtain after decompress all */
     116    uLong rest_read_compressed; /* number of byte to be decompressed */
     117    uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
     118    zlib_filefunc_def z_filefunc;
     119    voidpf filestream;        /* io structore of the zipfile */
     120    uLong compression_method;   /* compression method (0==store) */
     121    uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
     122    int   raw;
     123} file_in_zip_read_info_s;
     124
     125
     126/* unz_s contain internal information about the zipfile
     127*/
     128typedef struct
     129{
     130    zlib_filefunc_def z_filefunc;
     131    voidpf filestream;        /* io structore of the zipfile */
     132    unz_global_info gi;       /* public global information */
     133    uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
     134    uLong num_file;             /* number of the current file in the zipfile*/
     135    uLong pos_in_central_dir;   /* pos of the current file in the central dir*/
     136    uLong current_file_ok;      /* flag about the usability of the current file*/
     137    uLong central_pos;          /* position of the beginning of the central dir*/
     138
     139    uLong size_central_dir;     /* size of the central directory  */
     140    uLong offset_central_dir;   /* offset of start of central directory with
     141                                   respect to the starting disk number */
     142
     143    unz_file_info cur_file_info; /* public info about the current file in zip*/
     144    unz_file_info_internal cur_file_info_internal; /* private info about it*/
     145    file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
     146                                        file if we are decompressing it */
     147    int encrypted;
     148#    ifndef NOUNCRYPT
     149    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
     150    const unsigned long* pcrc_32_tab;
     151#    endif
     152} unz_s;
     153
     154
     155#ifndef NOUNCRYPT
     156#include "crypt.h"
     157#endif
     158
     159/* ===========================================================================
     160     Read a byte from a gz_stream; update next_in and avail_in. Return EOF
     161   for end of file.
     162   IN assertion: the stream s has been sucessfully opened for reading.
     163*/
     164
     165
     166local int unzlocal_getByte OF((
     167    const zlib_filefunc_def* pzlib_filefunc_def,
     168    voidpf filestream,
     169    int *pi));
     170
     171local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi)
     172    const zlib_filefunc_def* pzlib_filefunc_def;
     173    voidpf filestream;
     174    int *pi;
     175{
     176    unsigned char c;
     177    int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
     178    if (err==1)
     179    {
     180        *pi = (int)c;
     181        return UNZ_OK;
     182    }
     183    else
     184    {
     185        if (ZERROR(*pzlib_filefunc_def,filestream))
     186            return UNZ_ERRNO;
     187        else
     188            return UNZ_EOF;
     189    }
     190}
     191
     192
     193/* ===========================================================================
     194   Reads a long in LSB order from the given gz_stream. Sets
     195*/
     196local int unzlocal_getShort OF((
     197    const zlib_filefunc_def* pzlib_filefunc_def,
     198    voidpf filestream,
     199    uLong *pX));
     200
     201local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX)
     202    const zlib_filefunc_def* pzlib_filefunc_def;
     203    voidpf filestream;
     204    uLong *pX;
     205{
     206    uLong x ;
     207    int i;
     208    int err;
     209
     210    err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
     211    x = (uLong)i;
     212
     213    if (err==UNZ_OK)
     214        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
     215    x += ((uLong)i)<<8;
     216
     217    if (err==UNZ_OK)
     218        *pX = x;
     219    else
     220        *pX = 0;
     221    return err;
     222}
     223
     224local int unzlocal_getLong OF((
     225    const zlib_filefunc_def* pzlib_filefunc_def,
     226    voidpf filestream,
     227    uLong *pX));
     228
     229local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
     230    const zlib_filefunc_def* pzlib_filefunc_def;
     231    voidpf filestream;
     232    uLong *pX;
     233{
     234    uLong x ;
     235    int i;
     236    int err;
     237
     238    err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
     239    x = (uLong)i;
     240
     241    if (err==UNZ_OK)
     242        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
     243    x += ((uLong)i)<<8;
     244
     245    if (err==UNZ_OK)
     246        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
     247    x += ((uLong)i)<<16;
     248
     249    if (err==UNZ_OK)
     250        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
     251    x += ((uLong)i)<<24;
     252
     253    if (err==UNZ_OK)
     254        *pX = x;
     255    else
     256        *pX = 0;
     257    return err;
     258}
     259
     260
     261/* My own strcmpi / strcasecmp */
     262local int strcmpcasenosensitive_internal (fileName1,fileName2)
     263    const char* fileName1;
     264    const char* fileName2;
     265{
     266    for (;;)
     267    {
     268        char c1=*(fileName1++);
     269        char c2=*(fileName2++);
     270        if ((c1>='a') && (c1<='z'))
     271            c1 -= 0x20;
     272        if ((c2>='a') && (c2<='z'))
     273            c2 -= 0x20;
     274        if (c1=='\0')
     275            return ((c2=='\0') ? 0 : -1);
     276        if (c2=='\0')
     277            return 1;
     278        if (c1<c2)
     279            return -1;
     280        if (c1>c2)
     281            return 1;
     282    }
     283}
     284
     285
     286#ifdef  CASESENSITIVITYDEFAULT_NO
     287#define CASESENSITIVITYDEFAULTVALUE 2
     288#else
     289#define CASESENSITIVITYDEFAULTVALUE 1
     290#endif
     291
     292#ifndef STRCMPCASENOSENTIVEFUNCTION
     293#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
     294#endif
     295
     296/*
     297   Compare two filename (fileName1,fileName2).
     298   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
     299   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
     300                                                                or strcasecmp)
     301   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
     302        (like 1 on Unix, 2 on Windows)
     303
     304*/
     305extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
     306    const char* fileName1;
     307    const char* fileName2;
     308    int iCaseSensitivity;
     309{
     310    if (iCaseSensitivity==0)
     311        iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
     312
     313    if (iCaseSensitivity==1)
     314        return strcmp(fileName1,fileName2);
     315
     316    return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
     317}
     318
     319#ifndef BUFREADCOMMENT
     320#define BUFREADCOMMENT (0x400)
     321#endif
     322
     323/*
     324  Locate the Central directory of a zipfile (at the end, just before
     325    the global comment)
     326*/
     327local uLong unzlocal_SearchCentralDir OF((
     328    const zlib_filefunc_def* pzlib_filefunc_def,
     329    voidpf filestream));
     330
     331local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
     332    const zlib_filefunc_def* pzlib_filefunc_def;
     333    voidpf filestream;
     334{
     335    unsigned char* buf;
     336    uLong uSizeFile;
     337    uLong uBackRead;
     338    uLong uMaxBack=0xffff; /* maximum size of global comment */
     339    uLong uPosFound=0;
     340
     341    if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
     342        return 0;
     343
     344
     345    uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
     346
     347    if (uMaxBack>uSizeFile)
     348        uMaxBack = uSizeFile;
     349
     350    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
     351    if (buf==NULL)
     352        return 0;
     353
     354    uBackRead = 4;
     355    while (uBackRead<uMaxBack)
     356    {
     357        uLong uReadSize,uReadPos ;
     358        int i;
     359        if (uBackRead+BUFREADCOMMENT>uMaxBack)
     360            uBackRead = uMaxBack;
     361        else
     362            uBackRead+=BUFREADCOMMENT;
     363        uReadPos = uSizeFile-uBackRead ;
     364
     365        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
     366                     (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
     367        if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
     368            break;
     369
     370        if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
     371            break;
     372
     373        for (i=(int)uReadSize-3; (i--)>0;)
     374            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
     375                ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
     376            {
     377                uPosFound = uReadPos+i;
     378                break;
     379            }
     380
     381        if (uPosFound!=0)
     382            break;
     383    }
     384    TRYFREE(buf);
     385    return uPosFound;
     386}
     387
     388/*
     389  Open a Zip file. path contain the full pathname (by example,
     390     on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
     391     "zlib/zlib114.zip".
     392     If the zipfile cannot be opened (file doesn't exist or in not valid), the
     393       return value is NULL.
     394     Else, the return value is a unzFile Handle, usable with other function
     395       of this unzip package.
     396*/
     397extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
     398    const char *path;
     399    zlib_filefunc_def* pzlib_filefunc_def;
     400{
     401    unz_s us;
     402    unz_s *s;
     403    uLong central_pos,uL;
     404
     405    uLong number_disk;          /* number of the current dist, used for
     406                                   spaning ZIP, unsupported, always 0*/
     407    uLong number_disk_with_CD;  /* number the the disk with central dir, used
     408                                   for spaning ZIP, unsupported, always 0*/
     409    uLong number_entry_CD;      /* total number of entries in
     410                                   the central dir
     411                                   (same than number_entry on nospan) */
     412
     413    int err=UNZ_OK;
     414
     415    if (unz_copyright[0]!=' ')
     416        return NULL;
     417
     418    if (pzlib_filefunc_def==NULL)
     419        fill_fopen_filefunc(&us.z_filefunc);
     420    else
     421        us.z_filefunc = *pzlib_filefunc_def;
     422
     423    us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque,
     424                                                 path,
     425                                                 ZLIB_FILEFUNC_MODE_READ |
     426                                                 ZLIB_FILEFUNC_MODE_EXISTING);
     427    if (us.filestream==NULL)
     428        return NULL;
     429
     430    central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream);
     431    if (central_pos==0)
     432        err=UNZ_ERRNO;
     433
     434    if (ZSEEK(us.z_filefunc, us.filestream,
     435                                      central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
     436        err=UNZ_ERRNO;
     437
     438    /* the signature, already checked */
     439    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
     440        err=UNZ_ERRNO;
     441
     442    /* number of this disk */
     443    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
     444        err=UNZ_ERRNO;
     445
     446    /* number of the disk with the start of the central directory */
     447    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
     448        err=UNZ_ERRNO;
     449
     450    /* total number of entries in the central dir on this disk */
     451    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
     452        err=UNZ_ERRNO;
     453
     454    /* total number of entries in the central dir */
     455    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
     456        err=UNZ_ERRNO;
     457
     458    if ((number_entry_CD!=us.gi.number_entry) ||
     459        (number_disk_with_CD!=0) ||
     460        (number_disk!=0))
     461        err=UNZ_BADZIPFILE;
     462
     463    /* size of the central directory */
     464    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
     465        err=UNZ_ERRNO;
     466
     467    /* offset of start of central directory with respect to the
     468          starting disk number */
     469    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
     470        err=UNZ_ERRNO;
     471
     472    /* zipfile comment length */
     473    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
     474        err=UNZ_ERRNO;
     475
     476    if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
     477        (err==UNZ_OK))
     478        err=UNZ_BADZIPFILE;
     479
     480    if (err!=UNZ_OK)
     481    {
     482        ZCLOSE(us.z_filefunc, us.filestream);
     483        return NULL;
     484    }
     485
     486    us.byte_before_the_zipfile = central_pos -
     487                            (us.offset_central_dir+us.size_central_dir);
     488    us.central_pos = central_pos;
     489    us.pfile_in_zip_read = NULL;
     490    us.encrypted = 0;
     491
     492
     493    s=(unz_s*)ALLOC(sizeof(unz_s));
     494    *s=us;
     495    unzGoToFirstFile((unzFile)s);
     496    return (unzFile)s;
     497}
     498
     499
     500extern unzFile ZEXPORT unzOpen (path)
     501    const char *path;
     502{
     503    return unzOpen2(path, NULL);
     504}
     505
     506/*
     507  Close a ZipFile opened with unzipOpen.
     508  If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
     509    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
     510  return UNZ_OK if there is no problem. */
     511extern int ZEXPORT unzClose (file)
     512    unzFile file;
     513{
     514    unz_s* s;
     515    if (file==NULL)
     516        return UNZ_PARAMERROR;
     517    s=(unz_s*)file;
     518
     519    if (s->pfile_in_zip_read!=NULL)
     520        unzCloseCurrentFile(file);
     521
     522    ZCLOSE(s->z_filefunc, s->filestream);
     523    TRYFREE(s);
     524    return UNZ_OK;
     525}
     526
     527
     528/*
     529  Write info about the ZipFile in the *pglobal_info structure.
     530  No preparation of the structure is needed
     531  return UNZ_OK if there is no problem. */
     532extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
     533    unzFile file;
     534    unz_global_info *pglobal_info;
     535{
     536    unz_s* s;
     537    if (file==NULL)
     538        return UNZ_PARAMERROR;
     539    s=(unz_s*)file;
     540    *pglobal_info=s->gi;
     541    return UNZ_OK;
     542}
     543
     544
     545/*
     546   Translate date/time from Dos format to tm_unz (readable more easilty)
     547*/
     548local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
     549    uLong ulDosDate;
     550    tm_unz* ptm;
     551{
     552    uLong uDate;
     553    uDate = (uLong)(ulDosDate>>16);
     554    ptm->tm_mday = (uInt)(uDate&0x1f) ;
     555    ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
     556    ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
     557
     558    ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
     559    ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
     560    ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
     561}
     562
     563/*
     564  Get Info about the current file in the zipfile, with internal only info
     565*/
     566local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
     567                                                  unz_file_info *pfile_info,
     568                                                  unz_file_info_internal
     569                                                  *pfile_info_internal,
     570                                                  char *szFileName,
     571                                                  uLong fileNameBufferSize,
     572                                                  void *extraField,
     573                                                  uLong extraFieldBufferSize,
     574                                                  char *szComment,
     575                                                  uLong commentBufferSize));
     576
     577local int unzlocal_GetCurrentFileInfoInternal (file,
     578                                              pfile_info,
     579                                              pfile_info_internal,
     580                                              szFileName, fileNameBufferSize,
     581                                              extraField, extraFieldBufferSize,
     582                                              szComment,  commentBufferSize)
     583    unzFile file;
     584    unz_file_info *pfile_info;
     585    unz_file_info_internal *pfile_info_internal;
     586    char *szFileName;
     587    uLong fileNameBufferSize;
     588    void *extraField;
     589    uLong extraFieldBufferSize;
     590    char *szComment;
     591    uLong commentBufferSize;
     592{
     593    unz_s* s;
     594    unz_file_info file_info;
     595    unz_file_info_internal file_info_internal;
     596    int err=UNZ_OK;
     597    uLong uMagic;
     598    long lSeek=0;
     599
     600    if (file==NULL)
     601        return UNZ_PARAMERROR;
     602    s=(unz_s*)file;
     603    if (ZSEEK(s->z_filefunc, s->filestream,
     604              s->pos_in_central_dir+s->byte_before_the_zipfile,
     605              ZLIB_FILEFUNC_SEEK_SET)!=0)
     606        err=UNZ_ERRNO;
     607
     608
     609    /* we check the magic */
     610    if (err==UNZ_OK)
     611        if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
     612            err=UNZ_ERRNO;
     613        else if (uMagic!=0x02014b50)
     614            err=UNZ_BADZIPFILE;
     615
     616    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
     617        err=UNZ_ERRNO;
     618
     619    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
     620        err=UNZ_ERRNO;
     621
     622    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
     623        err=UNZ_ERRNO;
     624
     625    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
     626        err=UNZ_ERRNO;
     627
     628    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
     629        err=UNZ_ERRNO;
     630
     631    unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
     632
     633    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
     634        err=UNZ_ERRNO;
     635
     636    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
     637        err=UNZ_ERRNO;
     638
     639    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
     640        err=UNZ_ERRNO;
     641
     642    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
     643        err=UNZ_ERRNO;
     644
     645    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
     646        err=UNZ_ERRNO;
     647
     648    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
     649        err=UNZ_ERRNO;
     650
     651    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
     652        err=UNZ_ERRNO;
     653
     654    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
     655        err=UNZ_ERRNO;
     656
     657    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
     658        err=UNZ_ERRNO;
     659
     660    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
     661        err=UNZ_ERRNO;
     662
     663    lSeek+=file_info.size_filename;
     664    if ((err==UNZ_OK) && (szFileName!=NULL))
     665    {
     666        uLong uSizeRead ;
     667        if (file_info.size_filename<fileNameBufferSize)
     668        {
     669            *(szFileName+file_info.size_filename)='\0';
     670            uSizeRead = file_info.size_filename;
     671        }
     672        else
     673            uSizeRead = fileNameBufferSize;
     674
     675        if ((file_info.size_filename>0) && (fileNameBufferSize>0))
     676            if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
     677                err=UNZ_ERRNO;
     678        lSeek -= uSizeRead;
     679    }
     680
     681
     682    if ((err==UNZ_OK) && (extraField!=NULL))
     683    {
     684        uLong uSizeRead ;
     685        if (file_info.size_file_extra<extraFieldBufferSize)
     686            uSizeRead = file_info.size_file_extra;
     687        else
     688            uSizeRead = extraFieldBufferSize;
     689
     690        if (lSeek!=0)
     691            if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
     692                lSeek=0;
     693            else
     694                err=UNZ_ERRNO;
     695        if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
     696            if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead)
     697                err=UNZ_ERRNO;
     698        lSeek += file_info.size_file_extra - uSizeRead;
     699    }
     700    else
     701        lSeek+=file_info.size_file_extra;
     702
     703
     704    if ((err==UNZ_OK) && (szComment!=NULL))
     705    {
     706        uLong uSizeRead ;
     707        if (file_info.size_file_comment<commentBufferSize)
     708        {
     709            *(szComment+file_info.size_file_comment)='\0';
     710            uSizeRead = file_info.size_file_comment;
     711        }
     712        else
     713            uSizeRead = commentBufferSize;
     714
     715        if (lSeek!=0)
     716            if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
     717                lSeek=0;
     718            else
     719                err=UNZ_ERRNO;
     720        if ((file_info.size_file_comment>0) && (commentBufferSize>0))
     721            if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
     722                err=UNZ_ERRNO;
     723        lSeek+=file_info.size_file_comment - uSizeRead;
     724    }
     725    else
     726        lSeek+=file_info.size_file_comment;
     727
     728    if ((err==UNZ_OK) && (pfile_info!=NULL))
     729        *pfile_info=file_info;
     730
     731    if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
     732        *pfile_info_internal=file_info_internal;
     733
     734    return err;
     735}
     736
     737
     738
     739/*
     740  Write info about the ZipFile in the *pglobal_info structure.
     741  No preparation of the structure is needed
     742  return UNZ_OK if there is no problem.
     743*/
     744extern int ZEXPORT unzGetCurrentFileInfo (file,
     745                                          pfile_info,
     746                                          szFileName, fileNameBufferSize,
     747                                          extraField, extraFieldBufferSize,
     748                                          szComment,  commentBufferSize)
     749    unzFile file;
     750    unz_file_info *pfile_info;
     751    char *szFileName;
     752    uLong fileNameBufferSize;
     753    void *extraField;
     754    uLong extraFieldBufferSize;
     755    char *szComment;
     756    uLong commentBufferSize;
     757{
     758    return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
     759                                                szFileName,fileNameBufferSize,
     760                                                extraField,extraFieldBufferSize,
     761                                                szComment,commentBufferSize);
     762}
     763
     764/*
     765  Set the current file of the zipfile to the first file.
     766  return UNZ_OK if there is no problem
     767*/
     768extern int ZEXPORT unzGoToFirstFile (file)
     769    unzFile file;
     770{
     771    int err=UNZ_OK;
     772    unz_s* s;
     773    if (file==NULL)
     774        return UNZ_PARAMERROR;
     775    s=(unz_s*)file;
     776    s->pos_in_central_dir=s->offset_central_dir;
     777    s->num_file=0;
     778    err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
     779                                             &s->cur_file_info_internal,
     780                                             NULL,0,NULL,0,NULL,0);
     781    s->current_file_ok = (err == UNZ_OK);
     782    return err;
     783}
     784
     785/*
     786  Set the current file of the zipfile to the next file.
     787  return UNZ_OK if there is no problem
     788  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
     789*/
     790extern int ZEXPORT unzGoToNextFile (file)
     791    unzFile file;
     792{
     793    unz_s* s;
     794    int err;
     795
     796    if (file==NULL)
     797        return UNZ_PARAMERROR;
     798    s=(unz_s*)file;
     799    if (!s->current_file_ok)
     800        return UNZ_END_OF_LIST_OF_FILE;
     801    if (s->gi.number_entry != 0xffff)    /* 2^16 files overflow hack */
     802      if (s->num_file+1==s->gi.number_entry)
     803        return UNZ_END_OF_LIST_OF_FILE;
     804
     805    s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
     806            s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
     807    s->num_file++;
     808    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
     809                                               &s->cur_file_info_internal,
     810                                               NULL,0,NULL,0,NULL,0);
     811    s->current_file_ok = (err == UNZ_OK);
     812    return err;
     813}
     814
     815
     816/*
     817  Try locate the file szFileName in the zipfile.
     818  For the iCaseSensitivity signification, see unzipStringFileNameCompare
     819
     820  return value :
     821  UNZ_OK if the file is found. It becomes the current file.
     822  UNZ_END_OF_LIST_OF_FILE if the file is not found
     823*/
     824extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
     825    unzFile file;
     826    const char *szFileName;
     827    int iCaseSensitivity;
     828{
     829    unz_s* s;
     830    int err;
     831
     832    /* We remember the 'current' position in the file so that we can jump
     833     * back there if we fail.
     834     */
     835    unz_file_info cur_file_infoSaved;
     836    unz_file_info_internal cur_file_info_internalSaved;
     837    uLong num_fileSaved;
     838    uLong pos_in_central_dirSaved;
     839
     840
     841    if (file==NULL)
     842        return UNZ_PARAMERROR;
     843
     844    if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
     845        return UNZ_PARAMERROR;
     846
     847    s=(unz_s*)file;
     848    if (!s->current_file_ok)
     849        return UNZ_END_OF_LIST_OF_FILE;
     850
     851    /* Save the current state */
     852    num_fileSaved = s->num_file;
     853    pos_in_central_dirSaved = s->pos_in_central_dir;
     854    cur_file_infoSaved = s->cur_file_info;
     855    cur_file_info_internalSaved = s->cur_file_info_internal;
     856
     857    err = unzGoToFirstFile(file);
     858
     859    while (err == UNZ_OK)
     860    {
     861        char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
     862        err = unzGetCurrentFileInfo(file,NULL,
     863                                    szCurrentFileName,sizeof(szCurrentFileName)-1,
     864                                    NULL,0,NULL,0);
     865        if (err == UNZ_OK)
     866        {
     867            if (unzStringFileNameCompare(szCurrentFileName,
     868                                            szFileName,iCaseSensitivity)==0)
     869                return UNZ_OK;
     870            err = unzGoToNextFile(file);
     871        }
     872    }
     873
     874    /* We failed, so restore the state of the 'current file' to where we
     875     * were.
     876     */
     877    s->num_file = num_fileSaved ;
     878    s->pos_in_central_dir = pos_in_central_dirSaved ;
     879    s->cur_file_info = cur_file_infoSaved;
     880    s->cur_file_info_internal = cur_file_info_internalSaved;
     881    return err;
     882}
     883
     884
     885/*
     886///////////////////////////////////////////
     887// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
     888// I need random access
     889//
     890// Further optimization could be realized by adding an ability
     891// to cache the directory in memory. The goal being a single
     892// comprehensive file read to put the file I need in a memory.
     893*/
     894
     895/*
     896typedef struct unz_file_pos_s
     897{
     898    uLong pos_in_zip_directory;   // offset in file
     899    uLong num_of_file;            // # of file
     900} unz_file_pos;
     901*/
     902
     903extern int ZEXPORT unzGetFilePos(file, file_pos)
     904    unzFile file;
     905    unz_file_pos* file_pos;
     906{
     907    unz_s* s;
     908
     909    if (file==NULL || file_pos==NULL)
     910        return UNZ_PARAMERROR;
     911    s=(unz_s*)file;
     912    if (!s->current_file_ok)
     913        return UNZ_END_OF_LIST_OF_FILE;
     914
     915    file_pos->pos_in_zip_directory  = s->pos_in_central_dir;
     916    file_pos->num_of_file           = s->num_file;
     917
     918    return UNZ_OK;
     919}
     920
     921extern int ZEXPORT unzGoToFilePos(file, file_pos)
     922    unzFile file;
     923    unz_file_pos* file_pos;
     924{
     925    unz_s* s;
     926    int err;
     927
     928    if (file==NULL || file_pos==NULL)
     929        return UNZ_PARAMERROR;
     930    s=(unz_s*)file;
     931
     932    /* jump to the right spot */
     933    s->pos_in_central_dir = file_pos->pos_in_zip_directory;
     934    s->num_file           = file_pos->num_of_file;
     935
     936    /* set the current file */
     937    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
     938                                               &s->cur_file_info_internal,
     939                                               NULL,0,NULL,0,NULL,0);
     940    /* return results */
     941    s->current_file_ok = (err == UNZ_OK);
     942    return err;
     943}
     944
     945/*
     946// Unzip Helper Functions - should be here?
     947///////////////////////////////////////////
     948*/
     949
     950/*
     951  Read the local header of the current zipfile
     952  Check the coherency of the local header and info in the end of central
     953        directory about this file
     954  store in *piSizeVar the size of extra info in local header
     955        (filename and size of extra field data)
     956*/
     957local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
     958                                                    poffset_local_extrafield,
     959                                                    psize_local_extrafield)
     960    unz_s* s;
     961    uInt* piSizeVar;
     962    uLong *poffset_local_extrafield;
     963    uInt  *psize_local_extrafield;
     964{
     965    uLong uMagic,uData,uFlags;
     966    uLong size_filename;
     967    uLong size_extra_field;
     968    int err=UNZ_OK;
     969
     970    *piSizeVar = 0;
     971    *poffset_local_extrafield = 0;
     972    *psize_local_extrafield = 0;
     973
     974    if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
     975                                s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
     976        return UNZ_ERRNO;
     977
     978
     979    if (err==UNZ_OK)
     980        if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
     981            err=UNZ_ERRNO;
     982        else if (uMagic!=0x04034b50)
     983            err=UNZ_BADZIPFILE;
     984
     985    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
     986        err=UNZ_ERRNO;
     987/*
     988    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
     989        err=UNZ_BADZIPFILE;
     990*/
     991    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
     992        err=UNZ_ERRNO;
     993
     994    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
     995        err=UNZ_ERRNO;
     996    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
     997        err=UNZ_BADZIPFILE;
     998
     999    if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
     1000                         (s->cur_file_info.compression_method!=Z_DEFLATED))
     1001        err=UNZ_BADZIPFILE;
     1002
     1003    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
     1004        err=UNZ_ERRNO;
     1005
     1006    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
     1007        err=UNZ_ERRNO;
     1008    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
     1009                              ((uFlags & 8)==0))
     1010        err=UNZ_BADZIPFILE;
     1011
     1012    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
     1013        err=UNZ_ERRNO;
     1014    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
     1015                              ((uFlags & 8)==0))
     1016        err=UNZ_BADZIPFILE;
     1017
     1018    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
     1019        err=UNZ_ERRNO;
     1020    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
     1021                              ((uFlags & 8)==0))
     1022        err=UNZ_BADZIPFILE;
     1023
     1024
     1025    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
     1026        err=UNZ_ERRNO;
     1027    else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
     1028        err=UNZ_BADZIPFILE;
     1029
     1030    *piSizeVar += (uInt)size_filename;
     1031
     1032    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
     1033        err=UNZ_ERRNO;
     1034    *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
     1035                                    SIZEZIPLOCALHEADER + size_filename;
     1036    *psize_local_extrafield = (uInt)size_extra_field;
     1037
     1038    *piSizeVar += (uInt)size_extra_field;
     1039
     1040    return err;
     1041}
     1042
     1043/*
     1044  Open for reading data the current file in the zipfile.
     1045  If there is no error and the file is opened, the return value is UNZ_OK.
     1046*/
     1047extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
     1048    unzFile file;
     1049    int* method;
     1050    int* level;
     1051    int raw;
     1052    const char* password;
     1053{
     1054    int err=UNZ_OK;
     1055    uInt iSizeVar;
     1056    unz_s* s;
     1057    file_in_zip_read_info_s* pfile_in_zip_read_info;
     1058    uLong offset_local_extrafield;  /* offset of the local extra field */
     1059    uInt  size_local_extrafield;    /* size of the local extra field */
     1060#    ifndef NOUNCRYPT
     1061    char source[12];
     1062#    else
     1063    if (password != NULL)
     1064        return UNZ_PARAMERROR;
     1065#    endif
     1066
     1067    if (file==NULL)
     1068        return UNZ_PARAMERROR;
     1069    s=(unz_s*)file;
     1070    if (!s->current_file_ok)
     1071        return UNZ_PARAMERROR;
     1072
     1073    if (s->pfile_in_zip_read != NULL)
     1074        unzCloseCurrentFile(file);
     1075
     1076    if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
     1077                &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
     1078        return UNZ_BADZIPFILE;
     1079
     1080    pfile_in_zip_read_info = (file_in_zip_read_info_s*)
     1081                                        ALLOC(sizeof(file_in_zip_read_info_s));
     1082    if (pfile_in_zip_read_info==NULL)
     1083        return UNZ_INTERNALERROR;
     1084
     1085    pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
     1086    pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
     1087    pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
     1088    pfile_in_zip_read_info->pos_local_extrafield=0;
     1089    pfile_in_zip_read_info->raw=raw;
     1090
     1091    if (pfile_in_zip_read_info->read_buffer==NULL)
     1092    {
     1093        TRYFREE(pfile_in_zip_read_info);
     1094        return UNZ_INTERNALERROR;
     1095    }
     1096
     1097    pfile_in_zip_read_info->stream_initialised=0;
     1098
     1099    if (method!=NULL)
     1100        *method = (int)s->cur_file_info.compression_method;
     1101
     1102    if (level!=NULL)
     1103    {
     1104        *level = 6;
     1105        switch (s->cur_file_info.flag & 0x06)
     1106        {
     1107          case 6 : *level = 1; break;
     1108          case 4 : *level = 2; break;
     1109          case 2 : *level = 9; break;
     1110        }
     1111    }
     1112
     1113    if ((s->cur_file_info.compression_method!=0) &&
     1114        (s->cur_file_info.compression_method!=Z_DEFLATED))
     1115        err=UNZ_BADZIPFILE;
     1116
     1117    pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
     1118    pfile_in_zip_read_info->crc32=0;
     1119    pfile_in_zip_read_info->compression_method =
     1120            s->cur_file_info.compression_method;
     1121    pfile_in_zip_read_info->filestream=s->filestream;
     1122    pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
     1123    pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
     1124
     1125    pfile_in_zip_read_info->stream.total_out = 0;
     1126
     1127    if ((s->cur_file_info.compression_method==Z_DEFLATED) &&
     1128        (!raw))
     1129    {
     1130      pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
     1131      pfile_in_zip_read_info->stream.zfree = (free_func)0;
     1132      pfile_in_zip_read_info->stream.opaque = (voidpf)0;
     1133      pfile_in_zip_read_info->stream.next_in = (voidpf)0;
     1134      pfile_in_zip_read_info->stream.avail_in = 0;
     1135
     1136      err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
     1137      if (err == Z_OK)
     1138        pfile_in_zip_read_info->stream_initialised=1;
     1139      else
     1140      {
     1141        TRYFREE(pfile_in_zip_read_info);
     1142        return err;
     1143      }
     1144        /* windowBits is passed < 0 to tell that there is no zlib header.
     1145         * Note that in this case inflate *requires* an extra "dummy" byte
     1146         * after the compressed stream in order to complete decompression and
     1147         * return Z_STREAM_END.
     1148         * In unzip, i don't wait absolutely Z_STREAM_END because I known the
     1149         * size of both compressed and uncompressed data
     1150         */
     1151    }
     1152    pfile_in_zip_read_info->rest_read_compressed =
     1153            s->cur_file_info.compressed_size ;
     1154    pfile_in_zip_read_info->rest_read_uncompressed =
     1155            s->cur_file_info.uncompressed_size ;
     1156
     1157
     1158    pfile_in_zip_read_info->pos_in_zipfile =
     1159            s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
     1160              iSizeVar;
     1161
     1162    pfile_in_zip_read_info->stream.avail_in = (uInt)0;
     1163
     1164    s->pfile_in_zip_read = pfile_in_zip_read_info;
     1165
     1166#    ifndef NOUNCRYPT
     1167    if (password != NULL)
     1168    {
     1169        int i;
     1170        s->pcrc_32_tab = get_crc_table();
     1171        init_keys(password,s->keys,s->pcrc_32_tab);
     1172        if (ZSEEK(s->z_filefunc, s->filestream,
     1173                  s->pfile_in_zip_read->pos_in_zipfile +
     1174                     s->pfile_in_zip_read->byte_before_the_zipfile,
     1175                  SEEK_SET)!=0)
     1176            return UNZ_INTERNALERROR;
     1177        if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12)
     1178            return UNZ_INTERNALERROR;
     1179
     1180        for (i = 0; i<12; i++)
     1181            zdecode(s->keys,s->pcrc_32_tab,source[i]);
     1182
     1183        s->pfile_in_zip_read->pos_in_zipfile+=12;
     1184        s->encrypted=1;
     1185    }
     1186#    endif
     1187
     1188
     1189    return UNZ_OK;
     1190}
     1191
     1192extern int ZEXPORT unzOpenCurrentFile (file)
     1193    unzFile file;
     1194{
     1195    return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
     1196}
     1197
     1198extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
     1199    unzFile file;
     1200    const char* password;
     1201{
     1202    return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
     1203}
     1204
     1205extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
     1206    unzFile file;
     1207    int* method;
     1208    int* level;
     1209    int raw;
     1210{
     1211    return unzOpenCurrentFile3(file, method, level, raw, NULL);
     1212}
     1213
     1214/*
     1215  Read bytes from the current file.
     1216  buf contain buffer where data must be copied
     1217  len the size of buf.
     1218
     1219  return the number of byte copied if somes bytes are copied
     1220  return 0 if the end of file was reached
     1221  return <0 with error code if there is an error
     1222    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
     1223*/
     1224extern int ZEXPORT unzReadCurrentFile  (file, buf, len)
     1225    unzFile file;
     1226    voidp buf;
     1227    unsigned len;
     1228{
     1229    int err=UNZ_OK;
     1230    uInt iRead = 0;
     1231    unz_s* s;
     1232    file_in_zip_read_info_s* pfile_in_zip_read_info;
     1233    if (file==NULL)
     1234        return UNZ_PARAMERROR;
     1235    s=(unz_s*)file;
     1236    pfile_in_zip_read_info=s->pfile_in_zip_read;
     1237
     1238    if (pfile_in_zip_read_info==NULL)
     1239        return UNZ_PARAMERROR;
     1240
     1241
     1242    if ((pfile_in_zip_read_info->read_buffer == NULL))
     1243        return UNZ_END_OF_LIST_OF_FILE;
     1244    if (len==0)
     1245        return 0;
     1246
     1247    pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
     1248
     1249    pfile_in_zip_read_info->stream.avail_out = (uInt)len;
     1250
     1251    if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
     1252        (!(pfile_in_zip_read_info->raw)))
     1253        pfile_in_zip_read_info->stream.avail_out =
     1254            (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
     1255
     1256    if ((len>pfile_in_zip_read_info->rest_read_compressed+
     1257           pfile_in_zip_read_info->stream.avail_in) &&
     1258         (pfile_in_zip_read_info->raw))
     1259        pfile_in_zip_read_info->stream.avail_out =
     1260            (uInt)pfile_in_zip_read_info->rest_read_compressed+
     1261            pfile_in_zip_read_info->stream.avail_in;
     1262
     1263    while (pfile_in_zip_read_info->stream.avail_out>0)
     1264    {
     1265        if ((pfile_in_zip_read_info->stream.avail_in==0) &&
     1266            (pfile_in_zip_read_info->rest_read_compressed>0))
     1267        {
     1268            uInt uReadThis = UNZ_BUFSIZE;
     1269            if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
     1270                uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
     1271            if (uReadThis == 0)
     1272                return UNZ_EOF;
     1273            if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
     1274                      pfile_in_zip_read_info->filestream,
     1275                      pfile_in_zip_read_info->pos_in_zipfile +
     1276                         pfile_in_zip_read_info->byte_before_the_zipfile,
     1277                         ZLIB_FILEFUNC_SEEK_SET)!=0)
     1278                return UNZ_ERRNO;
     1279            if (ZREAD(pfile_in_zip_read_info->z_filefunc,
     1280                      pfile_in_zip_read_info->filestream,
     1281                      pfile_in_zip_read_info->read_buffer,
     1282                      uReadThis)!=uReadThis)
     1283                return UNZ_ERRNO;
     1284
     1285
     1286#            ifndef NOUNCRYPT
     1287            if(s->encrypted)
     1288            {
     1289                uInt i;
     1290                for(i=0;i<uReadThis;i++)
     1291                  pfile_in_zip_read_info->read_buffer[i] =
     1292                      zdecode(s->keys,s->pcrc_32_tab,
     1293                              pfile_in_zip_read_info->read_buffer[i]);
     1294            }
     1295#            endif
     1296
     1297
     1298            pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
     1299
     1300            pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
     1301
     1302            pfile_in_zip_read_info->stream.next_in =
     1303                (Bytef*)pfile_in_zip_read_info->read_buffer;
     1304            pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
     1305        }
     1306
     1307        if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
     1308        {
     1309            uInt uDoCopy,i ;
     1310
     1311            if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
     1312                (pfile_in_zip_read_info->rest_read_compressed == 0))
     1313                return (iRead==0) ? UNZ_EOF : iRead;
     1314
     1315            if (pfile_in_zip_read_info->stream.avail_out <
     1316                            pfile_in_zip_read_info->stream.avail_in)
     1317                uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
     1318            else
     1319                uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
     1320
     1321            for (i=0;i<uDoCopy;i++)
     1322                *(pfile_in_zip_read_info->stream.next_out+i) =
     1323                        *(pfile_in_zip_read_info->stream.next_in+i);
     1324
     1325            pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
     1326                                pfile_in_zip_read_info->stream.next_out,
     1327                                uDoCopy);
     1328            pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
     1329            pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
     1330            pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
     1331            pfile_in_zip_read_info->stream.next_out += uDoCopy;
     1332            pfile_in_zip_read_info->stream.next_in += uDoCopy;
     1333            pfile_in_zip_read_info->stream.total_out += uDoCopy;
     1334            iRead += uDoCopy;
     1335        }
     1336        else
     1337        {
     1338            uLong uTotalOutBefore,uTotalOutAfter;
     1339            const Bytef *bufBefore;
     1340            uLong uOutThis;
     1341            int flush=Z_SYNC_FLUSH;
     1342
     1343            uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
     1344            bufBefore = pfile_in_zip_read_info->stream.next_out;
     1345
     1346            /*
     1347            if ((pfile_in_zip_read_info->rest_read_uncompressed ==
     1348                     pfile_in_zip_read_info->stream.avail_out) &&
     1349                (pfile_in_zip_read_info->rest_read_compressed == 0))
     1350                flush = Z_FINISH;
     1351            */
     1352            err=inflate(&pfile_in_zip_read_info->stream,flush);
     1353
     1354            if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
     1355              err = Z_DATA_ERROR;
     1356
     1357            uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
     1358            uOutThis = uTotalOutAfter-uTotalOutBefore;
     1359
     1360            pfile_in_zip_read_info->crc32 =
     1361                crc32(pfile_in_zip_read_info->crc32,bufBefore,
     1362                        (uInt)(uOutThis));
     1363
     1364            pfile_in_zip_read_info->rest_read_uncompressed -=
     1365                uOutThis;
     1366
     1367            iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
     1368
     1369            if (err==Z_STREAM_END)
     1370                return (iRead==0) ? UNZ_EOF : iRead;
     1371            if (err!=Z_OK)
     1372                break;
     1373        }
     1374    }
     1375
     1376    if (err==Z_OK)
     1377        return iRead;
     1378    return err;
     1379}
     1380
     1381
     1382/*
     1383  Give the current position in uncompressed data
     1384*/
     1385extern z_off_t ZEXPORT unztell (file)
     1386    unzFile file;
     1387{
     1388    unz_s* s;
     1389    file_in_zip_read_info_s* pfile_in_zip_read_info;
     1390    if (file==NULL)
     1391        return UNZ_PARAMERROR;
     1392    s=(unz_s*)file;
     1393    pfile_in_zip_read_info=s->pfile_in_zip_read;
     1394
     1395    if (pfile_in_zip_read_info==NULL)
     1396        return UNZ_PARAMERROR;
     1397
     1398    return (z_off_t)pfile_in_zip_read_info->stream.total_out;
     1399}
     1400
     1401
     1402/*
     1403  return 1 if the end of file was reached, 0 elsewhere
     1404*/
     1405extern int ZEXPORT unzeof (file)
     1406    unzFile file;
     1407{
     1408    unz_s* s;
     1409    file_in_zip_read_info_s* pfile_in_zip_read_info;
     1410    if (file==NULL)
     1411        return UNZ_PARAMERROR;
     1412    s=(unz_s*)file;
     1413    pfile_in_zip_read_info=s->pfile_in_zip_read;
     1414
     1415    if (pfile_in_zip_read_info==NULL)
     1416        return UNZ_PARAMERROR;
     1417
     1418    if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
     1419        return 1;
     1420    else
     1421        return 0;
     1422}
     1423
     1424
     1425
     1426/*
     1427  Read extra field from the current file (opened by unzOpenCurrentFile)
     1428  This is the local-header version of the extra field (sometimes, there is
     1429    more info in the local-header version than in the central-header)
     1430
     1431  if buf==NULL, it return the size of the local extra field that can be read
     1432
     1433  if buf!=NULL, len is the size of the buffer, the extra header is copied in
     1434    buf.
     1435  the return value is the number of bytes copied in buf, or (if <0)
     1436    the error code
     1437*/
     1438extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
     1439    unzFile file;
     1440    voidp buf;
     1441    unsigned len;
     1442{
     1443    unz_s* s;
     1444    file_in_zip_read_info_s* pfile_in_zip_read_info;
     1445    uInt read_now;
     1446    uLong size_to_read;
     1447
     1448    if (file==NULL)
     1449        return UNZ_PARAMERROR;
     1450    s=(unz_s*)file;
     1451    pfile_in_zip_read_info=s->pfile_in_zip_read;
     1452
     1453    if (pfile_in_zip_read_info==NULL)
     1454        return UNZ_PARAMERROR;
     1455
     1456    size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
     1457                pfile_in_zip_read_info->pos_local_extrafield);
     1458
     1459    if (buf==NULL)
     1460        return (int)size_to_read;
     1461
     1462    if (len>size_to_read)
     1463        read_now = (uInt)size_to_read;
     1464    else
     1465        read_now = (uInt)len ;
     1466
     1467    if (read_now==0)
     1468        return 0;
     1469
     1470    if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
     1471              pfile_in_zip_read_info->filestream,
     1472              pfile_in_zip_read_info->offset_local_extrafield +
     1473              pfile_in_zip_read_info->pos_local_extrafield,
     1474              ZLIB_FILEFUNC_SEEK_SET)!=0)
     1475        return UNZ_ERRNO;
     1476
     1477    if (ZREAD(pfile_in_zip_read_info->z_filefunc,
     1478              pfile_in_zip_read_info->filestream,
     1479              buf,read_now)!=read_now)
     1480        return UNZ_ERRNO;
     1481
     1482    return (int)read_now;
     1483}
     1484
     1485/*
     1486  Close the file in zip opened with unzipOpenCurrentFile
     1487  Return UNZ_CRCERROR if all the file was read but the CRC is not good
     1488*/
     1489extern int ZEXPORT unzCloseCurrentFile (file)
     1490    unzFile file;
     1491{
     1492    int err=UNZ_OK;
     1493
     1494    unz_s* s;
     1495    file_in_zip_read_info_s* pfile_in_zip_read_info;
     1496    if (file==NULL)
     1497        return UNZ_PARAMERROR;
     1498    s=(unz_s*)file;
     1499    pfile_in_zip_read_info=s->pfile_in_zip_read;
     1500
     1501    if (pfile_in_zip_read_info==NULL)
     1502        return UNZ_PARAMERROR;
     1503
     1504
     1505    if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
     1506        (!pfile_in_zip_read_info->raw))
     1507    {
     1508        if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
     1509            err=UNZ_CRCERROR;
     1510    }
     1511
     1512
     1513    TRYFREE(pfile_in_zip_read_info->read_buffer);
     1514    pfile_in_zip_read_info->read_buffer = NULL;
     1515    if (pfile_in_zip_read_info->stream_initialised)
     1516        inflateEnd(&pfile_in_zip_read_info->stream);
     1517
     1518    pfile_in_zip_read_info->stream_initialised = 0;
     1519    TRYFREE(pfile_in_zip_read_info);
     1520
     1521    s->pfile_in_zip_read=NULL;
     1522
     1523    return err;
     1524}
     1525
     1526
     1527/*
     1528  Get the global comment string of the ZipFile, in the szComment buffer.
     1529  uSizeBuf is the size of the szComment buffer.
     1530  return the number of byte copied or an error code <0
     1531*/
     1532extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
     1533    unzFile file;
     1534    char *szComment;
     1535    uLong uSizeBuf;
     1536{
     1537    int err=UNZ_OK;
     1538    unz_s* s;
     1539    uLong uReadThis ;
     1540    if (file==NULL)
     1541        return UNZ_PARAMERROR;
     1542    s=(unz_s*)file;
     1543
     1544    uReadThis = uSizeBuf;
     1545    if (uReadThis>s->gi.size_comment)
     1546        uReadThis = s->gi.size_comment;
     1547
     1548    if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
     1549        return UNZ_ERRNO;
     1550
     1551    if (uReadThis>0)
     1552    {
     1553      *szComment='\0';
     1554      if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
     1555        return UNZ_ERRNO;
     1556    }
     1557
     1558    if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
     1559        *(szComment+s->gi.size_comment)='\0';
     1560    return (int)uReadThis;
     1561}
     1562
     1563/* Additions by RX '2004 */
     1564extern uLong ZEXPORT unzGetOffset (file)
     1565    unzFile file;
     1566{
     1567    unz_s* s;
     1568
     1569    if (file==NULL)
     1570          return UNZ_PARAMERROR;
     1571    s=(unz_s*)file;
     1572    if (!s->current_file_ok)
     1573      return 0;
     1574    if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
     1575      if (s->num_file==s->gi.number_entry)
     1576         return 0;
     1577    return s->pos_in_central_dir;
     1578}
     1579
     1580extern int ZEXPORT unzSetOffset (file, pos)
     1581        unzFile file;
     1582        uLong pos;
     1583{
     1584    unz_s* s;
     1585    int err;
     1586
     1587    if (file==NULL)
     1588        return UNZ_PARAMERROR;
     1589    s=(unz_s*)file;
     1590
     1591    s->pos_in_central_dir = pos;
     1592    s->num_file = s->gi.number_entry;      /* hack */
     1593    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
     1594                                              &s->cur_file_info_internal,
     1595                                              NULL,0,NULL,0,NULL,0);
     1596    s->current_file_ok = (err == UNZ_OK);
     1597    return err;
     1598}
  • backends/platform/iphone/nuzip/crypt.h

     
     1/* crypt.h -- base code for crypt/uncrypt ZIPfile
     2
     3
     4   Version 1.01e, February 12th, 2005
     5
     6   Copyright (C) 1998-2005 Gilles Vollant
     7
     8   This code is a modified version of crypting code in Infozip distribution
     9
     10   The encryption/decryption parts of this source code (as opposed to the
     11   non-echoing password parts) were originally written in Europe.  The
     12   whole source package can be freely distributed, including from the USA.
     13   (Prior to January 2000, re-export from the US was a violation of US law.)
     14
     15   This encryption code is a direct transcription of the algorithm from
     16   Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
     17   file (appnote.txt) is distributed with the PKZIP program (even in the
     18   version without encryption capabilities).
     19
     20   If you don't need crypting in your application, just define symbols
     21   NOCRYPT and NOUNCRYPT.
     22
     23   This code support the "Traditional PKWARE Encryption".
     24
     25   The new AES encryption added on Zip format by Winzip (see the page
     26   http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
     27   Encryption is not supported.
     28*/
     29
     30#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
     31
     32/***********************************************************************
     33 * Return the next byte in the pseudo-random sequence
     34 */
     35static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
     36{
     37    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
     38                     * unpredictable manner on 16-bit systems; not a problem
     39                     * with any known compiler so far, though */
     40
     41    temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
     42    return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
     43}
     44
     45/***********************************************************************
     46 * Update the encryption keys with the next byte of plain text
     47 */
     48static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
     49{
     50    (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
     51    (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
     52    (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
     53    {
     54      register int keyshift = (int)((*(pkeys+1)) >> 24);
     55      (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
     56    }
     57    return c;
     58}
     59
     60
     61/***********************************************************************
     62 * Initialize the encryption keys and the random header according to
     63 * the given password.
     64 */
     65static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
     66{
     67    *(pkeys+0) = 305419896L;
     68    *(pkeys+1) = 591751049L;
     69    *(pkeys+2) = 878082192L;
     70    while (*passwd != '\0') {
     71        update_keys(pkeys,pcrc_32_tab,(int)*passwd);
     72        passwd++;
     73    }
     74}
     75
     76#define zdecode(pkeys,pcrc_32_tab,c) \
     77    (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
     78
     79#define zencode(pkeys,pcrc_32_tab,c,t) \
     80    (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
     81
     82#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
     83
     84#define RAND_HEAD_LEN  12
     85   /* "last resort" source for second part of crypt seed pattern */
     86#  ifndef ZCR_SEED2
     87#    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
     88#  endif
     89
     90static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
     91    const char *passwd;         /* password string */
     92    unsigned char *buf;         /* where to write header */
     93    int bufSize;
     94    unsigned long* pkeys;
     95    const unsigned long* pcrc_32_tab;
     96    unsigned long crcForCrypting;
     97{
     98    int n;                       /* index in random header */
     99    int t;                       /* temporary */
     100    int c;                       /* random byte */
     101    unsigned char header[RAND_HEAD_LEN-2]; /* random header */
     102    static unsigned calls = 0;   /* ensure different random header each time */
     103
     104    if (bufSize<RAND_HEAD_LEN)
     105      return 0;
     106
     107    /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
     108     * output of rand() to get less predictability, since rand() is
     109     * often poorly implemented.
     110     */
     111    if (++calls == 1)
     112    {
     113        srand((unsigned)(time(NULL) ^ ZCR_SEED2));
     114    }
     115    init_keys(passwd, pkeys, pcrc_32_tab);
     116    for (n = 0; n < RAND_HEAD_LEN-2; n++)
     117    {
     118        c = (rand() >> 7) & 0xff;
     119        header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
     120    }
     121    /* Encrypt random header (last two bytes is high word of crc) */
     122    init_keys(passwd, pkeys, pcrc_32_tab);
     123    for (n = 0; n < RAND_HEAD_LEN-2; n++)
     124    {
     125        buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
     126    }
     127    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
     128    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
     129    return n;
     130}
     131
     132#endif
  • backends/platform/iphone/nuzip/ioapi.h

     
     1/* ioapi.h -- IO base function header for compress/uncompress .zip
     2   files using zlib + zip or unzip API
     3
     4   Version 1.01e, February 12th, 2005
     5
     6   Copyright (C) 1998-2005 Gilles Vollant
     7*/
     8
     9#ifndef _ZLIBIOAPI_H
     10#define _ZLIBIOAPI_H
     11
     12
     13#define ZLIB_FILEFUNC_SEEK_CUR (1)
     14#define ZLIB_FILEFUNC_SEEK_END (2)
     15#define ZLIB_FILEFUNC_SEEK_SET (0)
     16
     17#define ZLIB_FILEFUNC_MODE_READ      (1)
     18#define ZLIB_FILEFUNC_MODE_WRITE     (2)
     19#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
     20
     21#define ZLIB_FILEFUNC_MODE_EXISTING (4)
     22#define ZLIB_FILEFUNC_MODE_CREATE   (8)
     23
     24
     25#ifndef ZCALLBACK
     26
     27#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
     28#define ZCALLBACK CALLBACK
     29#else
     30#define ZCALLBACK
     31#endif
     32#endif
     33
     34#ifdef __cplusplus
     35extern "C" {
     36#endif
     37
     38typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
     39typedef uLong  (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
     40typedef uLong  (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
     41typedef long   (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
     42typedef long   (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
     43typedef int    (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
     44typedef int    (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
     45
     46typedef struct zlib_filefunc_def_s
     47{
     48    open_file_func      zopen_file;
     49    read_file_func      zread_file;
     50    write_file_func     zwrite_file;
     51    tell_file_func      ztell_file;
     52    seek_file_func      zseek_file;
     53    close_file_func     zclose_file;
     54    testerror_file_func zerror_file;
     55    voidpf              opaque;
     56} zlib_filefunc_def;
     57
     58
     59
     60void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
     61
     62#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
     63#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
     64#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
     65#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
     66#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
     67#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
     68
     69
     70#ifdef __cplusplus
     71}
     72#endif
     73
     74#endif
     75
  • backends/platform/iphone/nuzip/mztools.c

     
     1/*
     2  Additional tools for Minizip
     3  Code: Xavier Roche '2004
     4  License: Same as ZLIB (www.gzip.org)
     5*/
     6
     7/* Code */
     8#include <stdio.h>
     9#include <stdlib.h>
     10#include <string.h>
     11#include <zlib.h>
     12#include "unzip.h"
     13
     14#define READ_8(adr)  ((unsigned char)*(adr))
     15#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) )
     16#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) )
     17
     18#define WRITE_8(buff, n) do { \
     19  *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \
     20} while(0)
     21#define WRITE_16(buff, n) do { \
     22  WRITE_8((unsigned char*)(buff), n); \
     23  WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \
     24} while(0)
     25#define WRITE_32(buff, n) do { \
     26  WRITE_16((unsigned char*)(buff), (n) & 0xffff); \
     27  WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \
     28} while(0)
     29
     30extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered)
     31const char* file;
     32const char* fileOut;
     33const char* fileOutTmp;
     34uLong* nRecovered;
     35uLong* bytesRecovered;
     36{
     37  int err = Z_OK;
     38  FILE* fpZip = fopen(file, "rb");
     39  FILE* fpOut = fopen(fileOut, "wb");
     40  FILE* fpOutCD = fopen(fileOutTmp, "wb");
     41  if (fpZip != NULL &&  fpOut != NULL) {
     42    int entries = 0;
     43    uLong totalBytes = 0;
     44    char header[30];
     45    char filename[256];
     46    char extra[1024];
     47    int offset = 0;
     48    int offsetCD = 0;
     49    while ( fread(header, 1, 30, fpZip) == 30 ) {
     50      int currentOffset = offset;
     51
     52      /* File entry */
     53      if (READ_32(header) == 0x04034b50) {
     54        unsigned int version = READ_16(header + 4);
     55        unsigned int gpflag = READ_16(header + 6);
     56        unsigned int method = READ_16(header + 8);
     57        unsigned int filetime = READ_16(header + 10);
     58        unsigned int filedate = READ_16(header + 12);
     59        unsigned int crc = READ_32(header + 14); /* crc */
     60        unsigned int cpsize = READ_32(header + 18); /* compressed size */
     61        unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */
     62        unsigned int fnsize = READ_16(header + 26); /* file name length */
     63        unsigned int extsize = READ_16(header + 28); /* extra field length */
     64        filename[0] = extra[0] = '\0';
     65       
     66        /* Header */
     67        if (fwrite(header, 1, 30, fpOut) == 30) {
     68          offset += 30;
     69        } else {
     70          err = Z_ERRNO;
     71          break;
     72        }
     73       
     74        /* Filename */
     75        if (fnsize > 0) {
     76          if (fread(filename, 1, fnsize, fpZip) == fnsize) {
     77            if (fwrite(filename, 1, fnsize, fpOut) == fnsize) {
     78              offset += fnsize;
     79            } else {
     80              err = Z_ERRNO;
     81              break;
     82            }
     83          } else {
     84            err = Z_ERRNO;
     85            break;
     86          }
     87        } else {
     88          err = Z_STREAM_ERROR;
     89          break;
     90        }
     91
     92        /* Extra field */
     93        if (extsize > 0) {
     94          if (fread(extra, 1, extsize, fpZip) == extsize) {
     95            if (fwrite(extra, 1, extsize, fpOut) == extsize) {
     96              offset += extsize;
     97            } else {
     98              err = Z_ERRNO;
     99              break;
     100            }
     101          } else {
     102            err = Z_ERRNO;
     103            break;
     104          }
     105        }
     106       
     107        /* Data */
     108        {
     109          int dataSize = cpsize;
     110          if (dataSize == 0) {
     111            dataSize = uncpsize;
     112          }
     113          if (dataSize > 0) {
     114            char* data = malloc(dataSize);
     115            if (data != NULL) {
     116              if ((int)fread(data, 1, dataSize, fpZip) == dataSize) {
     117                if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) {
     118                  offset += dataSize;
     119                  totalBytes += dataSize;
     120                } else {
     121                  err = Z_ERRNO;
     122                }
     123              } else {
     124                err = Z_ERRNO;
     125              }
     126              free(data);
     127              if (err != Z_OK) {
     128                break;
     129              }
     130            } else {
     131              err = Z_MEM_ERROR;
     132              break;
     133            }
     134          }
     135        }
     136       
     137        /* Central directory entry */
     138        {
     139          char header[46];
     140          char* comment = "";
     141          int comsize = (int) strlen(comment);
     142          WRITE_32(header, 0x02014b50);
     143          WRITE_16(header + 4, version);
     144          WRITE_16(header + 6, version);
     145          WRITE_16(header + 8, gpflag);
     146          WRITE_16(header + 10, method);
     147          WRITE_16(header + 12, filetime);
     148          WRITE_16(header + 14, filedate);
     149          WRITE_32(header + 16, crc);
     150          WRITE_32(header + 20, cpsize);
     151          WRITE_32(header + 24, uncpsize);
     152          WRITE_16(header + 28, fnsize);
     153          WRITE_16(header + 30, extsize);
     154          WRITE_16(header + 32, comsize);
     155          WRITE_16(header + 34, 0);     /* disk # */
     156          WRITE_16(header + 36, 0);     /* int attrb */
     157          WRITE_32(header + 38, 0);     /* ext attrb */
     158          WRITE_32(header + 42, currentOffset);
     159          /* Header */
     160          if (fwrite(header, 1, 46, fpOutCD) == 46) {
     161            offsetCD += 46;
     162           
     163            /* Filename */
     164            if (fnsize > 0) {
     165              if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) {
     166                offsetCD += fnsize;
     167              } else {
     168                err = Z_ERRNO;
     169                break;
     170              }
     171            } else {
     172              err = Z_STREAM_ERROR;
     173              break;
     174            }
     175           
     176            /* Extra field */
     177            if (extsize > 0) {
     178              if (fwrite(extra, 1, extsize, fpOutCD) == extsize) {
     179                offsetCD += extsize;
     180              } else {
     181                err = Z_ERRNO;
     182                break;
     183              }
     184            }
     185           
     186            /* Comment field */
     187            if (comsize > 0) {
     188              if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) {
     189                offsetCD += comsize;
     190              } else {
     191                err = Z_ERRNO;
     192                break;
     193              }
     194            }
     195           
     196           
     197          } else {
     198            err = Z_ERRNO;
     199            break;
     200          }
     201        }
     202
     203        /* Success */
     204        entries++;
     205
     206      } else {
     207        break;
     208      }
     209    }
     210
     211    /* Final central directory  */
     212    {
     213      int entriesZip = entries;
     214      char header[22];
     215      char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
     216      int comsize = (int) strlen(comment);
     217      if (entriesZip > 0xffff) {
     218        entriesZip = 0xffff;
     219      }
     220      WRITE_32(header, 0x06054b50);
     221      WRITE_16(header + 4, 0);    /* disk # */
     222      WRITE_16(header + 6, 0);    /* disk # */
     223      WRITE_16(header + 8, entriesZip);   /* hack */
     224      WRITE_16(header + 10, entriesZip);  /* hack */
     225      WRITE_32(header + 12, offsetCD);    /* size of CD */
     226      WRITE_32(header + 16, offset);      /* offset to CD */
     227      WRITE_16(header + 20, comsize);     /* comment */
     228     
     229      /* Header */
     230      if (fwrite(header, 1, 22, fpOutCD) == 22) {
     231       
     232        /* Comment field */
     233        if (comsize > 0) {
     234          if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) {
     235            err = Z_ERRNO;
     236          }
     237        }
     238       
     239      } else {
     240        err = Z_ERRNO;
     241      }
     242    }
     243
     244    /* Final merge (file + central directory) */
     245    fclose(fpOutCD);
     246    if (err == Z_OK) {
     247      fpOutCD = fopen(fileOutTmp, "rb");
     248      if (fpOutCD != NULL) {
     249        int nRead;
     250        char buffer[8192];
     251        while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) {
     252          if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) {
     253            err = Z_ERRNO;
     254            break;
     255          }
     256        }
     257        fclose(fpOutCD);
     258      }
     259    }
     260   
     261    /* Close */
     262    fclose(fpZip);
     263    fclose(fpOut);
     264   
     265    /* Wipe temporary file */
     266    (void)remove(fileOutTmp);
     267   
     268    /* Number of recovered entries */
     269    if (err == Z_OK) {
     270      if (nRecovered != NULL) {
     271        *nRecovered = entries;
     272      }
     273      if (bytesRecovered != NULL) {
     274        *bytesRecovered = totalBytes;
     275      }
     276    }
     277  } else {
     278    err = Z_STREAM_ERROR;
     279  }
     280  return err;
     281}
  • backends/platform/iphone/nuzip/zip.h

     
     1/* zip.h -- IO for compress .zip files using zlib
     2   Version 1.01e, February 12th, 2005
     3
     4   Copyright (C) 1998-2005 Gilles Vollant
     5
     6   This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
     7     WinZip, InfoZip tools and compatible.
     8   Multi volume ZipFile (span) are not supported.
     9   Encryption compatible with pkzip 2.04g only supported
     10   Old compressions used by old PKZip 1.x are not supported
     11
     12  For uncompress .zip file, look at unzip.h
     13
     14
     15   I WAIT FEEDBACK at mail info@winimage.com
     16   Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
     17
     18   Condition of use and distribution are the same than zlib :
     19
     20  This software is provided 'as-is', without any express or implied
     21  warranty.  In no event will the authors be held liable for any damages
     22  arising from the use of this software.
     23
     24  Permission is granted to anyone to use this software for any purpose,
     25  including commercial applications, and to alter it and redistribute it
     26  freely, subject to the following restrictions:
     27
     28  1. The origin of this software must not be misrepresented; you must not
     29     claim that you wrote the original software. If you use this software
     30     in a product, an acknowledgment in the product documentation would be
     31     appreciated but is not required.
     32  2. Altered source versions must be plainly marked as such, and must not be
     33     misrepresented as being the original software.
     34  3. This notice may not be removed or altered from any source distribution.
     35
     36
     37*/
     38
     39/* for more info about .ZIP format, see
     40      http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
     41      http://www.info-zip.org/pub/infozip/doc/
     42   PkWare has also a specification at :
     43      ftp://ftp.pkware.com/probdesc.zip
     44*/
     45
     46#ifndef _zip_H
     47#define _zip_H
     48
     49#ifdef __cplusplus
     50extern "C" {
     51#endif
     52
     53#ifndef _ZLIB_H
     54#include <zlib.h>
     55#endif
     56
     57#ifndef _ZLIBIOAPI_H
     58#include "ioapi.h"
     59#endif
     60
     61#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
     62/* like the STRICT of WIN32, we define a pointer that cannot be converted
     63    from (void*) without cast */
     64typedef struct TagzipFile__ { int unused; } zipFile__;
     65typedef zipFile__ *zipFile;
     66#else
     67typedef voidp zipFile;
     68#endif
     69
     70#define ZIP_OK                          (0)
     71#define ZIP_EOF                         (0)
     72#define ZIP_ERRNO                       (Z_ERRNO)
     73#define ZIP_PARAMERROR                  (-102)
     74#define ZIP_BADZIPFILE                  (-103)
     75#define ZIP_INTERNALERROR               (-104)
     76
     77#ifndef DEF_MEM_LEVEL
     78#  if MAX_MEM_LEVEL >= 8
     79#    define DEF_MEM_LEVEL 8
     80#  else
     81#    define DEF_MEM_LEVEL  MAX_MEM_LEVEL
     82#  endif
     83#endif
     84/* default memLevel */
     85
     86/* tm_zip contain date/time info */
     87typedef struct tm_zip_s
     88{
     89    uInt tm_sec;            /* seconds after the minute - [0,59] */
     90    uInt tm_min;            /* minutes after the hour - [0,59] */
     91    uInt tm_hour;           /* hours since midnight - [0,23] */
     92    uInt tm_mday;           /* day of the month - [1,31] */
     93    uInt tm_mon;            /* months since January - [0,11] */
     94    uInt tm_year;           /* years - [1980..2044] */
     95} tm_zip;
     96
     97typedef struct
     98{
     99    tm_zip      tmz_date;       /* date in understandable format           */
     100    uLong       dosDate;       /* if dos_date == 0, tmu_date is used      */
     101/*    uLong       flag;        */   /* general purpose bit flag        2 bytes */
     102
     103    uLong       internal_fa;    /* internal file attributes        2 bytes */
     104    uLong       external_fa;    /* external file attributes        4 bytes */
     105} zip_fileinfo;
     106
     107typedef const char* zipcharpc;
     108
     109
     110#define APPEND_STATUS_CREATE        (0)
     111#define APPEND_STATUS_CREATEAFTER   (1)
     112#define APPEND_STATUS_ADDINZIP      (2)
     113
     114extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
     115/*
     116  Create a zipfile.
     117     pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
     118       an Unix computer "zlib/zlib113.zip".
     119     if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
     120       will be created at the end of the file.
     121         (useful if the file contain a self extractor code)
     122     if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
     123       add files in existing zip (be sure you don't add file that doesn't exist)
     124     If the zipfile cannot be opened, the return value is NULL.
     125     Else, the return value is a zipFile Handle, usable with other function
     126       of this zip package.
     127*/
     128
     129/* Note : there is no delete function into a zipfile.
     130   If you want delete file into a zipfile, you must open a zipfile, and create another
     131   Of couse, you can use RAW reading and writing to copy the file you did not want delte
     132*/
     133
     134extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
     135                                   int append,
     136                                   zipcharpc* globalcomment,
     137                                   zlib_filefunc_def* pzlib_filefunc_def));
     138
     139extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
     140                       const char* filename,
     141                       const zip_fileinfo* zipfi,
     142                       const void* extrafield_local,
     143                       uInt size_extrafield_local,
     144                       const void* extrafield_global,
     145                       uInt size_extrafield_global,
     146                       const char* comment,
     147                       int method,
     148                       int level));
     149/*
     150  Open a file in the ZIP for writing.
     151  filename : the filename in zip (if NULL, '-' without quote will be used
     152  *zipfi contain supplemental information
     153  if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
     154    contains the extrafield data the the local header
     155  if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
     156    contains the extrafield data the the local header
     157  if comment != NULL, comment contain the comment string
     158  method contain the compression method (0 for store, Z_DEFLATED for deflate)
     159  level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
     160*/
     161
     162
     163extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
     164                                            const char* filename,
     165                                            const zip_fileinfo* zipfi,
     166                                            const void* extrafield_local,
     167                                            uInt size_extrafield_local,
     168                                            const void* extrafield_global,
     169                                            uInt size_extrafield_global,
     170                                            const char* comment,
     171                                            int method,
     172                                            int level,
     173                                            int raw));
     174
     175/*
     176  Same than zipOpenNewFileInZip, except if raw=1, we write raw file
     177 */
     178
     179extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
     180                                            const char* filename,
     181                                            const zip_fileinfo* zipfi,
     182                                            const void* extrafield_local,
     183                                            uInt size_extrafield_local,
     184                                            const void* extrafield_global,
     185                                            uInt size_extrafield_global,
     186                                            const char* comment,
     187                                            int method,
     188                                            int level,
     189                                            int raw,
     190                                            int windowBits,
     191                                            int memLevel,
     192                                            int strategy,
     193                                            const char* password,
     194                                            uLong crcForCtypting));
     195
     196/*
     197  Same than zipOpenNewFileInZip2, except
     198    windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
     199    password : crypting password (NULL for no crypting)
     200    crcForCtypting : crc of file to compress (needed for crypting)
     201 */
     202
     203
     204extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
     205                       const void* buf,
     206                       unsigned len));
     207/*
     208  Write data in the zipfile
     209*/
     210
     211extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
     212/*
     213  Close the current file in the zipfile
     214*/
     215
     216extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
     217                                            uLong uncompressed_size,
     218                                            uLong crc32));
     219/*
     220  Close the current file in the zipfile, for fiel opened with
     221    parameter raw=1 in zipOpenNewFileInZip2
     222  uncompressed_size and crc32 are value for the uncompressed size
     223*/
     224
     225extern int ZEXPORT zipClose OF((zipFile file,
     226                const char* global_comment));
     227/*
     228  Close the zipfile
     229*/
     230
     231#ifdef __cplusplus
     232}
     233#endif
     234
     235#endif /* _zip_H */
  • backends/platform/iphone/nuzip/NuZip.h

     
     1
     2
     3#import <Foundation/Foundation.h>
     4
     5@interface NuZip : NSObject {}
     6
     7+ (int) unzip:(NSString *) command;
     8+ (int) zip:(NSString *) command;
     9
     10@end
  • backends/platform/iphone/nuzip/unzip.h

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

     
     1/*
     2  Additional tools for Minizip
     3  Code: Xavier Roche '2004
     4  License: Same as ZLIB (www.gzip.org)
     5*/
     6
     7#ifndef _zip_tools_H
     8#define _zip_tools_H
     9
     10#ifdef __cplusplus
     11extern "C" {
     12#endif
     13
     14#ifndef _ZLIB_H
     15#include "zlib.h"
     16#endif
     17
     18#include "unzip.h"
     19
     20/* Repair a ZIP file (missing central directory)
     21   file: file to recover
     22   fileOut: output file after recovery
     23   fileOutTmp: temporary file name used for recovery
     24*/
     25extern int ZEXPORT unzRepair(const char* file,
     26                             const char* fileOut,
     27                             const char* fileOutTmp,
     28                             uLong* nRecovered,
     29                             uLong* bytesRecovered);
     30
     31#endif