1: <?php
  2: /* vim: set expandtab tabstop=4 shiftwidth=4: */
  3: // +----------------------------------------------------------------------+
  4: // | PHP Version 4                                                        |
  5: // +----------------------------------------------------------------------+
  6: // | Copyright (c) 1997-2002 The PHP Group                                |
  7: // +----------------------------------------------------------------------+
  8: // | This source file is subject to version 2.02 of the PHP license,      |
  9: // | that is bundled with this package in the file LICENSE, and is        |
 10: // | available at through the world-wide-web at                           |
 11: // | http://www.php.net/license/2_02.txt.                                 |
 12: // | If you did not receive a copy of the PHP license and are unable to   |
 13: // | obtain it through the world-wide-web, please send a note to          |
 14: // | license@php.net so we can mail you a copy immediately.               |
 15: // +----------------------------------------------------------------------+
 16: // | Author: Xavier Noguer <xnoguer@php.net>                              |
 17: // | Based on OLE::Storage_Lite by Kawai, Takanori                        |
 18: // +----------------------------------------------------------------------+
 19: //
 20: // $Id: Root.php,v 1.9 2005/04/23 21:53:49 dufuz Exp $
 21: 
 22: 
 23: /**
 24: * Class for creating Root PPS's for OLE containers
 25: *
 26: * @author   Xavier Noguer <xnoguer@php.net>
 27: * @category PHPExcel
 28: * @package  PHPExcel_Shared_OLE
 29: */
 30: class PHPExcel_Shared_OLE_PPS_Root extends PHPExcel_Shared_OLE_PPS
 31:     {
 32: 
 33:     /**
 34:      * Directory for temporary files
 35:      * @var string
 36:      */
 37:     protected $_tmp_dir     = NULL;
 38: 
 39:     /**
 40:      * @param integer $time_1st A timestamp
 41:      * @param integer $time_2nd A timestamp
 42:      */
 43:     public function __construct($time_1st, $time_2nd, $raChild)
 44:     {
 45:         $this->_tempDir = PHPExcel_Shared_File::sys_get_temp_dir();
 46: 
 47:         parent::__construct(
 48:            null,
 49:            PHPExcel_Shared_OLE::Asc2Ucs('Root Entry'),
 50:            PHPExcel_Shared_OLE::OLE_PPS_TYPE_ROOT,
 51:            null,
 52:            null,
 53:            null,
 54:            $time_1st,
 55:            $time_2nd,
 56:            null,
 57:            $raChild);
 58:     }
 59: 
 60:     /**
 61:     * Method for saving the whole OLE container (including files).
 62:     * In fact, if called with an empty argument (or '-'), it saves to a
 63:     * temporary file and then outputs it's contents to stdout.
 64:     * If a resource pointer to a stream created by fopen() is passed
 65:     * it will be used, but you have to close such stream by yourself.
 66:     *
 67:     * @param string|resource $filename The name of the file or stream where to save the OLE container.
 68:     * @access public
 69:     * @return mixed true on success
 70:     */
 71:     public function save($filename)
 72:     {
 73:         // Initial Setting for saving
 74:         $this->_BIG_BLOCK_SIZE  = pow(2,
 75:                       ((isset($this->_BIG_BLOCK_SIZE))? self::_adjust2($this->_BIG_BLOCK_SIZE)  : 9));
 76:         $this->_SMALL_BLOCK_SIZE= pow(2,
 77:                       ((isset($this->_SMALL_BLOCK_SIZE))?  self::_adjust2($this->_SMALL_BLOCK_SIZE): 6));
 78: 
 79:         if (is_resource($filename)) {
 80:             $this->_FILEH_ = $filename;
 81:         } else if ($filename == '-' || $filename == '') {
 82:             if ($this->_tmp_dir === NULL)
 83:                 $this->_tmp_dir = PHPExcel_Shared_File::sys_get_temp_dir();
 84:             $this->_tmp_filename = tempnam($this->_tmp_dir, "OLE_PPS_Root");
 85:             $this->_FILEH_ = fopen($this->_tmp_filename,"w+b");
 86:             if ($this->_FILEH_ == false) {
 87:                 throw new PHPExcel_Writer_Exception("Can't create temporary file.");
 88:             }
 89:         } else {
 90:             $this->_FILEH_ = fopen($filename, "wb");
 91:         }
 92:         if ($this->_FILEH_ == false) {
 93:             throw new PHPExcel_Writer_Exception("Can't open $filename. It may be in use or protected.");
 94:         }
 95:         // Make an array of PPS's (for Save)
 96:         $aList = array();
 97:         PHPExcel_Shared_OLE_PPS::_savePpsSetPnt($aList, array($this));
 98:         // calculate values for header
 99:         list($iSBDcnt, $iBBcnt, $iPPScnt) = $this->_calcSize($aList); //, $rhInfo);
100:         // Save Header
101:         $this->_saveHeader($iSBDcnt, $iBBcnt, $iPPScnt);
102: 
103:         // Make Small Data string (write SBD)
104:         $this->_data = $this->_makeSmallData($aList);
105: 
106:         // Write BB
107:         $this->_saveBigData($iSBDcnt, $aList);
108:         // Write PPS
109:         $this->_savePps($aList);
110:         // Write Big Block Depot and BDList and Adding Header informations
111:         $this->_saveBbd($iSBDcnt, $iBBcnt, $iPPScnt);
112: 
113:         if (!is_resource($filename)) {
114:             fclose($this->_FILEH_);
115:         }
116: 
117:         return true;
118:     }
119: 
120:     /**
121:     * Calculate some numbers
122:     *
123:     * @access public
124:     * @param array $raList Reference to an array of PPS's
125:     * @return array The array of numbers
126:     */
127:     public function _calcSize(&$raList)
128:     {
129:         // Calculate Basic Setting
130:         list($iSBDcnt, $iBBcnt, $iPPScnt) = array(0,0,0);
131:         $iSmallLen = 0;
132:         $iSBcnt = 0;
133:         $iCount = count($raList);
134:         for ($i = 0; $i < $iCount; ++$i) {
135:             if ($raList[$i]->Type == PHPExcel_Shared_OLE::OLE_PPS_TYPE_FILE) {
136:                 $raList[$i]->Size = $raList[$i]->_DataLen();
137:                 if ($raList[$i]->Size < PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL) {
138:                     $iSBcnt += floor($raList[$i]->Size / $this->_SMALL_BLOCK_SIZE)
139:                                   + (($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE)? 1: 0);
140:                 } else {
141:                     $iBBcnt += (floor($raList[$i]->Size / $this->_BIG_BLOCK_SIZE) +
142:                         (($raList[$i]->Size % $this->_BIG_BLOCK_SIZE)? 1: 0));
143:                 }
144:             }
145:         }
146:         $iSmallLen = $iSBcnt * $this->_SMALL_BLOCK_SIZE;
147:         $iSlCnt = floor($this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE);
148:         $iSBDcnt = floor($iSBcnt / $iSlCnt) + (($iSBcnt % $iSlCnt)? 1:0);
149:         $iBBcnt +=  (floor($iSmallLen / $this->_BIG_BLOCK_SIZE) +
150:                       (( $iSmallLen % $this->_BIG_BLOCK_SIZE)? 1: 0));
151:         $iCnt = count($raList);
152:         $iBdCnt = $this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_PPS_SIZE;
153:         $iPPScnt = (floor($iCnt/$iBdCnt) + (($iCnt % $iBdCnt)? 1: 0));
154: 
155:         return array($iSBDcnt, $iBBcnt, $iPPScnt);
156:     }
157: 
158:     /**
159:     * Helper function for caculating a magic value for block sizes
160:     *
161:     * @access public
162:     * @param integer $i2 The argument
163:     * @see save()
164:     * @return integer
165:     */
166:     private static function _adjust2($i2)
167:     {
168:         $iWk = log($i2)/log(2);
169:         return ($iWk > floor($iWk))? floor($iWk)+1:$iWk;
170:     }
171: 
172:     /**
173:     * Save OLE header
174:     *
175:     * @access public
176:     * @param integer $iSBDcnt
177:     * @param integer $iBBcnt
178:     * @param integer $iPPScnt
179:     */
180:     public function _saveHeader($iSBDcnt, $iBBcnt, $iPPScnt)
181:     {
182:         $FILE = $this->_FILEH_;
183: 
184:         // Calculate Basic Setting
185:         $iBlCnt = $this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE;
186:         $i1stBdL = ($this->_BIG_BLOCK_SIZE - 0x4C) / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE;
187: 
188:         $iBdExL = 0;
189:         $iAll = $iBBcnt + $iPPScnt + $iSBDcnt;
190:         $iAllW = $iAll;
191:         $iBdCntW = floor($iAllW / $iBlCnt) + (($iAllW % $iBlCnt)? 1: 0);
192:         $iBdCnt = floor(($iAll + $iBdCntW) / $iBlCnt) + ((($iAllW+$iBdCntW) % $iBlCnt)? 1: 0);
193: 
194:         // Calculate BD count
195:         if ($iBdCnt > $i1stBdL) {
196:             while (1) {
197:                 ++$iBdExL;
198:                 ++$iAllW;
199:                 $iBdCntW = floor($iAllW / $iBlCnt) + (($iAllW % $iBlCnt)? 1: 0);
200:                 $iBdCnt = floor(($iAllW + $iBdCntW) / $iBlCnt) + ((($iAllW+$iBdCntW) % $iBlCnt)? 1: 0);
201:                 if ($iBdCnt <= ($iBdExL*$iBlCnt+ $i1stBdL)) {
202:                     break;
203:                 }
204:             }
205:         }
206: 
207:         // Save Header
208:         fwrite($FILE,
209:                 "\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1"
210:                 . "\x00\x00\x00\x00"
211:                 . "\x00\x00\x00\x00"
212:                 . "\x00\x00\x00\x00"
213:                 . "\x00\x00\x00\x00"
214:                 . pack("v", 0x3b)
215:                 . pack("v", 0x03)
216:                 . pack("v", -2)
217:                 . pack("v", 9)
218:                 . pack("v", 6)
219:                 . pack("v", 0)
220:                 . "\x00\x00\x00\x00"
221:                 . "\x00\x00\x00\x00"
222:                 . pack("V", $iBdCnt)
223:                 . pack("V", $iBBcnt+$iSBDcnt) //ROOT START
224:                 . pack("V", 0)
225:                 . pack("V", 0x1000)
226:                 . pack("V", $iSBDcnt ? 0 : -2)                  //Small Block Depot
227:                 . pack("V", $iSBDcnt)
228:           );
229:         // Extra BDList Start, Count
230:         if ($iBdCnt < $i1stBdL) {
231:             fwrite($FILE,
232:                     pack("V", -2)      // Extra BDList Start
233:                     . pack("V", 0)        // Extra BDList Count
234:                   );
235:         } else {
236:             fwrite($FILE, pack("V", $iAll+$iBdCnt) . pack("V", $iBdExL));
237:         }
238: 
239:         // BDList
240:         for ($i = 0; $i < $i1stBdL && $i < $iBdCnt; ++$i) {
241:             fwrite($FILE, pack("V", $iAll+$i));
242:         }
243:         if ($i < $i1stBdL) {
244:             $jB = $i1stBdL - $i;
245:             for ($j = 0; $j < $jB; ++$j) {
246:                 fwrite($FILE, (pack("V", -1)));
247:             }
248:         }
249:     }
250: 
251:     /**
252:     * Saving big data (PPS's with data bigger than PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL)
253:     *
254:     * @access public
255:     * @param integer $iStBlk
256:     * @param array &$raList Reference to array of PPS's
257:     */
258:     public function _saveBigData($iStBlk, &$raList)
259:     {
260:         $FILE = $this->_FILEH_;
261: 
262:         // cycle through PPS's
263:         $iCount = count($raList);
264:         for ($i = 0; $i < $iCount; ++$i) {
265:             if ($raList[$i]->Type != PHPExcel_Shared_OLE::OLE_PPS_TYPE_DIR) {
266:                 $raList[$i]->Size = $raList[$i]->_DataLen();
267:                 if (($raList[$i]->Size >= PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL) ||
268:                     (($raList[$i]->Type == PHPExcel_Shared_OLE::OLE_PPS_TYPE_ROOT) && isset($raList[$i]->_data)))
269:                 {
270:                     // Write Data
271:                     //if (isset($raList[$i]->_PPS_FILE)) {
272:                     //  $iLen = 0;
273:                     //  fseek($raList[$i]->_PPS_FILE, 0); // To The Top
274:                     //  while($sBuff = fread($raList[$i]->_PPS_FILE, 4096)) {
275:                     //      $iLen += strlen($sBuff);
276:                     //      fwrite($FILE, $sBuff);
277:                     //  }
278:                     //} else {
279:                         fwrite($FILE, $raList[$i]->_data);
280:                     //}
281: 
282:                     if ($raList[$i]->Size % $this->_BIG_BLOCK_SIZE) {
283:                         fwrite($FILE, str_repeat("\x00", $this->_BIG_BLOCK_SIZE - ($raList[$i]->Size % $this->_BIG_BLOCK_SIZE)));
284:                     }
285:                     // Set For PPS
286:                     $raList[$i]->_StartBlock = $iStBlk;
287:                     $iStBlk +=
288:                             (floor($raList[$i]->Size / $this->_BIG_BLOCK_SIZE) +
289:                                 (($raList[$i]->Size % $this->_BIG_BLOCK_SIZE)? 1: 0));
290:                 }
291:                 // Close file for each PPS, and unlink it
292:                 //if (isset($raList[$i]->_PPS_FILE)) {
293:                 //  fclose($raList[$i]->_PPS_FILE);
294:                 //  $raList[$i]->_PPS_FILE = null;
295:                 //  unlink($raList[$i]->_tmp_filename);
296:                 //}
297:             }
298:         }
299:     }
300: 
301:     /**
302:     * get small data (PPS's with data smaller than PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL)
303:     *
304:     * @access public
305:     * @param array &$raList Reference to array of PPS's
306:     */
307:     public function _makeSmallData(&$raList)
308:     {
309:         $sRes = '';
310:         $FILE = $this->_FILEH_;
311:         $iSmBlk = 0;
312: 
313:         $iCount = count($raList);
314:         for ($i = 0; $i < $iCount; ++$i) {
315:             // Make SBD, small data string
316:             if ($raList[$i]->Type == PHPExcel_Shared_OLE::OLE_PPS_TYPE_FILE) {
317:                 if ($raList[$i]->Size <= 0) {
318:                     continue;
319:                 }
320:                 if ($raList[$i]->Size < PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL) {
321:                     $iSmbCnt = floor($raList[$i]->Size / $this->_SMALL_BLOCK_SIZE)
322:                                   + (($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE)? 1: 0);
323:                     // Add to SBD
324:                     $jB = $iSmbCnt - 1;
325:                     for ($j = 0; $j < $jB; ++$j) {
326:                         fwrite($FILE, pack("V", $j+$iSmBlk+1));
327:                     }
328:                     fwrite($FILE, pack("V", -2));
329: 
330:                     //// Add to Data String(this will be written for RootEntry)
331:                     //if ($raList[$i]->_PPS_FILE) {
332:                     //  fseek($raList[$i]->_PPS_FILE, 0); // To The Top
333:                     //  while ($sBuff = fread($raList[$i]->_PPS_FILE, 4096)) {
334:                     //      $sRes .= $sBuff;
335:                     //  }
336:                     //} else {
337:                         $sRes .= $raList[$i]->_data;
338:                     //}
339:                     if ($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE) {
340:                         $sRes .= str_repeat("\x00",$this->_SMALL_BLOCK_SIZE - ($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE));
341:                     }
342:                     // Set for PPS
343:                     $raList[$i]->_StartBlock = $iSmBlk;
344:                     $iSmBlk += $iSmbCnt;
345:                 }
346:             }
347:         }
348:         $iSbCnt = floor($this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE);
349:         if ($iSmBlk % $iSbCnt) {
350:             $iB = $iSbCnt - ($iSmBlk % $iSbCnt);
351:             for ($i = 0; $i < $iB; ++$i) {
352:                 fwrite($FILE, pack("V", -1));
353:             }
354:         }
355:         return $sRes;
356:     }
357: 
358:     /**
359:     * Saves all the PPS's WKs
360:     *
361:     * @access public
362:     * @param array $raList Reference to an array with all PPS's
363:     */
364:     public function _savePps(&$raList)
365:     {
366:         // Save each PPS WK
367:         $iC = count($raList);
368:         for ($i = 0; $i < $iC; ++$i) {
369:             fwrite($this->_FILEH_, $raList[$i]->_getPpsWk());
370:         }
371:         // Adjust for Block
372:         $iCnt = count($raList);
373:         $iBCnt = $this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_PPS_SIZE;
374:         if ($iCnt % $iBCnt) {
375:             fwrite($this->_FILEH_, str_repeat("\x00",($iBCnt - ($iCnt % $iBCnt)) * PHPExcel_Shared_OLE::OLE_PPS_SIZE));
376:         }
377:     }
378: 
379:     /**
380:     * Saving Big Block Depot
381:     *
382:     * @access public
383:     * @param integer $iSbdSize
384:     * @param integer $iBsize
385:     * @param integer $iPpsCnt
386:     */
387:     public function _saveBbd($iSbdSize, $iBsize, $iPpsCnt)
388:     {
389:         $FILE = $this->_FILEH_;
390:         // Calculate Basic Setting
391:         $iBbCnt = $this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE;
392:         $i1stBdL = ($this->_BIG_BLOCK_SIZE - 0x4C) / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE;
393: 
394:         $iBdExL = 0;
395:         $iAll = $iBsize + $iPpsCnt + $iSbdSize;
396:         $iAllW = $iAll;
397:         $iBdCntW = floor($iAllW / $iBbCnt) + (($iAllW % $iBbCnt)? 1: 0);
398:         $iBdCnt = floor(($iAll + $iBdCntW) / $iBbCnt) + ((($iAllW+$iBdCntW) % $iBbCnt)? 1: 0);
399:         // Calculate BD count
400:         if ($iBdCnt >$i1stBdL) {
401:             while (1) {
402:                 ++$iBdExL;
403:                 ++$iAllW;
404:                 $iBdCntW = floor($iAllW / $iBbCnt) + (($iAllW % $iBbCnt)? 1: 0);
405:                 $iBdCnt = floor(($iAllW + $iBdCntW) / $iBbCnt) + ((($iAllW+$iBdCntW) % $iBbCnt)? 1: 0);
406:                 if ($iBdCnt <= ($iBdExL*$iBbCnt+ $i1stBdL)) {
407:                     break;
408:                 }
409:             }
410:         }
411: 
412:         // Making BD
413:         // Set for SBD
414:         if ($iSbdSize > 0) {
415:             for ($i = 0; $i < ($iSbdSize - 1); ++$i) {
416:                 fwrite($FILE, pack("V", $i+1));
417:             }
418:             fwrite($FILE, pack("V", -2));
419:         }
420:         // Set for B
421:         for ($i = 0; $i < ($iBsize - 1); ++$i) {
422:             fwrite($FILE, pack("V", $i+$iSbdSize+1));
423:         }
424:         fwrite($FILE, pack("V", -2));
425: 
426:         // Set for PPS
427:         for ($i = 0; $i < ($iPpsCnt - 1); ++$i) {
428:             fwrite($FILE, pack("V", $i+$iSbdSize+$iBsize+1));
429:         }
430:         fwrite($FILE, pack("V", -2));
431:         // Set for BBD itself ( 0xFFFFFFFD : BBD)
432:         for ($i = 0; $i < $iBdCnt; ++$i) {
433:             fwrite($FILE, pack("V", 0xFFFFFFFD));
434:         }
435:         // Set for ExtraBDList
436:         for ($i = 0; $i < $iBdExL; ++$i) {
437:             fwrite($FILE, pack("V", 0xFFFFFFFC));
438:         }
439:         // Adjust for Block
440:         if (($iAllW + $iBdCnt) % $iBbCnt) {
441:             $iBlock = ($iBbCnt - (($iAllW + $iBdCnt) % $iBbCnt));
442:             for ($i = 0; $i < $iBlock; ++$i) {
443:                 fwrite($FILE, pack("V", -1));
444:             }
445:         }
446:         // Extra BDList
447:         if ($iBdCnt > $i1stBdL) {
448:             $iN=0;
449:             $iNb=0;
450:             for ($i = $i1stBdL;$i < $iBdCnt; $i++, ++$iN) {
451:                 if ($iN >= ($iBbCnt - 1)) {
452:                     $iN = 0;
453:                     ++$iNb;
454:                     fwrite($FILE, pack("V", $iAll+$iBdCnt+$iNb));
455:                 }
456:                 fwrite($FILE, pack("V", $iBsize+$iSbdSize+$iPpsCnt+$i));
457:             }
458:             if (($iBdCnt-$i1stBdL) % ($iBbCnt-1)) {
459:                 $iB = ($iBbCnt - 1) - (($iBdCnt - $i1stBdL) % ($iBbCnt - 1));
460:                 for ($i = 0; $i < $iB; ++$i) {
461:                     fwrite($FILE, pack("V", -1));
462:                 }
463:             }
464:             fwrite($FILE, pack("V", -2));
465:         }
466:     }
467: }
468: