home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / File / Passwd / Common.php < prev    next >
Encoding:
PHP Script  |  2004-10-01  |  9.8 KB  |  380 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PEAR :: File :: Passwd :: Common                                     |
  4. // +----------------------------------------------------------------------+
  5. // | This source file is subject to version 3.0 of the PHP license,       |
  6. // | that is available at http://www.php.net/license/3_0.txt              |
  7. // | If you did not receive a copy of the PHP license and are unable      |
  8. // | to obtain it through the world-wide-web, please send a note to       |
  9. // | license@php.net so we can mail you a copy immediately.               |
  10. // +----------------------------------------------------------------------+
  11. // | Copyright (c) 2003-2004 Michael Wallner <mike@iworks.at>             |
  12. // +----------------------------------------------------------------------+
  13. //
  14. // $Id: Common.php,v 1.12 2004/06/07 19:19:47 mike Exp $
  15.  
  16. /**
  17. * Baseclass for File_Passwd_* classes.
  18. * 
  19. * @author   Michael Wallner <mike@php.net>
  20. * @package  File_Passwd
  21. */
  22.  
  23. /**
  24. * Requires System
  25. */
  26. require_once 'System.php';
  27. /**
  28. * Requires File::Passwd
  29. */
  30. require_once 'File/Passwd.php';
  31.  
  32. /**
  33. * Baseclass for File_Passwd_* classes.
  34. * 
  35. * <kbd><u>
  36. *   Provides basic operations:
  37. * </u></kbd>
  38. *   o opening & closing
  39. *   o locking & unlocking
  40. *   o loading & saving
  41. *   o check if user exist
  42. *   o delete a certain user
  43. *   o list users
  44. * 
  45. * @author   Michael Wallner <mike@php.net>
  46. * @package  File_Passwd
  47. * @version  $Revision: 1.12 $
  48. * @access   protected
  49. * @internal extend this class for your File_Passwd_* class
  50. */
  51. class File_Passwd_Common
  52. {
  53.     /**
  54.     * passwd file
  55.     *
  56.     * @var string
  57.     * @access protected
  58.     */
  59.     var $_file = 'passwd';
  60.     
  61.     /**
  62.     * file content
  63.     *
  64.     * @var aray
  65.     * @access protected
  66.     */
  67.     var $_contents = array();
  68.     
  69.     /**
  70.     * users
  71.     *
  72.     * @var array
  73.     * @access protected
  74.     */
  75.     var $_users = array();
  76.     
  77.     /**
  78.     * PCRE for valid chars
  79.     * 
  80.     * @var  string
  81.     * @access   protected
  82.     */
  83.     var $_pcre = '/^[a-z]+[a-z0-9_-]*$/i';
  84.     
  85.     /**
  86.     * Constructor (ZE2)
  87.     *
  88.     * @access protected
  89.     * @param  string    $file   path to passwd file
  90.     */
  91.     function __construct($file = 'passwd')
  92.     {
  93.         $this->setFile($file);
  94.     }
  95.     
  96.     /**
  97.     * Parse the content of the file
  98.     *
  99.     * You must overwrite this method in your File_Passwd_* class.
  100.     * 
  101.     * @abstract
  102.     * @internal
  103.     * @access public
  104.     * @return object    PEAR_Error
  105.     */
  106.     function parse()
  107.     {
  108.         return PEAR::raiseError(
  109.             sprintf(FILE_PASSWD_E_METHOD_NOT_IMPLEMENTED_STR, 'parse'),
  110.             FILE_PASSWD_E_METHOD_NOT_IMPLEMENTED
  111.         );
  112.     }
  113.     
  114.     /**
  115.     * Apply changes and rewrite passwd file
  116.     *
  117.     * You must overwrite this method in your File_Passwd_* class.
  118.     * 
  119.     * @abstract
  120.     * @internal
  121.     * @access public
  122.     * @return object    PEAR_Error
  123.     */
  124.     function save()
  125.     {
  126.         return PEAR::raiseError(
  127.             sprintf(FILE_PASSWD_E_METHOD_NOT_IMPLEMENTED_STR, 'save'),
  128.             FILE_PASSWD_E_METHOD_NOT_IMPLEMENTED
  129.         );
  130.     }
  131.     
  132.     /**
  133.     * Opens a file, locks it exclusively and returns the filehandle
  134.     *
  135.     * Returns a PEAR_Error if:
  136.     *   o directory in which the file should reside couldn't be created
  137.     *   o file couldn't be opened in the desired mode
  138.     *   o file couldn't be locked exclusively
  139.     * 
  140.     * @throws PEAR_Error
  141.     * @access protected
  142.     * @return mixed resource of type file handle or PEAR_Error
  143.     * @param  string    $mode   the mode to open the file with
  144.     */
  145.     function &_open($mode, $file = null)
  146.     {
  147.         $file   = realpath( is_null($file) ? $this->_file : $file );
  148.         $dir    = dirname($file);
  149.         $lock   = strstr($mode, 'r') ? LOCK_SH : LOCK_EX;
  150.         if (!is_dir($dir) && !System::mkDir('-p -m 0755 ' . $dir)) {
  151.             return PEAR::raiseError(
  152.                 sprintf(FILE_PASSWD_E_DIR_NOT_CREATED_STR, $dir),
  153.                 FILE_PASSWD_E_DIR_NOT_CREATED
  154.             );
  155.         }
  156.         if (!is_resource($fh = @fopen($file, $mode))) {
  157.             return PEAR::raiseError(
  158.                 sprintf(FILE_PASSWD_E_FILE_NOT_OPENED_STR, $file),
  159.                 FILE_PASSWD_E_FILE_NOT_OPENED
  160.             );
  161.         }
  162.         if (!@flock($fh, $lock)) {
  163.             fclose($fh);
  164.             return PEAR::raiseError(
  165.                 sprintf(FILE_PASSWD_E_FILE_NOT_LOCKED_STR, $file),
  166.                 FILE_PASSWD_E_FILE_NOT_LOCKED
  167.             );
  168.         }
  169.         return $fh;
  170.     }
  171.     
  172.     /**
  173.     * Closes a prior opened and locked file handle
  174.     *
  175.     * Returns a PEAR_Error if:
  176.     *   o file couldn't be unlocked
  177.     *   o file couldn't be closed
  178.     * 
  179.     * @throws PEAR_Error
  180.     * @access protected
  181.     * @return mixed true on success or PEAR_Error
  182.     * @param  resource  $file_handle    the file handle to operate on
  183.     */
  184.     function _close(&$file_handle)
  185.     {
  186.         if (!@flock($file_handle, LOCK_UN)) {
  187.             return PEAR::raiseError(
  188.                 FILE_PASSWD_E_FILE_NOT_UNLOCKED_STR,
  189.                 FILE_PASSWD_E_FILE_NOT_UNLOCKED
  190.             );
  191.         }
  192.         if (!@fclose($file_handle)) {
  193.             return PEAR::raiseError(
  194.                 FILE_PASSWD_E_FILE_NOT_CLOSED_STR,
  195.                 FILE_PASSWD_E_FILE_NOT_CLOSED
  196.             );
  197.         }
  198.         return true;
  199.     }
  200.     
  201.     /**
  202.     * Loads the file
  203.     *
  204.     * Returns a PEAR_Error if:
  205.     *   o directory in which the file should reside couldn't be created
  206.     *   o file couldn't be opened in read mode
  207.     *   o file couldn't be locked exclusively
  208.     *   o file couldn't be unlocked
  209.     *   o file couldn't be closed
  210.     * 
  211.     * @throws PEAR_Error
  212.     * @access public
  213.     * @return mixed true on success or PEAR_Error
  214.     */
  215.     function load()
  216.     {
  217.         $fh = &$this->_open('r');
  218.         if (PEAR::isError($fh)) {
  219.             return $fh;
  220.         }
  221.         $this->_contents = array();
  222.         while ($line = fgets($fh)) {
  223.             $line = trim(preg_replace('/^(\S*.*)#.*$/', '\\1', $line));
  224.             if (empty($line)) {
  225.                 continue;
  226.             }
  227.             $this->_contents[] = $line;
  228.         }
  229.         $e = $this->_close($fh);
  230.         if (PEAR::isError($e)) {
  231.             return $e;
  232.         }
  233.         return $this->parse();
  234.     }
  235.     
  236.     /**
  237.     * Save the modified content to the passwd file
  238.     *
  239.     * Returns a PEAR_Error if:
  240.     *   o directory in which the file should reside couldn't be created
  241.     *   o file couldn't be opened in write mode
  242.     *   o file couldn't be locked exclusively
  243.     *   o file couldn't be unlocked
  244.     *   o file couldn't be closed
  245.     * 
  246.     * @throws PEAR_Error
  247.     * @access protected
  248.     * @return mixed true on success or PEAR_Error
  249.     */
  250.     function _save($content)
  251.     {
  252.         $fh = &$this->_open('w');
  253.         if (PEAR::isError($fh)) {
  254.             return $fh;
  255.         }
  256.         fputs($fh, $content);
  257.         return $this->_close($fh);
  258.     }
  259.     
  260.     /**
  261.     * Set path to passwd file
  262.     *
  263.     * @access public
  264.     * @return void
  265.     */
  266.     function setFile($file)
  267.     {
  268.         $this->_file = $file;
  269.     }
  270.     
  271.     /**
  272.     * Get path of passwd file
  273.     *
  274.     * @access public
  275.     * @return string
  276.     */
  277.     function getFile()
  278.     {
  279.         return $this->_file;
  280.     }
  281.  
  282.     /**
  283.     * Check if a certain user already exists
  284.     *
  285.     * @access public
  286.     * @return bool
  287.     * @param  string    $user   the name of the user to check if already exists
  288.     */
  289.     function userExists($user)
  290.     {
  291.         return isset($this->_users[$user]);
  292.     }
  293.     
  294.     /**
  295.     * Delete a certain user
  296.     *
  297.     * Returns a PEAR_Error if user doesn't exist.
  298.     * 
  299.     * @throws PEAR_Error
  300.     * @access public
  301.     * @return mixed true on success or PEAR_Error
  302.     * @param  string    
  303.     */
  304.     function delUser($user)
  305.     {
  306.         if (!$this->userExists($user)) {
  307.             return PEAR::raiseError(
  308.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  309.                 FILE_PASSWD_E_EXISTS_NOT
  310.             );
  311.         }
  312.         unset($this->_users[$user]);
  313.         return true;
  314.     }
  315.     
  316.     /**
  317.     * List user
  318.     *
  319.     * Returns a PEAR_Error if <var>$user</var> doesn't exist.
  320.     * 
  321.     * @throws PEAR_Error
  322.     * @access public
  323.     * @return mixed array of a/all user(s) or PEAR_Error
  324.     * @param  string    $user   the user to list or all users if empty
  325.     */
  326.     function listUser($user = '')
  327.     {
  328.         if (empty($user)) {
  329.             return $this->_users;
  330.         }
  331.         if (!$this->userExists($user)) {
  332.             return PEAR::raiseError(
  333.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  334.                 FILE_PASSWD_E_EXISTS_NOT
  335.             );
  336.         }
  337.         return $this->_users[$user];
  338.     }
  339.  
  340.     /**
  341.     * Base method for File_Passwd::staticAuth()
  342.     * 
  343.     * Returns a PEAR_Error if:
  344.     *   o file doesn't exist
  345.     *   o file couldn't be opened in read mode
  346.     *   o file couldn't be locked exclusively
  347.     *   o file couldn't be unlocked (only if auth fails)
  348.     *   o file couldn't be closed (only if auth fails)
  349.     * 
  350.     * @throws   PEAR_Error
  351.     * @access   protected
  352.     * @return   mixed       line of passwd file containing <var>$id</var>,
  353.     *                       false if <var>$id</var> wasn't found or PEAR_Error
  354.     * @param    string      $file   path to passwd file
  355.     * @param    string      $id     user_id to search for
  356.     */
  357.     function _auth($file, $id)
  358.     {
  359.         $file = realpath($file);
  360.         if (!is_file($file)) {
  361.             return PEAR::raiseError("File '$file' couldn't be found.", 0);
  362.         }
  363.         $fh = &File_Passwd_Common::_open('r', $file);
  364.         if (PEAR::isError($fh)) {
  365.             return $fh;
  366.         }
  367.         while ($line = fgets($fh)) {
  368.             if (strstr($line, $id)) {
  369.                 File_Passwd_Common::_close($fh);
  370.                 return trim($line);
  371.             }
  372.         }
  373.         $e = File_Passwd_Common::_close($fh);
  374.         if (PEAR::isError($e)) {
  375.             return $e;
  376.         }
  377.         return false;
  378.     }
  379. }
  380. ?>