← Back to branch summary

~hexmode/+junk/main

« back to all changes in this revision

Viewing changes to install-files/apps/phpmyadmin2.10.1/libraries/unzip.lib.php

  • Committer: Mark A. Hershberger
  • Date: 2008-01-05 19:38:56 UTC
  • Revision ID: hershberger@spawn-xp-20080105193856-6rnzgwa4nehue3qj
initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
install-files/apps/phpmyadmin2.10.1/libraries/unzip.lib.php
 
1
<?PHP
 
2
    /* $Id: unzip.lib.php 9747 2006-11-19 20:57:24Z nijel $ */
 
3
 
 
4
    /**
 
5
     *  ZIP file unpack classes. Contributed to the phpMyAdmin project.
 
6
     *
 
7
     *  @category   phpPublic
 
8
     *  @package    File-Formats-ZIP
 
9
     *  @subpackage Unzip
 
10
     *  @filesource unzip.lib.php
 
11
     *  @version    1.0.1
 
12
     *
 
13
     *  @author     Holger Boskugel <vbwebprofi@gmx.de>
 
14
     *  @copyright  Copyright © 2003, Holger Boskugel, Berlin, Germany
 
15
     *  @license    http://opensource.org/licenses/gpl-license.php GNU Public License
 
16
     *
 
17
     *  @history
 
18
     *  2003-12-02 - HB : Patched : naming bug : Time/Size of file
 
19
     *                    Added   : ZIP file comment
 
20
     *                    Added   : Check BZIP2 support of PHP
 
21
     *  2003-11-29 - HB * Initial version
 
22
     */
 
23
 
 
24
    /**
 
25
     *  Unzip class, which retrieves entries from ZIP files.
 
26
     *
 
27
     *  Supports only the compression modes
 
28
     *  -  0 : Stored,
 
29
     *  -  8 : Deflated and
 
30
     *  - 12 : BZIP2
 
31
     *
 
32
     *  Based on :<BR>
 
33
     *  <BR>
 
34
     *  {@link http://www.pkware.com/products/enterprise/white_papers/appnote.html
 
35
     *  * Official ZIP file format}<BR>
 
36
     *  {@link http://msdn.microsoft.com/library/en-us/w98ddk/hh/w98ddk/storage_5l4m.asp
 
37
     *  * Microsoft DOS date/time format}
 
38
     *
 
39
     *  @category   phpPublic
 
40
     *  @package    File-Formats-ZIP
 
41
     *  @subpackage Unzip
 
42
     *  @version    1.0.1
 
43
     *  @author     Holger Boskugel <vbwebprofi@gmx.de>
 
44
     *  @uses       SimpleUnzipEntry
 
45
     *  @example    example.unzip.php Two examples
 
46
     */
 
47
    class SimpleUnzip {
 
48
// 2003-12-02 - HB >
 
49
        /**
 
50
         *  Array to store file entries
 
51
         *
 
52
         *  @var    string
 
53
         *  @access public
 
54
         *  @see    ReadFile()
 
55
         *  @since  1.0.1
 
56
         */
 
57
        var $Comment = '';
 
58
// 2003-12-02 - HB <
 
59
 
 
60
        /**
 
61
         *  Array to store file entries
 
62
         *
 
63
         *  @var    array
 
64
         *  @access public
 
65
         *  @see    ReadFile()
 
66
         *  @since  1.0
 
67
         */
 
68
        var $Entries = array();
 
69
 
 
70
        /**
 
71
         *  Name of the ZIP file
 
72
         *
 
73
         *  @var    string
 
74
         *  @access public
 
75
         *  @see    ReadFile()
 
76
         *  @since  1.0
 
77
         */
 
78
        var $Name = '';
 
79
 
 
80
        /**
 
81
         *  Size of the ZIP file
 
82
         *
 
83
         *  @var    integer
 
84
         *  @access public
 
85
         *  @see    ReadFile()
 
86
         *  @since  1.0
 
87
         */
 
88
        var $Size = 0;
 
89
 
 
90
        /**
 
91
         *  Time of the ZIP file (unix timestamp)
 
92
         *
 
93
         *  @var    integer
 
94
         *  @access public
 
95
         *  @see    ReadFile()
 
96
         *  @since  1.0
 
97
         */
 
98
        var $Time = 0;
 
99
 
 
100
        /**
 
101
         *  Contructor of the class
 
102
         *
 
103
         *  @param  string      File name
 
104
         *  @return SimpleUnzip Instanced class
 
105
         *  @access public
 
106
         *  @uses   SimpleUnzip::ReadFile() Opens file on new if specified
 
107
         *  @since  1.0
 
108
         */
 
109
        function SimpleUnzip($in_FileName = '')
 
110
        {
 
111
            if ($in_FileName !== '') {
 
112
                SimpleUnzip::ReadFile($in_FileName);
 
113
            }
 
114
        } // end of the 'SimpleUnzip' constructor
 
115
 
 
116
        /**
 
117
         *  Counts the entries
 
118
         *
 
119
         *  @return integer Count of ZIP entries
 
120
         *  @access public
 
121
         *  @uses   $Entries
 
122
         *  @since  1.0
 
123
         */
 
124
        function Count()
 
125
        {
 
126
            return count($this->Entries);
 
127
        } // end of the 'Count()' method
 
128
 
 
129
        /**
 
130
         *  Gets data of the specified ZIP entry
 
131
         *
 
132
         *  @param  integer Index of the ZIP entry
 
133
         *  @return mixed   Data for the ZIP entry
 
134
         *  @uses   SimpleUnzipEntry::$Data
 
135
         *  @access public
 
136
         *  @since  1.0
 
137
         */
 
138
        function GetData($in_Index)
 
139
        {
 
140
            return $this->Entries[$in_Index]->Data;
 
141
        } // end of the 'GetData()' method
 
142
 
 
143
        /**
 
144
         *  Gets an entry of the ZIP file
 
145
         *
 
146
         *  @param  integer             Index of the ZIP entry
 
147
         *  @return SimpleUnzipEntry    Entry of the ZIP file
 
148
         *  @uses   $Entries
 
149
         *  @access public
 
150
         *  @since  1.0
 
151
         */
 
152
        function GetEntry($in_Index)
 
153
        {
 
154
            return $this->Entries[$in_Index];
 
155
        } // end of the 'GetEntry()' method
 
156
 
 
157
        /**
 
158
         *  Gets error code for the specified ZIP entry
 
159
         *
 
160
         *  @param  integer     Index of the ZIP entry
 
161
         *  @return integer     Error code for the ZIP entry
 
162
         *  @uses   SimpleUnzipEntry::$Error
 
163
         *  @access public
 
164
         *  @since   1.0
 
165
         */
 
166
        function GetError($in_Index)
 
167
        {
 
168
            return $this->Entries[$in_Index]->Error;
 
169
        } // end of the 'GetError()' method
 
170
 
 
171
        /**
 
172
         *  Gets error message for the specified ZIP entry
 
173
         *
 
174
         *  @param  integer     Index of the ZIP entry
 
175
         *  @return string      Error message for the ZIP entry
 
176
         *  @uses   SimpleUnzipEntry::$ErrorMsg
 
177
         *  @access public
 
178
         *  @since  1.0
 
179
         */
 
180
        function GetErrorMsg($in_Index)
 
181
        {
 
182
            return $this->Entries[$in_Index]->ErrorMsg;
 
183
        } // end of the 'GetErrorMsg()' method
 
184
 
 
185
        /**
 
186
         *  Gets file name for the specified ZIP entry
 
187
         *
 
188
         *  @param  integer     Index of the ZIP entry
 
189
         *  @return string      File name for the ZIP entry
 
190
         *  @uses   SimpleUnzipEntry::$Name
 
191
         *  @access public
 
192
         *  @since  1.0
 
193
         */
 
194
        function GetName($in_Index)
 
195
        {
 
196
            return $this->Entries[$in_Index]->Name;
 
197
        } // end of the 'GetName()' method
 
198
 
 
199
        /**
 
200
         *  Gets path of the file for the specified ZIP entry
 
201
         *
 
202
         *  @param  integer     Index of the ZIP entry
 
203
         *  @return string      Path of the file for the ZIP entry
 
204
         *  @uses   SimpleUnzipEntry::$Path
 
205
         *  @access public
 
206
         *  @since  1.0
 
207
         */
 
208
        function GetPath($in_Index)
 
209
        {
 
210
            return $this->Entries[$in_Index]->Path;
 
211
        } // end of the 'GetPath()' method
 
212
 
 
213
        /**
 
214
         *  Gets file time for the specified ZIP entry
 
215
         *
 
216
         *  @param  integer     Index of the ZIP entry
 
217
         *  @return integer     File time for the ZIP entry (unix timestamp)
 
218
         *  @uses   SimpleUnzipEntry::$Time
 
219
         *  @access public
 
220
         *  @since  1.0
 
221
         */
 
222
        function GetTime($in_Index)
 
223
        {
 
224
            return $this->Entries[$in_Index]->Time;
 
225
        } // end of the 'GetTime()' method
 
226
 
 
227
        /**
 
228
         *  Reads ZIP file and extracts the entries
 
229
         *
 
230
         *  @param  string              File name of the ZIP archive
 
231
         *  @return array               ZIP entry list (see also class variable {@link $Entries $Entries})
 
232
         *  @uses   SimpleUnzipEntry    For the entries
 
233
         *  @access public
 
234
         *  @since  1.0
 
235
         */
 
236
        function ReadFile($in_FileName)
 
237
        {
 
238
            $this->Entries = array();
 
239
 
 
240
            // Get file parameters
 
241
            $this->Name = $in_FileName;
 
242
            $this->Time = filemtime($in_FileName);
 
243
            $this->Size = filesize($in_FileName);
 
244
 
 
245
            // Read file
 
246
            $oF = fopen($in_FileName, 'rb');
 
247
            $vZ = fread($oF, $this->Size);
 
248
            fclose($oF);
 
249
 
 
250
// 2003-12-02 - HB >
 
251
            // Cut end of central directory
 
252
            $aE = explode("\x50\x4b\x05\x06", $vZ);
 
253
 
 
254
            // Easiest way, but not sure if format changes
 
255
            //$this->Comment = substr($aE[1], 18);
 
256
 
 
257
            // Normal way
 
258
            $aP = unpack('x16/v1CL', $aE[1]);
 
259
            $this->Comment = substr($aE[1], 18, $aP['CL']);
 
260
 
 
261
            // Translates end of line from other operating systems
 
262
            $this->Comment = strtr($this->Comment, array("\r\n" => "\n",
 
263
                                                         "\r"   => "\n"));
 
264
// 2003-12-02 - HB <
 
265
 
 
266
            // Cut the entries from the central directory
 
267
            $aE = explode("\x50\x4b\x01\x02", $vZ);
 
268
            // Explode to each part
 
269
            $aE = explode("\x50\x4b\x03\x04", $aE[0]);
 
270
            // Shift out spanning signature or empty entry
 
271
            array_shift($aE);
 
272
 
 
273
            // Loop through the entries
 
274
            foreach ($aE as $vZ) {
 
275
                $aI = array();
 
276
                $aI['E']  = 0;
 
277
                $aI['EM'] = '';
 
278
                // Retrieving local file header information
 
279
                $aP = unpack('v1VN/v1GPF/v1CM/v1FT/v1FD/V1CRC/V1CS/V1UCS/v1FNL', $vZ);
 
280
                // Check if data is encrypted
 
281
                $bE = ($aP['GPF'] & 0x0001) ? TRUE : FALSE;
 
282
                $nF = $aP['FNL'];
 
283
 
 
284
                // Special case : value block after the compressed data
 
285
                if ($aP['GPF'] & 0x0008) {
 
286
                    $aP1 = unpack('V1CRC/V1CS/V1UCS', substr($vZ, -12));
 
287
 
 
288
                    $aP['CRC'] = $aP1['CRC'];
 
289
                    $aP['CS']  = $aP1['CS'];
 
290
                    $aP['UCS'] = $aP1['UCS'];
 
291
 
 
292
                    $vZ = substr($vZ, 0, -12);
 
293
                }
 
294
 
 
295
                // Getting stored filename
 
296
                $aI['N'] = substr($vZ, 26, $nF);
 
297
 
 
298
                if (substr($aI['N'], -1) == '/') {
 
299
                    // is a directory entry - will be skipped
 
300
                    continue;
 
301
                }
 
302
 
 
303
                // Truncate full filename in path and filename
 
304
                $aI['P'] = dirname($aI['N']);
 
305
                $aI['P'] = $aI['P'] == '.' ? '' : $aI['P'];
 
306
                $aI['N'] = basename($aI['N']);
 
307
 
 
308
                $vZ = substr($vZ, 26 + $nF);
 
309
 
 
310
                if (strlen($vZ) != $aP['CS']) {
 
311
                  $aI['E']  = 1;
 
312
                  $aI['EM'] = 'Compressed size is not equal with the value in header information.';
 
313
                } else {
 
314
                    if ($bE) {
 
315
                        $aI['E']  = 5;
 
316
                        $aI['EM'] = 'File is encrypted, which is not supported from this class.';
 
317
                    } else {
 
318
                        switch($aP['CM']) {
 
319
                            case 0: // Stored
 
320
                                // Here is nothing to do, the file ist flat.
 
321
                                break;
 
322
 
 
323
                            case 8: // Deflated
 
324
                                $vZ = gzinflate($vZ);
 
325
                                break;
 
326
 
 
327
                            case 12: // BZIP2
 
328
// 2003-12-02 - HB >
 
329
                                if (! extension_loaded('bz2')) {
 
330
                                    if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') {
 
331
                                      @dl('php_bz2.dll');
 
332
                                    } else {
 
333
                                      @dl('bz2.so');
 
334
                                    }
 
335
                                }
 
336
 
 
337
                                if (extension_loaded('bz2')) {
 
338
// 2003-12-02 - HB <
 
339
                                    $vZ = bzdecompress($vZ);
 
340
// 2003-12-02 - HB >
 
341
                                } else {
 
342
                                    $aI['E']  = 7;
 
343
                                    $aI['EM'] = "PHP BZIP2 extension not available.";
 
344
                                }
 
345
// 2003-12-02 - HB <
 
346
 
 
347
                                break;
 
348
 
 
349
                            default:
 
350
                              $aI['E']  = 6;
 
351
                              $aI['EM'] = "De-/Compression method {$aP['CM']} is not supported.";
 
352
                        }
 
353
 
 
354
// 2003-12-02 - HB >
 
355
                        if (! $aI['E']) {
 
356
// 2003-12-02 - HB <
 
357
                            if ($vZ === FALSE) {
 
358
                                $aI['E']  = 2;
 
359
                                $aI['EM'] = 'Decompression of data failed.';
 
360
                            } else {
 
361
                                if (strlen($vZ) != $aP['UCS']) {
 
362
                                    $aI['E']  = 3;
 
363
                                    $aI['EM'] = 'Uncompressed size is not equal with the value in header information.';
 
364
                                } else {
 
365
                                    if (crc32($vZ) != $aP['CRC']) {
 
366
                                        $aI['E']  = 4;
 
367
                                        $aI['EM'] = 'CRC32 checksum is not equal with the value in header information.';
 
368
                                    }
 
369
                                }
 
370
                            }
 
371
// 2003-12-02 - HB >
 
372
                        }
 
373
// 2003-12-02 - HB <
 
374
                    }
 
375
                }
 
376
 
 
377
                $aI['D'] = $vZ;
 
378
 
 
379
                // DOS to UNIX timestamp
 
380
                $aI['T'] = mktime(($aP['FT']  & 0xf800) >> 11,
 
381
                                  ($aP['FT']  & 0x07e0) >>  5,
 
382
                                  ($aP['FT']  & 0x001f) <<  1,
 
383
                                  ($aP['FD']  & 0x01e0) >>  5,
 
384
                                  ($aP['FD']  & 0x001f),
 
385
                                  (($aP['FD'] & 0xfe00) >>  9) + 1980);
 
386
 
 
387
                $this->Entries[] = &new SimpleUnzipEntry($aI);
 
388
            } // end for each entries
 
389
 
 
390
            return $this->Entries;
 
391
        } // end of the 'ReadFile()' method
 
392
    } // end of the 'SimpleUnzip' class
 
393
 
 
394
    /**
 
395
     *  Entry of the ZIP file.
 
396
     *
 
397
     *  @category   phpPublic
 
398
     *  @package    File-Formats-ZIP
 
399
     *  @subpackage Unzip
 
400
     *  @version    1.0
 
401
     *  @author     Holger Boskugel <vbwebprofi@gmx.de>
 
402
     *  @example    example.unzip.php Two examples
 
403
     */
 
404
    class SimpleUnzipEntry {
 
405
        /**
 
406
         *  Data of the file entry
 
407
         *
 
408
         *  @var    mixed
 
409
         *  @access public
 
410
         *  @see    SimpleUnzipEntry()
 
411
         *  @since  1.0
 
412
         */
 
413
        var $Data = '';
 
414
 
 
415
        /**
 
416
         *  Error of the file entry
 
417
         *
 
418
         *  - 0 : No error raised.<BR>
 
419
         *  - 1 : Compressed size is not equal with the value in header information.<BR>
 
420
         *  - 2 : Decompression of data failed.<BR>
 
421
         *  - 3 : Uncompressed size is not equal with the value in header information.<BR>
 
422
         *  - 4 : CRC32 checksum is not equal with the value in header information.<BR>
 
423
         *  - 5 : File is encrypted, which is not supported from this class.<BR>
 
424
         *  - 6 : De-/Compression method ... is not supported.<BR>
 
425
         *  - 7 : PHP BZIP2 extension not available.
 
426
         *
 
427
         *  @var    integer
 
428
         *  @access public
 
429
         *  @see    SimpleUnzipEntry()
 
430
         *  @since  1.0
 
431
         */
 
432
        var $Error = 0;
 
433
 
 
434
        /**
 
435
         *  Error message of the file entry
 
436
         *
 
437
         *  @var    string
 
438
         *  @access public
 
439
         *  @see    SimpleUnzipEntry()
 
440
         *  @since  1.0
 
441
         */
 
442
        var $ErrorMsg = '';
 
443
 
 
444
        /**
 
445
         *  File name of the file entry
 
446
         *
 
447
         *  @var    string
 
448
         *  @access public
 
449
         *  @see    SimpleUnzipEntry()
 
450
         *  @since  1.0
 
451
         */
 
452
        var $Name = '';
 
453
 
 
454
        /**
 
455
         *  File path of the file entry
 
456
         *
 
457
         *  @var    string
 
458
         *  @access public
 
459
         *  @see    SimpleUnzipEntry()
 
460
         *  @since  1.0
 
461
         */
 
462
        var $Path = '';
 
463
 
 
464
        /**
 
465
         *  File time of the file entry (unix timestamp)
 
466
         *
 
467
         *  @var    integer
 
468
         *  @access public
 
469
         *  @see    SimpleUnzipEntry()
 
470
         *  @since  1.0
 
471
         */
 
472
        var $Time = 0;
 
473
 
 
474
        /**
 
475
         *  Contructor of the class
 
476
         *
 
477
         *  @param  array               Entry datas
 
478
         *  @return SimpleUnzipEntry    Instanced class
 
479
         *  @access public
 
480
         *  @since  1.0
 
481
         */
 
482
        function SimpleUnzipEntry($in_Entry)
 
483
        {
 
484
            $this->Data     = $in_Entry['D'];
 
485
            $this->Error    = $in_Entry['E'];
 
486
            $this->ErrorMsg = $in_Entry['EM'];
 
487
            $this->Name     = $in_Entry['N'];
 
488
            $this->Path     = $in_Entry['P'];
 
489
            $this->Time     = $in_Entry['T'];
 
490
        } // end of the 'SimpleUnzipEntry' constructor
 
491
    } // end of the 'SimpleUnzipEntry' class
 
492
?>