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