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 / adodb / pear / Auth / Container / ADOdb.php
Encoding:
PHP Script  |  2005-09-08  |  12.5 KB  |  414 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP Version 4                                                        |
  5. // +----------------------------------------------------------------------+
  6. // |                                                                      |
  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: Martin Jansen <mj@php.net>
  17. // |    Richard Tango-Lowy <richtl@arscognita.com>                                  |
  18. // +----------------------------------------------------------------------+
  19. //
  20. // $Id: ADOdb.php,v 1.3 2005/05/18 06:58:47 jlim Exp $
  21. //
  22.  
  23. require_once 'Auth/Container.php';
  24. require_once 'adodb.inc.php';
  25. require_once 'adodb-pear.inc.php';
  26. require_once 'adodb-errorpear.inc.php';
  27.  
  28. /**
  29.  * Storage driver for fetching login data from a database using ADOdb-PHP.
  30.  *
  31.  * This storage driver can use all databases which are supported
  32.  * by the ADBdb DB abstraction layer to fetch login data.
  33.  * See http://php.weblogs.com/adodb for information on ADOdb.
  34.  * NOTE: The ADOdb directory MUST be in your PHP include_path!
  35.  *
  36.  * @author   Richard Tango-Lowy <richtl@arscognita.com>
  37.  * @package  Auth
  38.  * @version  $Revision: 1.3 $
  39.  */
  40. class Auth_Container_ADOdb extends Auth_Container
  41. {
  42.  
  43.     /**
  44.      * Additional options for the storage container
  45.      * @var array
  46.      */
  47.     var $options = array();
  48.  
  49.     /**
  50.      * DB object
  51.      * @var object
  52.      */
  53.     var $db = null;
  54.     var $dsn = '';
  55.     
  56.     /**
  57.      * User that is currently selected from the DB.
  58.      * @var string
  59.      */
  60.     var $activeUser = '';
  61.  
  62.     // {{{ Constructor
  63.  
  64.     /**
  65.      * Constructor of the container class
  66.      *
  67.      * Initate connection to the database via PEAR::ADOdb
  68.      *
  69.      * @param  string Connection data or DB object
  70.      * @return object Returns an error object if something went wrong
  71.      */
  72.     function Auth_Container_ADOdb($dsn)
  73.     {
  74.         $this->_setDefaults();
  75.         
  76.         if (is_array($dsn)) {
  77.             $this->_parseOptions($dsn);
  78.  
  79.             if (empty($this->options['dsn'])) {
  80.                 PEAR::raiseError('No connection parameters specified!');
  81.             }
  82.         } else {
  83.             // Extract db_type from dsn string.
  84.             $this->options['dsn'] = $dsn;
  85.         }
  86.     }
  87.  
  88.     // }}}
  89.     // {{{ _connect()
  90.  
  91.     /**
  92.      * Connect to database by using the given DSN string
  93.      *
  94.      * @access private
  95.      * @param  string DSN string
  96.      * @return mixed  Object on error, otherwise bool
  97.      */
  98.      function _connect($dsn)
  99.     {
  100.         if (is_string($dsn) || is_array($dsn)) {
  101.             if(!$this->db) {
  102.                 $this->db = &ADONewConnection($dsn);
  103.                 if( $err = ADODB_Pear_error() ) {
  104.                        return PEAR::raiseError($err);
  105.                 }
  106.             }
  107.             
  108.         } else {
  109.             return PEAR::raiseError('The given dsn was not valid in file ' . __FILE__ . ' at line ' . __LINE__,
  110.                                     41,
  111.                                     PEAR_ERROR_RETURN,
  112.                                     null,
  113.                                     null
  114.                                     );
  115.         }
  116.         
  117.         if(!$this->db) {
  118.             return PEAR::raiseError(ADODB_Pear_error());
  119.         } else {
  120.             return true;
  121.         }
  122.     }
  123.  
  124.     // }}}
  125.     // {{{ _prepare()
  126.  
  127.     /**
  128.      * Prepare database connection
  129.      *
  130.      * This function checks if we have already opened a connection to
  131.      * the database. If that's not the case, a new connection is opened.
  132.      *
  133.      * @access private
  134.      * @return mixed True or a DB error object.
  135.      */
  136.     function _prepare()
  137.     {
  138.         if(!$this->db) {
  139.             $res = $this->_connect($this->options['dsn']);          
  140.         }
  141.         return true;
  142.     }
  143.  
  144.     // }}}
  145.     // {{{ query()
  146.  
  147.     /**
  148.      * Prepare query to the database
  149.      *
  150.      * This function checks if we have already opened a connection to
  151.      * the database. If that's not the case, a new connection is opened.
  152.      * After that the query is passed to the database.
  153.      *
  154.      * @access public
  155.      * @param  string Query string
  156.      * @return mixed  a DB_result object or DB_OK on success, a DB
  157.      *                or PEAR error on failure
  158.      */
  159.     function query($query)
  160.     {
  161.         $err = $this->_prepare();
  162.         if ($err !== true) {
  163.             return $err;
  164.         }
  165.         return $this->db->query($query);
  166.     }
  167.  
  168.     // }}}
  169.     // {{{ _setDefaults()
  170.  
  171.     /**
  172.      * Set some default options
  173.      *
  174.      * @access private
  175.      * @return void
  176.      */
  177.     function _setDefaults()
  178.     {
  179.         $this->options['db_type']    = 'mysql';
  180.         $this->options['table']       = 'auth';
  181.         $this->options['usernamecol'] = 'username';
  182.         $this->options['passwordcol'] = 'password';
  183.         $this->options['dsn']         = '';
  184.         $this->options['db_fields']   = '';
  185.         $this->options['cryptType']   = 'md5';
  186.     }
  187.  
  188.     // }}}
  189.     // {{{ _parseOptions()
  190.  
  191.     /**
  192.      * Parse options passed to the container class
  193.      *
  194.      * @access private
  195.      * @param  array
  196.      */
  197.     function _parseOptions($array)
  198.     {
  199.         foreach ($array as $key => $value) {
  200.             if (isset($this->options[$key])) {
  201.                 $this->options[$key] = $value;
  202.             }
  203.         }
  204.  
  205.         /* Include additional fields if they exist */
  206.         if(!empty($this->options['db_fields'])){
  207.             if(is_array($this->options['db_fields'])){
  208.                 $this->options['db_fields'] = join($this->options['db_fields'], ', ');
  209.             }
  210.             $this->options['db_fields'] = ', '.$this->options['db_fields'];
  211.         }
  212.     }
  213.  
  214.     // }}}
  215.     // {{{ fetchData()
  216.  
  217.     /**
  218.      * Get user information from database
  219.      *
  220.      * This function uses the given username to fetch
  221.      * the corresponding login data from the database
  222.      * table. If an account that matches the passed username
  223.      * and password is found, the function returns true.
  224.      * Otherwise it returns false.
  225.      *
  226.      * @param   string Username
  227.      * @param   string Password
  228.      * @return  mixed  Error object or boolean
  229.      */
  230.     function fetchData($username, $password)
  231.     {
  232.         // Prepare for a database query
  233.         $err = $this->_prepare();
  234.         if ($err !== true) {
  235.             return PEAR::raiseError($err->getMessage(), $err->getCode());
  236.         }
  237.  
  238.         // Find if db_fields contains a *, i so assume all col are selected
  239.         if(strstr($this->options['db_fields'], '*')){
  240.             $sql_from = "*";
  241.         }
  242.         else{
  243.             $sql_from = $this->options['usernamecol'] . ", ".$this->options['passwordcol'].$this->options['db_fields'];
  244.         }
  245.         
  246.         $query = "SELECT ".$sql_from.
  247.                 " FROM ".$this->options['table'].
  248.                 " WHERE ".$this->options['usernamecol']." = " . $this->db->Quote($username);
  249.         
  250.         $ADODB_FETCH_MODE = ADODB_FETCH_ASSOC;
  251.         $rset = $this->db->Execute( $query );
  252.         $res = $rset->fetchRow();
  253.  
  254.         if (DB::isError($res)) {
  255.             return PEAR::raiseError($res->getMessage(), $res->getCode());
  256.         }
  257.         if (!is_array($res)) {
  258.             $this->activeUser = '';
  259.             return false;
  260.         }
  261.         if ($this->verifyPassword(trim($password, "\r\n"),
  262.                                   trim($res[$this->options['passwordcol']], "\r\n"),
  263.                                   $this->options['cryptType'])) {
  264.             // Store additional field values in the session
  265.             foreach ($res as $key => $value) {
  266.                 if ($key == $this->options['passwordcol'] ||
  267.                     $key == $this->options['usernamecol']) {
  268.                     continue;
  269.                 }
  270.                 // Use reference to the auth object if exists
  271.                 // This is because the auth session variable can change so a static call to setAuthData does not make sence
  272.                 if(is_object($this->_auth_obj)){
  273.                     $this->_auth_obj->setAuthData($key, $value);
  274.                 } else {
  275.                     Auth::setAuthData($key, $value);
  276.                 }
  277.             }
  278.  
  279.             return true;
  280.         }
  281.  
  282.         $this->activeUser = $res[$this->options['usernamecol']];
  283.         return false;
  284.     }
  285.  
  286.     // }}}
  287.     // {{{ listUsers()
  288.  
  289.     function listUsers()
  290.     {
  291.         $err = $this->_prepare();
  292.         if ($err !== true) {
  293.             return PEAR::raiseError($err->getMessage(), $err->getCode());
  294.         }
  295.  
  296.         $retVal = array();
  297.  
  298.         // Find if db_fileds contains a *, i so assume all col are selected
  299.         if(strstr($this->options['db_fields'], '*')){
  300.             $sql_from = "*";
  301.         }
  302.         else{
  303.             $sql_from = $this->options['usernamecol'] . ", ".$this->options['passwordcol'].$this->options['db_fields'];
  304.         }
  305.  
  306.         $query = sprintf("SELECT %s FROM %s",
  307.                          $sql_from,
  308.                          $this->options['table']
  309.                          );
  310.         $res = $this->db->getAll($query, null, DB_FETCHMODE_ASSOC);
  311.  
  312.         if (DB::isError($res)) {
  313.             return PEAR::raiseError($res->getMessage(), $res->getCode());
  314.         } else {
  315.             foreach ($res as $user) {
  316.                 $user['username'] = $user[$this->options['usernamecol']];
  317.                 $retVal[] = $user;
  318.             }
  319.         }
  320.         return $retVal;
  321.     }
  322.  
  323.     // }}}
  324.     // {{{ addUser()
  325.  
  326.     /**
  327.      * Add user to the storage container
  328.      *
  329.      * @access public
  330.      * @param  string Username
  331.      * @param  string Password
  332.      * @param  mixed  Additional information that are stored in the DB
  333.      *
  334.      * @return mixed True on success, otherwise error object
  335.      */
  336.     function addUser($username, $password, $additional = "")
  337.     {
  338.         if (function_exists($this->options['cryptType'])) {
  339.             $cryptFunction = $this->options['cryptType'];
  340.         } else {
  341.             $cryptFunction = 'md5';
  342.         }
  343.  
  344.         $additional_key   = '';
  345.         $additional_value = '';
  346.  
  347.         if (is_array($additional)) {
  348.             foreach ($additional as $key => $value) {
  349.                 $additional_key .= ', ' . $key;
  350.                 $additional_value .= ", '" . $value . "'";
  351.             }
  352.         }
  353.  
  354.         $query = sprintf("INSERT INTO %s (%s, %s%s) VALUES ('%s', '%s'%s)",
  355.                          $this->options['table'],
  356.                          $this->options['usernamecol'],
  357.                          $this->options['passwordcol'],
  358.                          $additional_key,
  359.                          $username,
  360.                          $cryptFunction($password),
  361.                          $additional_value
  362.                          );
  363.  
  364.         $res = $this->query($query);
  365.  
  366.         if (DB::isError($res)) {
  367.            return PEAR::raiseError($res->getMessage(), $res->getCode());
  368.         } else {
  369.           return true;
  370.         }
  371.     }
  372.  
  373.     // }}}
  374.     // {{{ removeUser()
  375.  
  376.     /**
  377.      * Remove user from the storage container
  378.      *
  379.      * @access public
  380.      * @param  string Username
  381.      *
  382.      * @return mixed True on success, otherwise error object
  383.      */
  384.     function removeUser($username)
  385.     {
  386.         $query = sprintf("DELETE FROM %s WHERE %s = '%s'",
  387.                          $this->options['table'],
  388.                          $this->options['usernamecol'],
  389.                          $username
  390.                          );
  391.  
  392.         $res = $this->query($query);
  393.  
  394.         if (DB::isError($res)) {
  395.            return PEAR::raiseError($res->getMessage(), $res->getCode());
  396.         } else {
  397.           return true;
  398.         }
  399.     }
  400.  
  401.     // }}}
  402. }
  403.  
  404. function showDbg( $string ) {
  405.     print "
  406. -- $string</P>";
  407. }
  408. function dump( $var, $str, $vardump = false ) {
  409.     print "<H4>$str</H4><pre>";
  410.     ( !$vardump ) ? ( print_r( $var )) : ( var_dump( $var ));
  411.     print "</pre>";
  412. }
  413. ?>
  414.