Solved

Assigning the return value of new by reference is deprecated in

Posted on 2010-08-26
2
5,025 Views
Last Modified: 2012-08-13
PHP Deprecated:  Assigning the return value of new by reference is deprecated in C:\inetpub\wwwroot\osDate_v254\public_html\libs\Pear\DB.php on line 311
PHP Deprecated:  Assigning the return value of new by reference is deprecated in C:\inetpub\wwwroot\osDate_v254\public_html\libs\Pear\DB.php on line 384
PHP Deprecated:  Assigning the return value of new by reference is deprecated in C:\inetpub\wwwroot\osDate_v254\public_html\libs\Pear\DB.php on line 889

<?php

//osDate Installer

session_start();

include 'install_files/consts.php'; 	// Constants

include 'install_files/funcs.php';		// Needed functions

include 'install_files/header.tpl';		// HTML Header

@set_time_limit(1200);



error_reporting( E_ALL - E_NOTICE );



if ( (!isset( $_GET['step'])) || ($_GET['step'] < 1 || $_GET['step'] > 7) )

	$step = 1;

else

	$step = $_GET['step'];



if ($step > 1)

{





	$typeValues = array( 'mysql', 'pgsql', 'ibase', 'msql', 'mssql', 'oci8', 'odbc', 'sybase', 'ifx', 'fbsql');



	$typeNames  = array(

		'MySQL',

		'PostgreSQL',

		'InterBase',

		'Mini SQL',

		'Microsoft SQL Server',

		'Oracle 7/8/8i',

		'ODBC (Open Database Connectivity)',

		'SyBase',

		'Informix',

		'FrontBase'

		);

	// Can use templates

	$full_path = dirname(__FILE__) . '/';

	$dbtype='mysql'; //default db type

	import_request_variables( 'pgs' );



	define ( 'SMARTY_DIR', $full_path . 'libs/Smarty/' );

	define ( 'TEMPLATES_DIR', $full_path . 'templates/' );

	define ( 'TEMPLATE_DIR', $full_path . 'templates/' );

	define ( 'TEMPLATE_C_DIR', $full_path . 'templates_c/' );

	define ( 'PEAR_DIR', $full_path . 'libs/Pear/' );

	define ( 'CACHE_DIR', $full_path . 'cache/' );

	define ( 'INCLUDE_DIR', $full_path . 'includes/' );

	define ( 'DOC_ROOT', $full_path );

//	define ( 'LANG_DIR', $full_path . 'language/' );



	require_once SMARTY_DIR . 'Config_File.class.php';

	require_once SMARTY_DIR . 'Smarty.class.php';

	require_once INCLUDE_DIR . 'internal/Functions.php';



	//ini_set( 'include_path', PEAR_DIR );



	require_once( PEAR_DIR . 'DB.php' );



	//	PEAR::setErrorHandling( PEAR_ERROR_CALLBACK, 'errhndl' );



	$t = new Smarty;

	$t->template_dir = TEMPLATE_DIR;

	$t->compile_dir = TEMPLATE_C_DIR;

	$t->cache_dir = CACHE_DIR;



	$t->assign('typeValues',$typeValues);

	$t->assign('typeNames',$typeNames);



	$t->assign('dbtype', $dbtype);



	if (!isset($_SESSION['configAvailable'])) $_SESSION['configAvailable'] = 'N';



	if ( !isset($_SESSION['replacearray']) || $dbuser != '') {





		if (file_exists('myconfigs/config.php') ) {



			include_once('myconfigs/config.php');

			$configdata = file('myconfigs/config.php');



		} elseif (file_exists('config.php')) {



			$configdata = file('config.php');

			include_once('config.php');



		}

		if (count($configdata) > 2) {

			$_SESSION['configAvailable'] = 'Y';

			$_SESSION['osDate_current_version'] = C_VERSION;

			foreach ($configdata as $line) {

				if (substr_count($line,'define') > 0) {

					eval($line);

				}

			}

		}



		define ('DB_USER', $dbuser);

		define('DB_PASS', $dbpasswd);

		define('DB_HOST', $dbhost);

		define('DB_NAME', $dbname);

		define('DB_PREFIX', $prefix);

		define('DB_TYPE', $dbtype);

		$_SESSION['replacearray'] = array(

		'MAIL_FORMAT'	=> MAIL_FORMAT,

		'MAIL_TYPE'		=> MAIL_TYPE,

		'SMTP_HOST'		=> SMTP_HOST,

		'SMTP_PORT'		=> SMTP_PORT,

		'SMTP_AUTH'		=> SMTP_AUTH,

		'SMTP_USER'		=> SMTP_USER,

		'SMTP_PASS'		=> SMTP_PASS,

		'SM_PATH'		=> SM_PATH,

		'DB_USER'		=> DB_USER,

		'DB_NAME'		=> DB_NAME,

		'DB_HOST'		=> DB_HOST,

		'DB_PASS'		=> DB_PASS,

		'DB_TYPE'		=> DB_TYPE,

		'DB_PREFIX' 	=> DB_PREFIX

		);



	} elseif (isset($_SESSION['replacearray'])){



		define ('MAIL_FORMAT', $_SESSION['replacearray']['MAIL_FORMAT']);

		define ('MAIL_TYPE', $_SESSION['replacearray']['MAIL_TYPE']);

		define ('SMTP_HOST', $_SESSION['replacearray']['SMTP_HOST']);

		define ('SMTP_PORT', $_SESSION['replacearray']['SMTP_PORT']);

		define ('SMTP_AUTH', $_SESSION['replacearray']['SMTP_AUTH']);

		define ('SMTP_USER', $_SESSION['replacearray']['SMTP_USER']);

		define ('SMTP_PASS', $_SESSION['replacearray']['SMTP_PASS']);

		define ('SM_PATH', $_SESSION['replacearray']['SM_PATH']);

		define ('DB_USER', $_SESSION['replacearray']['DB_USER']);

		define ('DB_NAME', $_SESSION['replacearray']['DB_NAME']);

		define ('DB_HOST', $_SESSION['replacearray']['DB_HOST']);

		define ('DB_PASS', $_SESSION['replacearray']['DB_PASS']);

		define ('DB_TYPE', $_SESSION['replacearray']['DB_TYPE']);

		define ('DB_PREFIX', $_SESSION['replacearray']['DB_PREFIX']);

		define ('DOC_ROOT', $_SESSION['replacearray']['DOC_ROOT']);

	}



	define('VERSION',$_SESSION['osDate_current_version']);

}



// First step - general check



if ($step == 1) {

	include 'install_files/step_1.tpl';



	unset($_SESSION['replacearray']);

	unset($_SESSION['configAvailable']);

	$canContinue = 1;



	//check GD librarry

	$good = function_exists( 'gd_info' ) ? 1 : 0;

	$canContinue = $canContinue && $good;

	Message ( 'GD library exists: ', $good );



	//JPEG support

	$good = function_exists( 'imagecreatefromjpeg' ) && function_exists( 'imagejpeg' ) ? 1 : 0;

	$canContinue = $canContinue && $good;

	Message ( 'JPEG support exists for GD: ', $good );

	//---

	$canContinue = isWriteable ( $canContinue, 'banners/', 0777, 'banners folder' );

	$canContinue = isWriteable ( $canContinue, 'cache/', 0777, 'cache folder' );

	$canContinue = isWriteable ( $canContinue, 'emailimages/', 0777, 'emailimages folder' );

	$canContinue = isWriteable ( $canContinue, 'myconfigs/', 0777, 'myconfigs folder');

	if (file_exists('myconfigs/config.php') ) {

		$canContinue = isWriteable ( $canContinue, 'myconfigs/config.php', 0777, 'myconfigs/config.php file');

	}

	$canContinue = isWriteable ( $canContinue, 'plugins/', 0777, 'plugins folder' );

	$canContinue = isWriteable ( $canContinue, 'temp/', 0777, 'temp folder' );

	$canContinue = isWriteable ( $canContinue, 'temp/imageedits/', 0777, 'temp/imageedits  folder' );

	$canContinue = isWriteable ( $canContinue, 'temp/imageedits/original/', 0777, 'temp/imageedits/original folder' );

	$canContinue = isWriteable ( $canContinue, 'templates_c/', 0777, 'templates_c folder' );

	$canContinue = isWriteable ( $canContinue, 'userimages/', 0777, 'userimages folder' );

	$canContinue = isWriteable ( $canContinue, 'uservideos/', 0777, 'uservideos folder' );

	$ftpCan = $canContinue;



	$good = function_exists( 'mysql_connect' ) ? 1 : 0;

	$canContinue = $canContinue && $good;



	Message ( 'MySQL support exists: ', $good );



	$good = phpversion() >= '4.1.2' ? 1 : 0;

	$canContinue = $canContinue && $good;



	Message ( 'PHP version >= 4.1.2: ', $good );



	echo '</table>';



	if ( $canContinue) {

		echo  '<tr><td colspan="2" align="center"><b><font style="font-size:12pt">Congratulations!</font></b><br />You may continue the installation.</td></tr><tr><td colspan=2 align="right"><input type="button" name="continue" value="Continue >>" onclick="javascript:document.location.href=\'?step=2&amp;dispstep=1\'" /></td></tr>';

	} else {

		echo  '<tr><td colspan="2" ><br />The installer has detected some problems with your server environment, which will not allow osDate to operate correctly.<br /><br />Please correct these issues and then refresh the page to re-check your environment.<br /><br />';



		echo '<br /><input type="button" name="continue" value="Continue >>" onclick="javascript:alert(\'Please correct the above problems before continuing.\')" /></td></tr>';

	}

}



// Second step - database login information



if ( $step == 2 )

{

	$t->assign( 'errorConnection', 0 );

	include 'install_files/step_2.php';

}



// Third step - test connection



if ( $step == 3 )

{

	include 'install_files/step_3.php';

}



if ($step == 4) {



	include 'install_files/step_4.php';

}

if ($step == 5) {



	include 'install_files/step_5.php';

}

if ($step == 6)

{

	/* Accept mail settings */



	$sendMailPath = @ini_get( sendmail_path );



	// if sendmail is found, then parse it to remove sendmail options



	if ( $sendMailPath ) {

		$sendMailPathParts = explode( ' ', $sendMailPath );

		$sendMailPath = $sendMailPathParts[0];

	}



	$t->assign( 'dispstep', $dispstep+1);

	$t->assign( 'config_opt', $config_opt);



	$t->assign( 'sendMailPath', $sendMailPath );



    $t->assign( 'formatValues', array( 'text', 'html') );

    $t->assign( 'formatNames', array(  'Text', 'HTML' ) );

    $t->assign( 'typeValues', array( 'sendmail', 'smtp', 'mail' ) );

    $t->assign( 'typeNames', array(  'Sendmail', 'SMTP', 'Standard Mail' ) );



    $t->display( 'install/install_step6.tpl' );

}



// Fifth step - writing mail settings

if ($step == 7)

{

	// clear the cache & template_c before starting osDate



	$t->clear_all_cache();

	$t->clear_compiled_tpl();



	// remove all files from image cache

	include_once( 'includes/internal/class.cacher.php' );

	$c = new Cacher();

	$c->clear();



	define ('CONFIG_FILE', 'config.inc.php');



	if ($_POST['mail_set']!= '' ) {



	    extract ($_POST);



	    if (!isset($smtpAuth))

			$smtpAuth = 0;



		// Replacing config variables



		$replace = array(

			'DB_USER' => $_SESSION['replacearray']['DB_USER'],

			'DB_NAME' => $_SESSION['replacearray']['DB_NAME'],

			'DB_HOST' => $_SESSION['replacearray']['DB_HOST'],

			'DB_PASS' => $_SESSION['replacearray']['DB_PASS'],

			'DB_TYPE' => $_SESSION['replacearray']['DB_TYPE'],

			'DB_PREFIX' => $_SESSION['replacearray']['DB_PREFIX'],

			'DOC_ROOT' => $_SESSION['replacearray']['DOC_ROOT'],

			'C_VERSION'	=> OSDATE_VERSION,

			'MAIL_FORMAT'	=> $mailFormat,

			'MAIL_TYPE'		=> $mailType,

			'SMTP_HOST'		=> $smtpHost,

			'SMTP_PORT'		=> $smtpPort,

			'SMTP_AUTH'		=> $smtpAuth,

			'SMTP_USER'		=> $smtpUser,

			'SMTP_PASS'		=> $smtpPassword,

			'SM_PATH'		=> $smPath );

		$dsn = $_SESSION['replacearray']['DB_TYPE'] . '://' . $_SESSION['replacearray']['DB_USER'] . ':' . $_SESSION['replacearray']['DB_PASS'] . '@' . $_SESSION['replacearray']['DB_HOST'] . '/' .$_SESSION['replacearray']['DB_NAME'];

		$db = @DB::connect( $dsn );

		$db->setFetchMode( DB_FETCHMODE_ASSOC );

		$sql = 'update '.$_SESSION['replacearray']['DB_PREFIX']."_glblsettings" ." set config_value='".$mailFormat."' where config_variable='MAIL_FORMAT'";

		$r = $db->query($sql) ;

		$db->query('update '.$_SESSION['replacearray']['DB_PREFIX']."_glblsettings" ." set config_value='".$mailType."' where config_variable='MAIL_TYPE'") ;

		$db->query('update '.$_SESSION['replacearray']['DB_PREFIX']."_glblsettings" ." set config_value='".$smtpHost."' where config_variable='SMTP_HOST'") ;

		$db->query('update '.$_SESSION['replacearray']['DB_PREFIX']."_glblsettings" ." set config_value='".$smtpPort."' where config_variable='SMTP_PORT'") ;

		$db->query('update '.$_SESSION['replacearray']['DB_PREFIX']."_glblsettings" ." set config_value='".$smtpAuth."' where config_variable='SMTP_AUTH'") ;

		$db->query('update '.$_SESSION['replacearray']['DB_PREFIX']."_glblsettings" ." set config_value='".$smtpUser."' where config_variable='SMTP_USER'") ;

		$db->query('update '.$_SESSION['replacearray']['DB_PREFIX']."_glblsettings" ." set config_value='".$smtpPassword."' where config_variable='SMTP_PASS'") ;

		$db->query('update '.$_SESSION['replacearray']['DB_PREFIX']."_glblsettings" ." set config_value='".$smPath."' where config_variable='SM_PATH'") ;

		$t->assign( 'configCreated', true );



	}

	$t->assign('mail_set', $_POST['mail_set']);

	$t->assign('config_opt', $config_opt);

	$t->assign('dispstep', $dispstep + 1);

	$t->display('install/install_step7.tpl');



}



unset( $db );



include './install_files/footer.tpl'; //HTML Footer.

?>

Open in new window

<?php

/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */

// +----------------------------------------------------------------------+

// | PHP Version 4                                                        |

// +----------------------------------------------------------------------+

// | Copyright (c) 1997-2004 The PHP Group                                |

// +----------------------------------------------------------------------+

// | This source file is subject to version 2.02 of the PHP license,      |

// | that is bundled with this package in the file LICENSE, and is        |

// | available at through the world-wide-web at                           |

// | http://www.php.net/license/2_02.txt.                                 |

// | If you did not receive a copy of the PHP license and are unable to   |

// | obtain it through the world-wide-web, please send a note to          |

// | license@php.net so we can mail you a copy immediately.               |

// +----------------------------------------------------------------------+

// | Authors: Stig Bakken <ssb@php.net>                                   |

// |          Tomas V.V.Cox <cox@idecnet.com>                             |

// | Maintainer: Daniel Convissor <danielc@php.net>                       |

// +----------------------------------------------------------------------+

//

// $Id: DB.php,v 1.3 2005/07/22 05:10:13 max Exp $

//

// Database independent query interface.



require_once(PEAR_DIR.'PEAR.php');





// {{{ constants

// {{{ error codes



/*

 * The method mapErrorCode in each DB_dbtype implementation maps

 * native error codes to one of these.

 *

 * If you add an error code here, make sure you also add a textual

 * version of it in DB::errorMessage().

 */

define('DB_OK',                         1);

define('DB_ERROR',                     -1);

define('DB_ERROR_SYNTAX',              -2);

define('DB_ERROR_CONSTRAINT',          -3);

define('DB_ERROR_NOT_FOUND',           -4);

define('DB_ERROR_ALREADY_EXISTS',      -5);

define('DB_ERROR_UNSUPPORTED',         -6);

define('DB_ERROR_MISMATCH',            -7);

define('DB_ERROR_INVALID',             -8);

define('DB_ERROR_NOT_CAPABLE',         -9);

define('DB_ERROR_TRUNCATED',          -10);

define('DB_ERROR_INVALID_NUMBER',     -11);

define('DB_ERROR_INVALID_DATE',       -12);

define('DB_ERROR_DIVZERO',            -13);

define('DB_ERROR_NODBSELECTED',       -14);

define('DB_ERROR_CANNOT_CREATE',      -15);

define('DB_ERROR_CANNOT_DELETE',      -16);

define('DB_ERROR_CANNOT_DROP',        -17);

define('DB_ERROR_NOSUCHTABLE',        -18);

define('DB_ERROR_NOSUCHFIELD',        -19);

define('DB_ERROR_NEED_MORE_DATA',     -20);

define('DB_ERROR_NOT_LOCKED',         -21);

define('DB_ERROR_VALUE_COUNT_ON_ROW', -22);

define('DB_ERROR_INVALID_DSN',        -23);

define('DB_ERROR_CONNECT_FAILED',     -24);

define('DB_ERROR_EXTENSION_NOT_FOUND',-25);

define('DB_ERROR_ACCESS_VIOLATION',   -26);

define('DB_ERROR_NOSUCHDB',           -27);

define('DB_ERROR_CONSTRAINT_NOT_NULL',-29);





// }}}

// {{{ prepared statement-related





/*

 * These constants are used when storing information about prepared

 * statements (using the "prepare" method in DB_dbtype).

 *

 * The prepare/execute model in DB is mostly borrowed from the ODBC

 * extension, in a query the "?" character means a scalar parameter.

 * There are two extensions though, a "&" character means an opaque

 * parameter.  An opaque parameter is simply a file name, the real

 * data are in that file (useful for putting uploaded files into your

 * database and such). The "!" char means a parameter that must be

 * left as it is.

 * They modify the quote behavoir:

 * DB_PARAM_SCALAR (?) => 'original string quoted'

 * DB_PARAM_OPAQUE (&) => 'string from file quoted'

 * DB_PARAM_MISC   (!) => original string

 */

define('DB_PARAM_SCALAR', 1);

define('DB_PARAM_OPAQUE', 2);

define('DB_PARAM_MISC',   3);





// }}}

// {{{ binary data-related





/*

 * These constants define different ways of returning binary data

 * from queries.  Again, this model has been borrowed from the ODBC

 * extension.

 *

 * DB_BINMODE_PASSTHRU sends the data directly through to the browser

 * when data is fetched from the database.

 * DB_BINMODE_RETURN lets you return data as usual.

 * DB_BINMODE_CONVERT returns data as well, only it is converted to

 * hex format, for example the string "123" would become "313233".

 */

define('DB_BINMODE_PASSTHRU', 1);

define('DB_BINMODE_RETURN',   2);

define('DB_BINMODE_CONVERT',  3);





// }}}

// {{{ fetch modes





/**

 * This is a special constant that tells DB the user hasn't specified

 * any particular get mode, so the default should be used.

 */

define('DB_FETCHMODE_DEFAULT', 0);



/**

 * Column data indexed by numbers, ordered from 0 and up

 */

define('DB_FETCHMODE_ORDERED', 1);



/**

 * Column data indexed by column names

 */

define('DB_FETCHMODE_ASSOC', 2);



/**

 * Column data as object properties

 */

define('DB_FETCHMODE_OBJECT', 3);



/**

 * For multi-dimensional results: normally the first level of arrays

 * is the row number, and the second level indexed by column number or name.

 * DB_FETCHMODE_FLIPPED switches this order, so the first level of arrays

 * is the column name, and the second level the row number.

 */

define('DB_FETCHMODE_FLIPPED', 4);



/* for compatibility */

define('DB_GETMODE_ORDERED', DB_FETCHMODE_ORDERED);

define('DB_GETMODE_ASSOC',   DB_FETCHMODE_ASSOC);

define('DB_GETMODE_FLIPPED', DB_FETCHMODE_FLIPPED);





// }}}

// {{{ tableInfo() && autoPrepare()-related





/**

 * these are constants for the tableInfo-function

 * they are bitwised or'ed. so if there are more constants to be defined

 * in the future, adjust DB_TABLEINFO_FULL accordingly

 */

define('DB_TABLEINFO_ORDER', 1);

define('DB_TABLEINFO_ORDERTABLE', 2);

define('DB_TABLEINFO_FULL', 3);



/*

 * Used by autoPrepare()

 */

if (!defined('DB_AUTOQUERY_INSERT') ) define('DB_AUTOQUERY_INSERT', 1);

if (!defined('DB_AUTOQUERY_UPDATE') ) define('DB_AUTOQUERY_UPDATE', 2);





// }}}

// {{{ portability modes





/**

 * Portability: turn off all portability features.

 * @see DB_common::setOption()

 */

define('DB_PORTABILITY_NONE', 0);



/**

 * Portability: convert names of tables and fields to lower case

 * when using the get*(), fetch*() and tableInfo() methods.

 * @see DB_common::setOption()

 */

define('DB_PORTABILITY_LOWERCASE', 1);



/**

 * Portability: right trim the data output by get*() and fetch*().

 * @see DB_common::setOption()

 */

define('DB_PORTABILITY_RTRIM', 2);



/**

 * Portability: force reporting the number of rows deleted.

 * @see DB_common::setOption()

 */

define('DB_PORTABILITY_DELETE_COUNT', 4);



/**

 * Portability: enable hack that makes numRows() work in Oracle.

 * @see DB_common::setOption()

 */

define('DB_PORTABILITY_NUMROWS', 8);



/**

 * Portability: makes certain error messages in certain drivers compatible

 * with those from other DBMS's.

 *

 * + mysql, mysqli:  change unique/primary key constraints

 *   DB_ERROR_ALREADY_EXISTS -> DB_ERROR_CONSTRAINT

 *

 * + odbc(access):  MS's ODBC driver reports 'no such field' as code

 *   07001, which means 'too few parameters.'  When this option is on

 *   that code gets mapped to DB_ERROR_NOSUCHFIELD.

 *

 * @see DB_common::setOption()

 */

define('DB_PORTABILITY_ERRORS', 16);



/**

 * Portability: convert null values to empty strings in data output by

 * get*() and fetch*().

 * @see DB_common::setOption()

 */

define('DB_PORTABILITY_NULL_TO_EMPTY', 32);



/**

 * Portability: turn on all portability features.

 * @see DB_common::setOption()

 */

define('DB_PORTABILITY_ALL', 63);



// }}}





// }}}

// {{{ class DB



/**

 * The main "DB" class is simply a container class with some static

 * methods for creating DB objects as well as some utility functions

 * common to all parts of DB.

 *

 * The object model of DB is as follows (indentation means inheritance):

 *

 * DB           The main DB class.  This is simply a utility class

 *              with some "static" methods for creating DB objects as

 *              well as common utility functions for other DB classes.

 *

 * DB_common    The base for each DB implementation.  Provides default

 * |            implementations (in OO lingo virtual methods) for

 * |            the actual DB implementations as well as a bunch of

 * |            query utility functions.

 * |

 * +-DB_mysql   The DB implementation for MySQL.  Inherits DB_common.

 *              When calling DB::factory or DB::connect for MySQL

 *              connections, the object returned is an instance of this

 *              class.

 *

 * @package  DB

 * @author   Stig Bakken <ssb@php.net>

 * @author   Tomas V.V.Cox <cox@idecnet.com>

 * @since    PHP 4.0

 * @version  $Id: DB.php,v 1.3 2005/07/22 05:10:13 max Exp $

 * @category Database

 */

class DB

{



    // {{{ &factory()



    /**

     * Create a new DB object for the specified database type.

     *

     * Allows creation of a DB_<driver> object from which the object's

     * methods can be utilized without actually connecting to a database.

     *

     * @param string $type    database type, for example "mysql"

     * @param array  $options associative array of option names and values

     *

     * @return object  a new DB object.  On error, an error object.

     *

     * @see DB_common::setOption()

     * @access public

     */

    function &factory($type, $options = false)

    {

        if (!is_array($options)) {

            $options = array('persistent' => $options);

        }



        if (isset($options['debug']) && $options['debug'] >= 2) {

            // expose php errors with sufficient debug level

            include_once PEAR_DIR . "DB/{$type}.php";

        } else {

            @include_once PEAR_DIR . "DB/{$type}.php";

        }



        $classname = "DB_${type}";



        if (!class_exists($classname)) {

            $tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null,

                                    "Unable to include the DB/{$type}.php file",

                                    'DB_Error', true);

            return $tmp;

        }



        @$obj =& new $classname;



        foreach ($options as $option => $value) {

            $test = $obj->setOption($option, $value);

            if (DB::isError($test)) {

                return $test;

            }

        }

        return $obj;

    }



    // }}}

    // {{{ &connect()



    /**

     * Create a new DB object and connect to the specified database.

     *

     * Example 1.

     * <code> <?php

     * require_once 'DB.php';

     *

     * $dsn = 'mysql://user:password@host/database'

     * $options = array(

     *     'debug'       => 2,

     *     'portability' => DB_PORTABILITY_ALL,

     * );

     *

     * $dbh =& DB::connect($dsn, $options);

     * if (DB::isError($dbh)) {

     *     die($dbh->getMessage());

     * }

     * ?></code>

     *

     * @param mixed $dsn      string "data source name" or an array in the

     *                        format returned by DB::parseDSN()

     *

     * @param array $options  an associative array of option names and

     *                        their values

     *

     * @return object  a newly created DB connection object, or a DB

     *                 error object on error

     *

     * @see DB::parseDSN(), DB_common::setOption(), DB::isError()

     * @access public

     */

    function &connect($dsn, $options = array())

    {

        $dsninfo = DB::parseDSN($dsn);

        $type = $dsninfo['phptype'];



        if (!is_array($options)) {

            /*

             * For backwards compatibility.  $options used to be boolean,

             * indicating whether the connection should be persistent.

             */

            $options = array('persistent' => $options);

        }



        if (isset($options['debug']) && $options['debug'] >= 2) {

            // expose php errors with sufficient debug level

            include_once PEAR_DIR . "DB/${type}.php";

        } else {

            @include_once PEAR_DIR . "DB/${type}.php";

        }



        $classname = "DB_${type}";

        if (!class_exists($classname)) {

            $tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null,

                                    "Unable to include the DB/{$type}.php file for `$dsn'",

                                    'DB_Error', true);

            return $tmp;

        }



        @$obj =& new $classname;



        foreach ($options as $option => $value) {

            $test = $obj->setOption($option, $value);

            if (DB::isError($test)) {

                return $test;

            }

        }



        $err = $obj->connect($dsninfo, $obj->getOption('persistent'));

        if (DB::isError($err)) {

            $err->addUserInfo($dsn);

            return $err;

        }



        return $obj;

    }



    // }}}

    // {{{ apiVersion()



    /**

     * Return the DB API version

     *

     * @return int the DB API version number

     *

     * @access public

     */

    function apiVersion()

    {

        return 2;

    }



    // }}}

    // {{{ isError()



    /**

     * Tell whether a result code from a DB method is an error

     *

     * @param int $value result code

     *

     * @return bool whether $value is an error

     *

     * @access public

     */

    function isError($value)

    {

        return is_a($value, 'DB_Error');

    }



    // }}}

    // {{{ isConnection()



    /**

     * Tell whether a value is a DB connection

     *

     * @param mixed $value value to test

     *

     * @return bool whether $value is a DB connection

     *

     * @access public

     */

    function isConnection($value)

    {

        return (is_object($value) &&

                is_subclass_of($value, 'db_common') &&

                method_exists($value, 'simpleQuery'));

    }



    // }}}

    // {{{ isManip()



    /**

     * Tell whether a query is a data manipulation query (insert,

     * update or delete) or a data definition query (create, drop,

     * alter, grant, revoke).

     *

     * @access public

     *

     * @param string $query the query

     *

     * @return boolean whether $query is a data manipulation query

     */

    function isManip($query)

    {

        $manips = 'INSERT|UPDATE|DELETE|LOAD DATA|'.'REPLACE|CREATE|DROP|'.

                  'ALTER|GRANT|REVOKE|'.'LOCK|UNLOCK';

        if (preg_match('/^\s*"?('.$manips.')\s+/i', $query)) {

            return true;

        }

        return false;

    }



    // }}}

    // {{{ errorMessage()



    /**

     * Return a textual error message for a DB error code

     *

     * @param integer $value error code

     *

     * @return string error message, or false if the error code was

     * not recognized

     */

    function errorMessage($value)

    {

        static $errorMessages;

        if (!isset($errorMessages)) {

            $errorMessages = array(

                DB_ERROR                    => 'unknown error',

                DB_ERROR_ALREADY_EXISTS     => 'already exists',

                DB_ERROR_CANNOT_CREATE      => 'can not create',

                DB_ERROR_CANNOT_DELETE      => 'can not delete',

                DB_ERROR_CANNOT_DROP        => 'can not drop',

                DB_ERROR_CONSTRAINT         => 'constraint violation',

                DB_ERROR_CONSTRAINT_NOT_NULL=> 'null value violates not-null constraint',

                DB_ERROR_DIVZERO            => 'division by zero',

                DB_ERROR_INVALID            => 'invalid',

                DB_ERROR_INVALID_DATE       => 'invalid date or time',

                DB_ERROR_INVALID_NUMBER     => 'invalid number',

                DB_ERROR_MISMATCH           => 'mismatch',

                DB_ERROR_NODBSELECTED       => 'no database selected',

                DB_ERROR_NOSUCHFIELD        => 'no such field',

                DB_ERROR_NOSUCHTABLE        => 'no such table',

                DB_ERROR_NOT_CAPABLE        => 'DB backend not capable',

                DB_ERROR_NOT_FOUND          => 'not found',

                DB_ERROR_NOT_LOCKED         => 'not locked',

                DB_ERROR_SYNTAX             => 'syntax error',

                DB_ERROR_UNSUPPORTED        => 'not supported',

                DB_ERROR_VALUE_COUNT_ON_ROW => 'value count on row',

                DB_ERROR_INVALID_DSN        => 'invalid DSN',

                DB_ERROR_CONNECT_FAILED     => 'connect failed',

                DB_OK                       => 'no error',

                DB_ERROR_NEED_MORE_DATA     => 'insufficient data supplied',

                DB_ERROR_EXTENSION_NOT_FOUND=> 'extension not found',

                DB_ERROR_NOSUCHDB           => 'no such database',

                DB_ERROR_ACCESS_VIOLATION   => 'insufficient permissions',

                DB_ERROR_TRUNCATED          => 'truncated'

            );

        }



        if (DB::isError($value)) {

            $value = $value->getCode();

        }



        return isset($errorMessages[$value]) ? $errorMessages[$value] : $errorMessages[DB_ERROR];

    }



    // }}}

    // {{{ parseDSN()



    /**

     * Parse a data source name.

     *

     * Additional keys can be added by appending a URI query string to the

     * end of the DSN.

     *

     * The format of the supplied DSN is in its fullest form:

     * <code>

     *  phptype(dbsyntax)://username:password@protocol+hostspec/database?option=8&another=true

     * </code>

     *

     * Most variations are allowed:

     * <code>

     *  phptype://username:password@protocol+hostspec:110//usr/db_file.db?mode=0644

     *  phptype://username:password@hostspec/database_name

     *  phptype://username:password@hostspec

     *  phptype://username@hostspec

     *  phptype://hostspec/database

     *  phptype://hostspec

     *  phptype(dbsyntax)

     *  phptype

     * </code>

     *

     * @param string $dsn Data Source Name to be parsed

     *

     * @return array an associative array with the following keys:

     *  + phptype:  Database backend used in PHP (mysql, odbc etc.)

     *  + dbsyntax: Database used with regards to SQL syntax etc.

     *  + protocol: Communication protocol to use (tcp, unix etc.)

     *  + hostspec: Host specification (hostname[:port])

     *  + database: Database to use on the DBMS server

     *  + username: User name for login

     *  + password: Password for login

     *

     * @author Tomas V.V.Cox <cox@idecnet.com>

     */

    function parseDSN($dsn)

    {



        $parsed = array(

            'phptype'  => false,

            'dbsyntax' => false,

            'username' => false,

            'password' => false,

            'protocol' => false,

            'hostspec' => false,

            'port'     => false,

            'socket'   => false,

            'database' => false,

        );

        if (is_array($dsn)) {

            $dsn = array_merge($parsed, $dsn);

            if (!$dsn['dbsyntax']) {

                $dsn['dbsyntax'] = $dsn['phptype'];

            }

            return $dsn;

        }



        // Find phptype and dbsyntax

        if (($pos = strpos($dsn, '://')) !== false) {

            $str = substr($dsn, 0, $pos);

            $dsn = substr($dsn, $pos + 3);

        } else {

            $str = $dsn;

            $dsn = null;

        }



        // Get phptype and dbsyntax

        // $str => phptype(dbsyntax)

        if (preg_match('|^(.+?)\((.*?)\)$|', $str, $arr)) {

            $parsed['phptype']  = $arr[1];

            $parsed['dbsyntax'] = !$arr[2] ? $arr[1] : $arr[2];

        } else {

            $parsed['phptype']  = $str;

            $parsed['dbsyntax'] = $str;

        }



        if (!count($dsn)) {

            return $parsed;

        }



        // Get (if found): username and password

        // $dsn => username:password@protocol+hostspec/database

        if (($at = strrpos($dsn,'@')) !== false) {

            $str = substr($dsn, 0, $at);

            $dsn = substr($dsn, $at + 1);

            if (($pos = strpos($str, ':')) !== false) {

                $parsed['username'] = rawurldecode(substr($str, 0, $pos));

                $parsed['password'] = rawurldecode(substr($str, $pos + 1));

            } else {

                $parsed['username'] = rawurldecode($str);

            }

        }



        // Find protocol and hostspec



        // $dsn => proto(proto_opts)/database

        if (preg_match('|^([^(]+)\((.*?)\)/?(.*?)$|', $dsn, $match)) {

            $proto       = $match[1];

            $proto_opts  = $match[2] ? $match[2] : false;

            $dsn         = $match[3];



        // $dsn => protocol+hostspec/database (old format)

        } else {

            if (strpos($dsn, '+') !== false) {

                list($proto, $dsn) = explode('+', $dsn, 2);

            }

            if (strpos($dsn, '/') !== false) {

                list($proto_opts, $dsn) = explode('/', $dsn, 2);

            } else {

                $proto_opts = $dsn;

                $dsn = null;

            }

        }



        // process the different protocol options

        $parsed['protocol'] = (!empty($proto)) ? $proto : 'tcp';

        $proto_opts = rawurldecode($proto_opts);

        if ($parsed['protocol'] == 'tcp') {

            if (strpos($proto_opts, ':') !== false) {

                list($parsed['hostspec'], $parsed['port']) = explode(':', $proto_opts);

            } else {

                $parsed['hostspec'] = $proto_opts;

            }

        } elseif ($parsed['protocol'] == 'unix') {

            $parsed['socket'] = $proto_opts;

        }



        // Get dabase if any

        // $dsn => database

        if ($dsn) {

            // /database

            if (($pos = strpos($dsn, '?')) === false) {

                $parsed['database'] = $dsn;

            // /database?param1=value1&param2=value2

            } else {

                $parsed['database'] = substr($dsn, 0, $pos);

                $dsn = substr($dsn, $pos + 1);

                if (strpos($dsn, '&') !== false) {

                    $opts = explode('&', $dsn);

                } else { // database?param1=value1

                    $opts = array($dsn);

                }

                foreach ($opts as $opt) {

                    list($key, $value) = explode('=', $opt);

                    if (!isset($parsed[$key])) {

                        // don't allow params overwrite

                        $parsed[$key] = rawurldecode($value);

                    }

                }

            }

        }

        return $parsed;

    }



    // }}}

    // {{{ assertExtension()



    /**

     * Load a PHP database extension if it is not loaded already.

     *

     * @access public

     *

     * @param string $name the base name of the extension (without the .so or

     *                     .dll suffix)

     *

     * @return boolean true if the extension was already or successfully

     *                 loaded, false if it could not be loaded

     */

    function assertExtension($name)

    {

        if (!extension_loaded($name)) {

            $dlext = OS_WINDOWS ? '.dll' : '.so';

            $dlprefix = OS_WINDOWS ? 'php_' : '';

            @dl($dlprefix . $name . $dlext);

            return extension_loaded($name);

        }

        return true;

    }

    // }}}

}



// }}}

// {{{ class DB_Error



/**

 * DB_Error implements a class for reporting portable database error

 * messages.

 *

 * @package  DB

 * @author Stig Bakken <ssb@php.net>

 */

class DB_Error extends PEAR_Error

{

    // {{{ constructor



    /**

     * DB_Error constructor.

     *

     * @param mixed   $code   DB error code, or string with error message.

     * @param integer $mode   what "error mode" to operate in

     * @param integer $level  what error level to use for $mode & PEAR_ERROR_TRIGGER

     * @param mixed   $debuginfo  additional debug info, such as the last query

     *

     * @access public

     *

     * @see PEAR_Error

     */

    function DB_Error($code = DB_ERROR, $mode = PEAR_ERROR_RETURN,

              $level = E_USER_NOTICE, $debuginfo = null)

    {

        if (is_int($code)) {

            $this->PEAR_Error('DB Error: ' . DB::errorMessage($code), $code, $mode, $level, $debuginfo);

        } else {

            $this->PEAR_Error("DB Error: $code", DB_ERROR, $mode, $level, $debuginfo);

        }

    }

    // }}}

}



// }}}

// {{{ class DB_result



/**

 * This class implements a wrapper for a DB result set.

 * A new instance of this class will be returned by the DB implementation

 * after processing a query that returns data.

 *

 * @package  DB

 * @author Stig Bakken <ssb@php.net>

 */

class DB_result

{

    // {{{ properties



    var $dbh;

    var $result;

    var $row_counter = null;



    /**

     * for limit queries, the row to start fetching

     * @var integer

     */

    var $limit_from  = null;



    /**

     * for limit queries, the number of rows to fetch

     * @var integer

     */

    var $limit_count = null;



    // }}}

    // {{{ constructor



    /**

     * DB_result constructor.

     * @param resource &$dbh   DB object reference

     * @param resource $result  result resource id

     * @param array    $options assoc array with optional result options

     */

    function DB_result(&$dbh, $result, $options = array())

    {

        $this->dbh = &$dbh;

        $this->result = $result;

        foreach ($options as $key => $value) {

            $this->setOption($key, $value);

        }

        $this->limit_type  = $dbh->features['limit'];

        $this->autofree    = $dbh->options['autofree'];

        $this->fetchmode   = $dbh->fetchmode;

        $this->fetchmode_object_class = $dbh->fetchmode_object_class;

    }



    function setOption($key, $value = null)

    {

        switch ($key) {

            case 'limit_from':

                $this->limit_from = $value; break;

            case 'limit_count':

                $this->limit_count = $value; break;

        }

    }



    // }}}

    // {{{ fetchRow()



    /**

     * Fetch a row of data and return it by reference into an array.

     *

     * The type of array returned can be controlled either by setting this

     * method's <var>$fetchmode</var> parameter or by changing the default

     * fetch mode setFetchMode() before calling this method.

     *

     * There are two options for standardizing the information returned

     * from databases, ensuring their values are consistent when changing

     * DBMS's.  These portability options can be turned on when creating a

     * new DB object or by using setOption().

     *

     *   + <samp>DB_PORTABILITY_LOWERCASE</samp>

     *     convert names of fields to lower case

     *

     *   + <samp>DB_PORTABILITY_RTRIM</samp>

     *     right trim the data

     *

     * @param int $fetchmode  how the resulting array should be indexed

     * @param int $rownum     the row number to fetch

     *

     * @return array  a row of data, null on no more rows or PEAR_Error

     *                object on error

     *

     * @see DB_common::setOption(), DB_common::setFetchMode()

     * @access public

     */

    function &fetchRow($fetchmode = DB_FETCHMODE_DEFAULT, $rownum=null)

    {

        if ($fetchmode === DB_FETCHMODE_DEFAULT) {

            $fetchmode = $this->fetchmode;

        }

        if ($fetchmode === DB_FETCHMODE_OBJECT) {

            $fetchmode = DB_FETCHMODE_ASSOC;

            $object_class = $this->fetchmode_object_class;

        }

        if ($this->limit_from !== null) {

            if ($this->row_counter === null) {

                $this->row_counter = $this->limit_from;

                // Skip rows

                if ($this->limit_type == false) {

                    $i = 0;

                    while ($i++ < $this->limit_from) {

                        $this->dbh->fetchInto($this->result, $arr, $fetchmode);

                    }

                }

            }

            if ($this->row_counter >= (

                    $this->limit_from + $this->limit_count))

            {

                if ($this->autofree) {

                    $this->free();

                }

                $tmp = null;

                return $tmp;

            }

            if ($this->limit_type == 'emulate') {

                $rownum = $this->row_counter;

            }

            $this->row_counter++;

        }

        $res = $this->dbh->fetchInto($this->result, $arr, $fetchmode, $rownum);

        if ($res === DB_OK) {

            if (isset($object_class)) {

                // default mode specified in DB_common::fetchmode_object_class property

                if ($object_class == 'stdClass') {

                    $arr = (object) $arr;

                } else {

                    $arr = &new $object_class($arr);

                }

            }

            return $arr;

        }

        if ($res == null && $this->autofree) {

            $this->free();

        }

        return $res;

    }



    // }}}

    // {{{ fetchInto()



    /**

     * Fetch a row of data into an array which is passed by reference.

     *

     * The type of array returned can be controlled either by setting this

     * method's <var>$fetchmode</var> parameter or by changing the default

     * fetch mode setFetchMode() before calling this method.

     *

     * There are two options for standardizing the information returned

     * from databases, ensuring their values are consistent when changing

     * DBMS's.  These portability options can be turned on when creating a

     * new DB object or by using setOption().

     *

     *   + <samp>DB_PORTABILITY_LOWERCASE</samp>

     *     convert names of fields to lower case

     *

     *   + <samp>DB_PORTABILITY_RTRIM</samp>

     *     right trim the data

     *

     * @param array &$arr       (reference) array where data from the row

     *                          should be placed

     * @param int   $fetchmode  how the resulting array should be indexed

     * @param int   $rownum     the row number to fetch

     *

     * @return mixed  DB_OK on success, null on no more rows or

     *                a DB_Error object on error

     *

     * @see DB_common::setOption(), DB_common::setFetchMode()

     * @access public

     */

    function fetchInto(&$arr, $fetchmode = DB_FETCHMODE_DEFAULT, $rownum=null)

    {

        if ($fetchmode === DB_FETCHMODE_DEFAULT) {

            $fetchmode = $this->fetchmode;

        }

        if ($fetchmode === DB_FETCHMODE_OBJECT) {

            $fetchmode = DB_FETCHMODE_ASSOC;

            $object_class = $this->fetchmode_object_class;

        }

        if ($this->limit_from !== null) {

            if ($this->row_counter === null) {

                $this->row_counter = $this->limit_from;

                // Skip rows

                if ($this->limit_type == false) {

                    $i = 0;

                    while ($i++ < $this->limit_from) {

                        $this->dbh->fetchInto($this->result, $arr, $fetchmode);

                    }

                }

            }

            if ($this->row_counter >= (

                    $this->limit_from + $this->limit_count))

            {

                if ($this->autofree) {

                    $this->free();

                }

                return null;

            }

            if ($this->limit_type == 'emulate') {

                $rownum = $this->row_counter;

            }



            $this->row_counter++;

        }

        $res = $this->dbh->fetchInto($this->result, $arr, $fetchmode, $rownum);

        if ($res === DB_OK) {

            if (isset($object_class)) {

                // default mode specified in DB_common::fetchmode_object_class property

                if ($object_class == 'stdClass') {

                    $arr = (object) $arr;

                } else {

                    $arr = new $object_class($arr);

                }

            }

            return DB_OK;

        }

        if ($res == null && $this->autofree) {

            $this->free();

        }

        return $res;

    }



    // }}}

    // {{{ numCols()



    /**

     * Get the the number of columns in a result set.

     *

     * @return int the number of columns, or a DB error

     *

     * @access public

     */

    function numCols()

    {

        return $this->dbh->numCols($this->result);

    }



    // }}}

    // {{{ numRows()



    /**

     * Get the number of rows in a result set.

     *

     * @return int the number of rows, or a DB error

     *

     * @access public

     */

    function numRows()

    {

        return $this->dbh->numRows($this->result);

    }



    // }}}

    // {{{ nextResult()



    /**

     * Get the next result if a batch of queries was executed.

     *

     * @return bool true if a new result is available or false if not.

     *

     * @access public

     */

    function nextResult()

    {

        return $this->dbh->nextResult($this->result);

    }



    // }}}

    // {{{ free()



    /**

     * Frees the resources allocated for this result set.

     * @return  int error code

     *

     * @access public

     */

    function free()

    {

        $err = $this->dbh->freeResult($this->result);

        if (DB::isError($err)) {

            return $err;

        }

        $this->result = false;

        return true;

    }



    // }}}

    // {{{ tableInfo()



    /**

     * @deprecated

     * @internal

     * @see DB_common::tableInfo()

     */

    function tableInfo($mode = null)

    {

        if (is_string($mode)) {

            return $this->dbh->raiseError(DB_ERROR_NEED_MORE_DATA);

        }

        return $this->dbh->tableInfo($this, $mode);

    }



    // }}}

    // {{{ getRowCounter()



    /**

     * returns the actual row number

     * @return integer

     */

    function getRowCounter()

    {

        return $this->row_counter;

    }

    // }}}

}



// }}}

// {{{ class DB_row



/**

 * Pear DB Row Object

 * @see DB_common::setFetchMode()

 */

class DB_row

{

    // {{{ constructor



    /**

     * constructor

     *

     * @param resource row data as array

     */

    function DB_row(&$arr)

    {

        foreach ($arr as $key => $value) {

            $this->$key = &$arr[$key];

        }

    }



    // }}}

}



// }}}



/*

 * Local variables:

 * tab-width: 4

 * c-basic-offset: 4

 * End:

 */



?>

Open in new window

0
Comment
Question by:omegalove
2 Comments
 
LVL 2

Accepted Solution

by:
Nol888 earned 500 total points
ID: 33538989
PHP 5 changed the behavior for classes; all classes are now passed by reference by default. To get rid of the error either change the `=&' to just `=' or remove the E_STRICT tag from your error_reporting value.
0
 

Author Closing Comment

by:omegalove
ID: 33539198
awesome
0

Featured Post

Why You Should Analyze Threat Actor TTPs

After years of analyzing threat actor behavior, it’s become clear that at any given time there are specific tactics, techniques, and procedures (TTPs) that are particularly prevalent. By analyzing and understanding these TTPs, you can dramatically enhance your security program.

Join & Write a Comment

Suggested Solutions

Password hashing is better than message digests or encryption, and you should be using it instead of message digests or encryption.  Find out why and how in this article, which supplements the original article on PHP Client Registration, Login, Logo…
Since pre-biblical times, humans have sought ways to keep secrets, and share the secrets selectively.  This article explores the ways PHP can be used to hide and encrypt information.
Learn how to match and substitute tagged data using PHP regular expressions. Demonstrated on Windows 7, but also applies to other operating systems. Demonstrated technique applies to PHP (all versions) and Firefox, but very similar techniques will w…
The viewer will learn how to create and use a small PHP class to apply a watermark to an image. This video shows the viewer the setup for the PHP watermark as well as important coding language. Continue to Part 2 to learn the core code used in creat…

706 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question

Need Help in Real-Time?

Connect with top rated Experts

11 Experts available now in Live!

Get 1:1 Help Now