custom.php

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

    *                       FILE_PASSWD_E_FILE_NOT_CLOSED
    * @access   public
    * @return   mixed   Returns &true; on success or 
    *                   <classname>PEAR_Error</classname> on failure.
    */
    function save()
    {
        $content = '';
        foreach ($this->_users as $user => $array){
            $pass   = array_shift($array);
            $extra  = implode($this->_delim, $array);
            $content .= $user . $this->_delim . $pass;
            if (!empty($extra)) {
                $content .= $this->_delim . $extra;
            }
            $content .= "\n";
        }
        return $this->_save($content);
    }

    /**
    * Parse the Custom password file
    *
    * Returns a PEAR_Error if passwd file has invalid format.
    * 
    * @throws   PEAR_Error  FILE_PASSWD_E_INVALID_FORMAT
    * @access   public
    * @return   mixed   Returns &true; on success or
    *                   <classname>PEAR_Error</classname> on failure.
    */
    function parse()
    {
        $this->_users = array();
        foreach ($this->_contents as $line){
            $parts = explode($this->_delim, $line);
            if (count($parts) < 2) {
                return PEAR::raiseError(
                    FILE_PASSWD_E_INVALID_FORMAT_STR,
                    FILE_PASSWD_E_INVALID_FORMAT
                );
            }
            $user = array_shift($parts);
            $pass = array_shift($parts);
            $values = array();
            if ($this->_usemap) {
                $values['pass'] = $pass;
                foreach ($parts as $i => $value){
                    if (isset($this->_map[$i])) {
                        $values[$this->_map[$i]] = $value;
                    } else {
                        $values[$i+1] = $value;
                    }
                }
            } else {
                $values = array_merge(array($pass), $parts);
            }
            $this->_users[$user] = $values;
            
        }
        $this->_contents = array();
        return true;
    }

    /**
    * Add an user
    *
    * The username must start with an alphabetical character and must NOT
    * contain any other characters than alphanumerics, the underline and dash.
    * 
    * If you use the 'name map' you should also use these naming in
    * the supplied extra array, because your values would get mixed up
    * if they are in the wrong order, which is always true if you
    * DON'T use the 'name map'!
    * 
    * So be warned and USE the 'name map'!
    * 
    * Returns a PEAR_Error if:
    *   o user already exists
    *   o user contains illegal characters
    *   o encryption mode is not supported
    *   o any element of the <var>$extra</var> array contains the delimiter char
    * 
    * @throws   PEAR_Error  FILE_PASSWD_E_EXISTS_ALREADY |
    *                       FILE_PASSWD_E_INVALID_ENC_MODE |
    *                       FILE_PASSWD_E_INVALID_CHARS
    * @access   public
    * @return   mixed   Returns &true; on success or 
    *                   <classname>PEAR_Error</classname> on failure.
    * @param    string  $user   the name of the user to add
    * @param    string  $pass   the password of the user to add
    * @param    array   $extra  extra properties of user to add
    */
    function addUser($user, $pass, $extra = array())
    {
        if ($this->userExists($user)) {
            return PEAR::raiseError(
                sprintf(FILE_PASSWD_E_EXISTS_ALREADY_STR, 'User ', $user),
                FILE_PASSWD_E_EXISTS_ALREADY
            );
        }
        if (!preg_match($this->_pcre, $user) || strstr($user, $this->_delim)) {
            return PEAR::raiseError(
                sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'User ', $user),
                FILE_PASSWD_E_INVALID_CHARS
            );
        }
        if (!is_array($extra)) {
            setType($extra, 'array');
        }
        foreach ($extra as $e){
            if (strstr($e, $this->_delim)) {
                return PEAR::raiseError(
                    sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'Property ', $e),
                    FILE_PASSWD_E_INVALID_CHARS
                );
            }
        }
        
        $pass = $this->_genPass($pass);
        if (PEAR::isError($pass)) {
            return $pass;
        }
        
        /**
        * If you don't use the 'name map' the user array will be numeric.
        */
        if (!$this->_usemap) {
            array_unshift($extra, $pass);
            $this->_users[$user] = $extra;
        } else {
            $map = $this->_map;
            array_unshift($map, 'pass');
            $extra['pass'] = $pass;
            foreach ($map as $key){
                $this->_users[$user][$key] = @$extra[$key];
            }
        }
        
        return true;
    }

    /**
    * Modify properties of a certain user
    *
    * # DON'T MODIFY THE PASSWORD WITH THIS METHOD!
    * 
    * You should use this method only if the 'name map' is used, too.
    * 
    * Returns a PEAR_Error if:
    *   o user doesn't exist
    *   o any property contains the custom delimiter character
    * 
    * @see      changePasswd()
    * 
    * @throws   PEAR_Error  FILE_PASSWD_E_EXISTS_NOT | 
    *                       FILE_PASSWD_E_INVALID_CHARS
    * @access   public
    * @return   mixed       true on success or PEAR_Error
    * @param    string      $user           the user to modify
    * @param    array       $properties     an associative array of 
    *                                       properties to modify
    */
    function modUser($user, $properties = array())
    {
        if (!$this->userExists($user)) {
            return PEAR::raiseError(
                sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
                FILE_PASSWD_E_EXISTS_NOT
            );
        }
        
        if (!is_array($properties)) {
            setType($properties, 'array');
        }
        
        foreach ($properties as $key => $value){
            if (strstr($value, $this->_delim)) {
                return PEAR::raiseError(
                    sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'User ', $user),
                    FILE_PASSWD_E_INVALID_CHARS
                );
            }
            $this->_users[$user][$key] = $value;
        }
        
        return true;
    }

    /**
    * Change the password of a certain user
    *
    * Returns a PEAR_Error if:
    *   o user doesn't exists
    *   o encryption mode is not supported
    * 
    * @throws   PEAR_Error  FILE_PASSWD_E_EXISTS_NOT |
    *                       FILE_PASSWD_E_INVALID_ENC_MODE
    * @access   public
    * @return   mixed   Returns &true; on success or 
    *                   <classname>PEAR_Error</classname> on failure.
    * @param    string  $user   the user whose password should be changed
    * @param    string  $pass   the new plaintext password
    */
    function changePasswd($user, $pass)
    {
        if (!$this->userExists($user)) {
            return PEAR::raiseError(
                sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
                FILE_PASSWD_E_EXISTS_NOT
            );
        }
        
        $pass = $this->_genPass($pass);
        if (PEAR::isError($pass)) {
            return $pass;
        }
        
        if ($this->_usemap) {
            $this->_users[$user]['pass'] = $pass;
        } else {
            $this->_users[$user][0] = $pass;
        }
        
        return true;
    }

    /**
    * Verify the password of a certain user
    * 
    * Returns a PEAR_Error if:
    *   o user doesn't exist
    *   o encryption mode is not supported
    *
    * @throws   PEAR_Error  FILE_PASSWD_E_EXISTS_NOT |
    *                       FILE_PASSWD_E_INVALID_ENC_MODE
    * @access   public
    * @return   mixed   Returns &true; if passwors equal, &false; if they don't 
    *                   or <classname>PEAR_Error</classname> on fialure.
    * @param    string  $user   the user whose password should be verified
    * @param    string  $pass   the password to verify
    */
    function verifyPasswd($user, $pass)
    {
        if (!$this->userExists($user)) {
            return PEAR::raiseError(
                sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
                FILE_PASSWD_E_EXISTS_NOT
            );
        }
        $real = 
            $this->_usemap ? 
            $this->_users[$user]['pass'] : 
            $this->_users[$user][0]
        ;
        return ($real === $this->_genPass($pass, $real));
    }
    
    /**
    * Generate crypted password from the plaintext password
    *
    * Returns a PEAR_Error if actual encryption mode is not supported.
    * 
    * @throws   PEAR_Error  FILE_PASSWD_E_INVALID_ENC_MODE
    * @access   private
    * @return   mixed   Returns the crypted password or 
    *                   <classname>PEAR_Error</classname>
    * @param    string  $pass   the plaintext password
    * @param    string  $salt   the crypted password from which to gain the salt
    * @param    string  $func   the encryption function to use
    */
    function _genPass($pass, $salt = null, $func = null)
    {
        if (is_null($func)) {
            $func = $this->_enc;
        }
        
        if (!is_callable($func)) {
            if (is_array($func)) {
                $func = implode('::', $func);
            }
            return PEAR::raiseError(
                sprintf(FILE_PASSWD_E_INVALID_ENC_MODE_STR, $func),
                FILE_PASSWD_E_INVALID_ENC_MODE
            );
        }
        
        $return = @call_user_func($func, $pass, $salt);
        
        if (is_null($return) || $return === false) {
            $return = @call_user_func($func, $pass);
        }
        
        return $return;
    }
}
?>