home *** CD-ROM | disk | FTP | other *** search
/ Enter 2004 June / ENTER.ISO / files / xampp-win32-1.4.5-installer.exe / xampp / SHM.php < prev    next >
Encoding:
PHP Script  |  2004-03-24  |  6.8 KB  |  227 lines
  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4: */
  3. // +----------------------------------------------------------------------+
  4. // | PHP Version 4                                                        |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2003 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. // | Authors: David Sklar <sklar@sklar.com>                               |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: SHM.php,v 1.2 2003/01/15 22:00:36 sklar Exp $
  20. //
  21.  
  22. /**
  23.  * This class implements a user-space stream that reads/writes shared
  24.  * memory. It requires the shmop extension for shared memory access.
  25.  *
  26.  * Sample Usage:
  27.  *
  28.  * require_once('Stream/SHM.php');
  29.  * stream_register_wrapper('shm','Stream_SHM') or die("can't register shm");
  30.  * $shm = fopen('shm://0xabcd:12000','c');
  31.  * fwrite($shm, 'One Two Three Four');
  32.  * fseek($shm,4,SEEK_SET);
  33.  * $two = fread($shm,3); // $two is "Two"
  34.  * fclose($shm);
  35.  *
  36.  * Specify the key of the shared memory segment in decimal or hexadecimal
  37.  * after the "shm://" and then optionally, a colon and the size of the
  38.  * shared memory segment. If you don't specify a size, the segment size
  39.  * defaults to 16384 bytes.
  40.  *
  41.  * Allowable modes are "a", "c", "w", and "n". For what those modes 
  42.  * mean, see:
  43.  * --> http://www.php.net/manual/en/function.shmop-open.php
  44.  *
  45.  *
  46.  * @author David Sklar <sklar@sklar.com>
  47.  * @version 1.0
  48.  * @package Stream::SHM
  49.  */
  50. class Stream_SHM {
  51.  
  52.     /**
  53.      * position
  54.      * 
  55.      * @var  string stream position in the shared memory segment
  56.      */
  57.     var $pos = 0;
  58.  
  59.     /**
  60.      * shared memory segment key
  61.      *
  62.      * @var  integer key (for shmop_open()) of the segment
  63.      */
  64.     var $shm_key;
  65.  
  66.     /**
  67.      * shared memory segment size
  68.      *
  69.      * @var  integer size of the shared memory segment (default: 16k)
  70.      */
  71.     var $size = 16384;
  72.  
  73.     /**
  74.      * shared memory segment handle
  75.      * @var resource handle to the segment for the shmop_*() functions
  76.      */
  77.     var $shm;
  78.  
  79.     /**
  80.      * Stream opener
  81.      *
  82.      * @param string  $path         URL-style path to the segment
  83.      * @param string  $mode         mode to open the segment with
  84.      * @param integer $options      stream options
  85.      * @param string  &$opened_path (not used)
  86.      * @return boolean              Stream opened sucessfully?
  87.      */
  88.     function stream_open($path, $mode, $options, &$opened_path)
  89.     {
  90.         $url = parse_url($path);
  91.         $this->shm_key = $url['host'];
  92.         if ((! intval($this->shm_key)) && (! preg_match('/^0x[0-9a-f]+$/i',
  93.                                                         $this->shm_key))) {
  94.             if ($options & STREAM_REPORT_ERRORS) {
  95.                 trigger_error("Stream_SHM::stream_open: $this->shm_key is not a valid shm key.",E_USER_ERROR);
  96.             }
  97.             return false;
  98.         }
  99.         if (intval($url['port'])) {
  100.             $this->size = intval($url['port']);
  101.         }
  102.         if (($mode != 'a') && ($mode != 'c') && 
  103.             ($mode != 'w') && ($mode != 'n')) {
  104.             if ($options & STREAM_REPORT_ERRORS) {
  105.                 trigger_error("Stream_SHM::stream_open: $mode is not a valid mode (must be one of: a c n w)",E_USER_ERROR);
  106.             }
  107.             return false;
  108.         }
  109.         if (! ($this->shm = shmop_open($this->shm_key,$mode,0600,$this->size))) {
  110.             if ($options & STREAM_REPORT_ERRORS) {
  111.                 trigger_error('Stream_SHM::stream_open: shmop_open() failed');
  112.             }
  113.             return false;
  114.         }
  115.         $this->size = shmop_size($this->shm);
  116.         return true;
  117.     }
  118.     /**
  119.      * Stream closer
  120.      *
  121.      */
  122.     function stream_close()
  123.     {
  124.         shmop_close($this->shm);
  125.     }
  126.  
  127.  
  128.     /**
  129.      * Read from stream
  130.      *
  131.      * @param integer $count How many bytes to read from the stream
  132.      * @return string        Data read from the stream
  133.      */
  134.     function stream_read($count)
  135.     {
  136.         // Don't read past the end of the stream
  137.         if ($count + $this->pos > $this->size) {
  138.             $count = $this->size - $this->pos;
  139.         }
  140.         $data = shmop_read($this->shm,$this->pos,$count);
  141.         $this->pos += strlen($data);
  142.         return $data;
  143.     }
  144.  
  145.     /**
  146.      * Write to stream
  147.      *
  148.      * @param  mixed   $data Data to write to the stream
  149.      * @return integer       Bytes actually written to the stream
  150.      */
  151.     function stream_write($data)
  152.     {
  153.         $count = shmop_write($this->shm,$data,$this->pos);
  154.         $this->pos += $count;
  155.         return $count;
  156.     }
  157.  
  158.     /**
  159.      * Check stream end-of-file
  160.      *
  161.      * @return boolean Is the stream position at the end of the stream?
  162.      */
  163.     function stream_eof()
  164.     {
  165.         return ($this->pos == ($this->size - 1));
  166.     }
  167.  
  168.     /**
  169.      * Get stream position
  170.      *
  171.      * @return integer The current position in the stream
  172.      */
  173.     function stream_tell()
  174.     {
  175.         return $this->pos;
  176.     }
  177.     /**
  178.      * Adjust current position in the stream
  179.      *
  180.      * @param  integer $offset How many bytes to move the position
  181.      * @param  integer $whence Where to start counting from
  182.      * @return boolean         Was the position adjustment successful?
  183.      */
  184.     function stream_seek($offset,$whence)
  185.     {
  186.         switch ($whence) {
  187.         case SEEK_SET:
  188.             if (($offset >= 0) && ($offset < $this->size)) {
  189.                 $this->pos = $offset;
  190.                 return true;
  191.             } else {
  192.                 return false;
  193.             }
  194.             break;
  195.         case SEEK_CUR:
  196.             if (($offset >= 0) && (($this->pos + $offset) < $this->size)) {
  197.                 $this->pos += $offset;
  198.                 return true;
  199.             } else {
  200.                 return false;
  201.             }
  202.             break;
  203.         case SEEK_END:
  204.             if (($this->size + $offset) >= 0) {
  205.                 $this->pos = $this->size + $offset;
  206.                 return true;
  207.             } else {
  208.                 return false;
  209.             }
  210.             break;
  211.         default:
  212.             return false;
  213.         }
  214.     }
  215.  
  216.     /**
  217.      * Flush data to the stream
  218.      *
  219.      * @return boolean Data is always flushed when writing with shmop_write()
  220.      */
  221.     function stream_flush()
  222.     {
  223.         return true;
  224.     }
  225. }
  226. ?>
  227.