Teino1978-Corp/owncloud_.htaccess

	ErrorDocument 404 /owncloud/core/templates/404.php
	<IfModule mod_php5.c>
	php_value upload_max_filesize 512M
	php_value post_max_size 512M
	php_value memory_limit 128M
	SetEnv htaccessWorking true
	</IfModule>
	Options -Indexes
	<?xml version="1.0" encoding="UTF-8"?>
	<project version="4">
	<component name="Encoding" useUTFGuessing="true" native2AsciiForPropertiesFiles="false" />
	</project>
	<?xml version="1.0" encoding="UTF-8"?>
	<project version="4">
	<component name="ProjectRootManager" version="2" />
	<component name="SvnConfiguration" maxAnnotateRevisions="500" myUseAcceleration="nothing" myAutoUpdateAfterCommit="false" cleanupOnStartRun="false" SSL_PROTOCOLS="sslv3">
	<option name="USER" value="" />
	<option name="PASSWORD" value="" />
	<option name="mySSHConnectionTimeout" value="30000" />
	<option name="mySSHReadTimeout" value="30000" />
	<option name="LAST_MERGED_REVISION" />
	<option name="MERGE_DRY_RUN" value="false" />
	<option name="MERGE_DIFF_USE_ANCESTRY" value="true" />
	<option name="UPDATE_LOCK_ON_DEMAND" value="false" />
	<option name="IGNORE_SPACES_IN_MERGE" value="false" />
	<option name="CHECK_NESTED_FOR_QUICK_MERGE" value="false" />
	<option name="IGNORE_SPACES_IN_ANNOTATE" value="true" />
	<option name="SHOW_MERGE_SOURCES_IN_ANNOTATE" value="true" />
	<option name="FORCE_UPDATE" value="false" />
	<option name="IGNORE_EXTERNALS" value="false" />
	<configuration useDefault="false">$USER_HOME$/.subversion</configuration>
	<myIsUseDefaultProxy>false</myIsUseDefaultProxy>
	</component>
	</project>
	<?xml version="1.0" encoding="UTF-8"?>
	<project version="4">
	<component name="ProjectModuleManager">
	<modules>
	<module fileurl="file://$PROJECT_DIR$/.idea/owncloud.iml" filepath="$PROJECT_DIR$/.idea/owncloud.iml" />
	</modules>
	</component>
	</project>
	<?xml version="1.0" encoding="UTF-8"?>
	<module type="WEB_MODULE" version="4">
	<component name="NewModuleRootManager">
	<content url="file://$MODULE_DIR$" />
	<orderEntry type="inheritedJdk" />
	<orderEntry type="sourceFolder" forTests="false" />
	</component>
	</module>
	<component name="DependencyValidationManager">
	<state>
	<option name="SKIP_IMPORT_STATEMENTS" value="false" />
	</state>
	</component>
	<?xml version="1.0" encoding="UTF-8"?>
	<project version="4">
	<component name="VcsDirectoryMappings">
	<mapping directory="" vcs="" />
	</component>
	</project>
	<?php
	/* vim: set expandtab tabstop=4 shiftwidth=4: */
	// +----------------------------------------------------------------------+
	// \| PHP Version 4 \|
	// +----------------------------------------------------------------------+
	// \| Copyright (c) 1997-2003 The PHP Group \|
	// +----------------------------------------------------------------------+
	// \| This source file is subject to version 3.0 of the PHP license, \|
	// \| that is bundled with this package in the file LICENSE, and is \|
	// \| available through the world-wide-web at the following url: \|
	// \| http://www.php.net/license/3_0.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. \|
	// +----------------------------------------------------------------------+
	// \| Author: Andrei Zmievski <andrei@php.net> \|
	// +----------------------------------------------------------------------+
	//
	// $Id: Getopt.php,v 1.21.4.7 2003/12/05 21:57:01 andrei Exp $

	require_once( 'PEAR.php');

	/**
	* Command-line options parsing class.
	*
	* @author Andrei Zmievski <andrei@php.net>
	*
	*/
	class Console_Getopt {
	/**
	* Parses the command-line options.
	*
	* The first parameter to this function should be the list of command-line
	* arguments without the leading reference to the running program.
	*
	* The second parameter is a string of allowed short options. Each of the
	* option letters can be followed by a colon ':' to specify that the option
	* requires an argument, or a double colon '::' to specify that the option
	* takes an optional argument.
	*
	* The third argument is an optional array of allowed long options. The
	* leading '--' should not be included in the option name. Options that
	* require an argument should be followed by '=', and options that take an
	* option argument should be followed by '=='.
	*
	* The return value is an array of two elements: the list of parsed
	* options and the list of non-option command-line arguments. Each entry in
	* the list of parsed options is a pair of elements - the first one
	* specifies the option, and the second one specifies the option argument,
	* if there was one.
	*
	* Long and short options can be mixed.
	*
	* Most of the semantics of this function are based on GNU getopt_long().
	*
	* @param array $args an array of command-line arguments
	* @param string $short_options specifies the list of allowed short options
	* @param array $long_options specifies the list of allowed long options
	*
	* @return array two-element array containing the list of parsed options and
	* the non-option arguments
	*
	* @access public
	*
	*/
	function getopt2($args, $short_options, $long_options = null)
	{
	return Console_Getopt::doGetopt(2, $args, $short_options, $long_options);
	}

	/**
	* This function expects $args to start with the script name (POSIX-style).
	* Preserved for backwards compatibility.
	* @see getopt2()
	*/
	function getopt($args, $short_options, $long_options = null)
	{
	return Console_Getopt::doGetopt(1, $args, $short_options, $long_options);
	}

	/**
	* The actual implementation of the argument parsing code.
	*/
	function doGetopt($version, $args, $short_options, $long_options = null)
	{
	// in case you pass directly readPHPArgv() as the first arg
	if (PEAR::isError($args)) {
	return $args;
	}
	if (empty($args)) {
	return array(array(), array());
	}
	$opts = array();
	$non_opts = array();

	settype($args, 'array');

	if ($long_options) {
	sort($long_options);
	}

	/*
	* Preserve backwards compatibility with callers that relied on
	* erroneous POSIX fix.
	*/
	if ($version < 2) {
	if (isset($args[0]{0}) && $args[0]{0} != '-') {
	array_shift($args);
	}
	}

	reset($args);
	while (list($i, $arg) = each($args)) {

	/* The special element '--' means explicit end of
	options. Treat the rest of the arguments as non-options
	and end the loop. */
	if ($arg == '--') {
	$non_opts = array_merge($non_opts, array_slice($args, $i + 1));
	break;
	}

	if ($arg{0} != '-' \|\| (strlen($arg) > 1 && $arg{1} == '-' && !$long_options)) {
	$non_opts = array_merge($non_opts, array_slice($args, $i));
	break;
	} elseif (strlen($arg) > 1 && $arg{1} == '-') {
	$error = Console_Getopt::_parseLongOption(substr($arg, 2), $long_options, $opts, $args);
	if (PEAR::isError($error))
	return $error;
	} else {
	$error = Console_Getopt::_parseShortOption(substr($arg, 1), $short_options, $opts, $args);
	if (PEAR::isError($error))
	return $error;
	}
	}

	return array($opts, $non_opts);
	}

	/**
	* @access private
	*
	*/
	function _parseShortOption($arg, $short_options, &$opts, &$args)
	{
	for ($i = 0; $i < strlen($arg); $i++) {
	$opt = $arg{$i};
	$opt_arg = null;

	/* Try to find the short option in the specifier string. */
	if (($spec = strstr($short_options, $opt)) === false \|\| $arg{$i} == ':')
	{
	return PEAR::raiseError("Console_Getopt: unrecognized option -- $opt");
	}

	if (strlen($spec) > 1 && $spec{1} == ':') {
	if (strlen($spec) > 2 && $spec{2} == ':') {
	if ($i + 1 < strlen($arg)) {
	/* Option takes an optional argument. Use the remainder of
	the arg string if there is anything left. */
	$opts[] = array($opt, substr($arg, $i + 1));
	break;
	}
	} else {
	/* Option requires an argument. Use the remainder of the arg
	string if there is anything left. */
	if ($i + 1 < strlen($arg)) {
	$opts[] = array($opt, substr($arg, $i + 1));
	break;
	} else if (list(, $opt_arg) = each($args))
	/* Else use the next argument. */;
	else
	return PEAR::raiseError("Console_Getopt: option requires an argument -- $opt");
	}
	}

	$opts[] = array($opt, $opt_arg);
	}
	}

	/**
	* @access private
	*
	*/
	function _parseLongOption($arg, $long_options, &$opts, &$args)
	{
	@list($opt, $opt_arg) = explode('=', $arg);
	$opt_len = strlen($opt);

	for ($i = 0; $i < count($long_options); $i++) {
	$long_opt = $long_options[$i];
	$opt_start = substr($long_opt, 0, $opt_len);

	/* Option doesn't match. Go on to the next one. */
	if ($opt_start != $opt)
	continue;

	$opt_rest = substr($long_opt, $opt_len);

	/* Check that the options uniquely matches one of the allowed
	options. */
	if ($opt_rest != '' && $opt{0} != '=' &&
	$i + 1 < count($long_options) &&
	$opt == substr($long_options[$i+1], 0, $opt_len)) {
	return PEAR::raiseError("Console_Getopt: option --$opt is ambiguous");
	}

	if (substr($long_opt, -1) == '=') {
	if (substr($long_opt, -2) != '==') {
	/* Long option requires an argument.
	Take the next argument if one wasn't specified. */;
	if (!strlen($opt_arg) && !(list(, $opt_arg) = each($args))) {
	return PEAR::raiseError("Console_Getopt: option --$opt requires an argument");
	}
	}
	} else if ($opt_arg) {
	return PEAR::raiseError("Console_Getopt: option --$opt doesn't allow an argument");
	}

	$opts[] = array('--' . $opt, $opt_arg);
	return;
	}

	return PEAR::raiseError("Console_Getopt: unrecognized option --$opt");
	}

	/**
	* Safely read the $argv PHP array across different PHP configurations.
	* Will take care on register_globals and register_argc_argv ini directives
	*
	* @access public
	* @return mixed the $argv PHP array or PEAR error if not registered
	*/
	function readPHPArgv()
	{
	global $argv;
	if (!is_array($argv)) {
	if (!@is_array($_SERVER['argv'])) {
	if (!@is_array($GLOBALS['HTTP_SERVER_VARS']['argv'])) {
	return PEAR::raiseError("Console_Getopt: Could not read cmd args (register_argc_argv=Off?)");
	}
	return $GLOBALS['HTTP_SERVER_VARS']['argv'];
	}
	return $_SERVER['argv'];
	}
	return $argv;
	}

	}

	?>
	<?php
	/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

	/**
	* Crypt_Blowfish allows for encryption and decryption on the fly using
	* the Blowfish algorithm. Crypt_Blowfish does not require the mcrypt
	* PHP extension, it uses only PHP.
	* Crypt_Blowfish support encryption/decryption with or without a secret key.
	*
	*
	* PHP versions 4 and 5
	*
	* LICENSE: This source file is subject to version 3.0 of the PHP license
	* that is available through the world-wide-web at the following URI:
	* http://www.php.net/license/3_0.txt. If you did not receive a copy of
	* the PHP License and are unable to obtain it through the web, please
	* send a note to license@php.net so we can mail you a copy immediately.
	*
	* @category Encryption
	* @package Crypt_Blowfish
	* @author Matthew Fonda <mfonda@php.net>
	* @copyright 2005 Matthew Fonda
	* @license http://www.php.net/license/3_0.txt PHP License 3.0
	* @version CVS: $Id: Blowfish.php,v 1.81 2005/05/30 18:40:36 mfonda Exp $
	* @link http://pear.php.net/package/Crypt_Blowfish
	*/


	require_once 'PEAR.php';


	/**
	*
	* Example usage:
	* $bf = new Crypt_Blowfish('some secret key!');
	* $encrypted = $bf->encrypt('this is some example plain text');
	* $plaintext = $bf->decrypt($encrypted);
	* echo "plain text: $plaintext";
	*
	*
	* @category Encryption
	* @package Crypt_Blowfish
	* @author Matthew Fonda <mfonda@php.net>
	* @copyright 2005 Matthew Fonda
	* @license http://www.php.net/license/3_0.txt PHP License 3.0
	* @link http://pear.php.net/package/Crypt_Blowfish
	* @version @package_version@
	* @access public
	*/
	class Crypt_Blowfish
	{
	/**
	* P-Array contains 18 32-bit subkeys
	*
	* @var array
	* @access private
	*/
	var $_P = array();


	/**
	* Array of four S-Blocks each containing 256 32-bit entries
	*
	* @var array
	* @access private
	*/
	var $_S = array();

	/**
	* Mcrypt td resource
	*
	* @var resource
	* @access private
	*/
	var $_td = null;

	/**
	* Initialization vector
	*
	* @var string
	* @access private
	*/
	var $_iv = null;


	/**
	* Crypt_Blowfish Constructor
	* Initializes the Crypt_Blowfish object, and gives a sets
	* the secret key
	*
	* @param string $key
	* @access public
	*/
	function Crypt_Blowfish($key)
	{
	if (extension_loaded('mcrypt')) {
	$this->_td = mcrypt_module_open(MCRYPT_BLOWFISH, '', 'ecb', '');
	$this->_iv = mcrypt_create_iv(8, MCRYPT_RAND);
	}
	$this->setKey($key);
	}

	/**
	* Deprecated isReady method
	*
	* @return bool
	* @access public
	* @deprecated
	*/
	function isReady()
	{
	return true;
	}

	/**
	* Deprecated init method - init is now a private
	* method and has been replaced with _init
	*
	* @return bool
	* @access public
	* @deprecated
	* @see Crypt_Blowfish::_init()
	*/
	function init()
	{
	$this->_init();
	}

	/**
	* Initializes the Crypt_Blowfish object
	*
	* @access private
	*/
	function _init()
	{
	$defaults = new Crypt_Blowfish_DefaultKey();
	$this->_P = $defaults->P;
	$this->_S = $defaults->S;
	}

	/**
	* Enciphers a single 64 bit block
	*
	* @param int &$Xl
	* @param int &$Xr
	* @access private
	*/
	function _encipher(&$Xl, &$Xr)
	{
	for ($i = 0; $i < 16; $i++) {
	$temp = $Xl ^ $this->_P[$i];
	$Xl = ((($this->_S[0][($temp>>24) & 255] +
	$this->_S[1][($temp>>16) & 255]) ^
	$this->_S[2][($temp>>8) & 255]) +
	$this->_S[3][$temp & 255]) ^ $Xr;
	$Xr = $temp;
	}
	$Xr = $Xl ^ $this->_P[16];
	$Xl = $temp ^ $this->_P[17];
	}


	/**
	* Deciphers a single 64 bit block
	*
	* @param int &$Xl
	* @param int &$Xr
	* @access private
	*/
	function _decipher(&$Xl, &$Xr)
	{
	for ($i = 17; $i > 1; $i--) {
	$temp = $Xl ^ $this->_P[$i];
	$Xl = ((($this->_S[0][($temp>>24) & 255] +
	$this->_S[1][($temp>>16) & 255]) ^
	$this->_S[2][($temp>>8) & 255]) +
	$this->_S[3][$temp & 255]) ^ $Xr;
	$Xr = $temp;
	}
	$Xr = $Xl ^ $this->_P[1];
	$Xl = $temp ^ $this->_P[0];
	}


	/**
	* Encrypts a string
	*
	* @param string $plainText
	* @return string Returns cipher text on success, PEAR_Error on failure
	* @access public
	*/
	function encrypt($plainText)
	{
	if (!is_string($plainText)) {
	PEAR::raiseError('Plain text must be a string', 0, PEAR_ERROR_DIE);
	}

	if (extension_loaded('mcrypt')) {
	return mcrypt_generic($this->_td, $plainText);
	}

	$cipherText = '';
	$len = strlen($plainText);
	$plainText .= str_repeat(chr(0),(8 - ($len%8))%8);
	for ($i = 0; $i < $len; $i += 8) {
	list(,$Xl,$Xr) = unpack("N2",substr($plainText,$i,8));
	$this->_encipher($Xl, $Xr);
	$cipherText .= pack("N2", $Xl, $Xr);
	}
	return $cipherText;
	}


	/**
	* Decrypts an encrypted string
	*
	* @param string $cipherText
	* @return string Returns plain text on success, PEAR_Error on failure
	* @access public
	*/
	function decrypt($cipherText)
	{
	if (!is_string($cipherText)) {
	PEAR::raiseError('Chiper text must be a string', 1, PEAR_ERROR_DIE);
	}

	if (extension_loaded('mcrypt')) {
	return mdecrypt_generic($this->_td, $cipherText);
	}

	$plainText = '';
	$len = strlen($cipherText);
	$cipherText .= str_repeat(chr(0),(8 - ($len%8))%8);
	for ($i = 0; $i < $len; $i += 8) {
	list(,$Xl,$Xr) = unpack("N2",substr($cipherText,$i,8));
	$this->_decipher($Xl, $Xr);
	$plainText .= pack("N2", $Xl, $Xr);
	}
	return $plainText;
	}


	/**
	* Sets the secret key
	* The key must be non-zero, and less than or equal to
	* 56 characters in length.
	*
	* @param string $key
	* @return bool Returns true on success, PEAR_Error on failure
	* @access public
	*/
	function setKey($key)
	{
	if (!is_string($key)) {
	PEAR::raiseError('Key must be a string', 2, PEAR_ERROR_DIE);
	}

	$len = strlen($key);

	if ($len > 56 \|\| $len == 0) {
	PEAR::raiseError('Key must be less than 56 characters and non-zero. Supplied key length: ' . $len, 3, PEAR_ERROR_DIE);
	}

	if (extension_loaded('mcrypt')) {
	mcrypt_generic_init($this->_td, $key, $this->_iv);
	return true;
	}

	require_once 'Blowfish/DefaultKey.php';
	$this->_init();

	$k = 0;
	$data = 0;
	$datal = 0;
	$datar = 0;

	for ($i = 0; $i < 18; $i++) {
	$data = 0;
	for ($j = 4; $j > 0; $j--) {
	$data = $data << 8 \| ord($key{$k});
	$k = ($k+1) % $len;
	}
	$this->_P[$i] ^= $data;
	}

	for ($i = 0; $i <= 16; $i += 2) {
	$this->_encipher($datal, $datar);
	$this->_P[$i] = $datal;
	$this->_P[$i+1] = $datar;
	}
	for ($i = 0; $i < 256; $i += 2) {
	$this->_encipher($datal, $datar);
	$this->_S[0][$i] = $datal;
	$this->_S[0][$i+1] = $datar;
	}
	for ($i = 0; $i < 256; $i += 2) {
	$this->_encipher($datal, $datar);
	$this->_S[1][$i] = $datal;
	$this->_S[1][$i+1] = $datar;
	}
	for ($i = 0; $i < 256; $i += 2) {
	$this->_encipher($datal, $datar);
	$this->_S[2][$i] = $datal;
	$this->_S[2][$i+1] = $datar;
	}
	for ($i = 0; $i < 256; $i += 2) {
	$this->_encipher($datal, $datar);
	$this->_S[3][$i] = $datal;
	$this->_S[3][$i+1] = $datar;
	}

	return true;
	}

	}

	?>
	<?php
	// +----------------------------------------------------------------------+
	// \| PHP versions 4 and 5 \|
	// +----------------------------------------------------------------------+
	// \| Copyright (c) 1998-2006 Manuel Lemos, Tomas V.V.Cox, \|
	// \| Stig. S. Bakken, Lukas Smith \|
	// \| All rights reserved. \|
	// +----------------------------------------------------------------------+
	// \| MDB2 is a merge of PEAR DB and Metabases that provides a unified DB \|
	// \| API as well as database abstraction for PHP applications. \|
	// \| This LICENSE is in the BSD license style. \|
	// \| \|
	// \| Redistribution and use in source and binary forms, with or without \|
	// \| modification, are permitted provided that the following conditions \|
	// \| are met: \|
	// \| \|
	// \| Redistributions of source code must retain the above copyright \|
	// \| notice, this list of conditions and the following disclaimer. \|
	// \| \|
	// \| Redistributions in binary form must reproduce the above copyright \|
	// \| notice, this list of conditions and the following disclaimer in the \|
	// \| documentation and/or other materials provided with the distribution. \|
	// \| \|
	// \| Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken, \|
	// \| Lukas Smith nor the names of his contributors may be used to endorse \|
	// \| or promote products derived from this software without specific prior\|
	// \| written permission. \|
	// \| \|
	// \| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \|
	// \| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \|
	// \| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS \|
	// \| FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \|
	// \| REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \|
	// \| INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, \|
	// \| BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS\|
	// \| OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED \|
	// \| AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT \|
	// \| LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY\|
	// \| WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \|
	// \| POSSIBILITY OF SUCH DAMAGE. \|
	// +----------------------------------------------------------------------+
	// \| Author: Lukas Smith <smith@pooteeweet.org> \|
	// +----------------------------------------------------------------------+
	//
	// $Id: Date.php,v 1.10 2006/03/01 12:15:32 lsmith Exp $
	//

	/**
	* @package MDB2
	* @category Database
	* @author Lukas Smith <smith@pooteeweet.org>
	*/

	/**
	* Several methods to convert the MDB2 native timestamp format (ISO based)
	* to and from data structures that are convenient to worth with in side of php.
	* For more complex date arithmetic please take a look at the Date package in PEAR
	*
	* @package MDB2
	* @category Database
	* @author Lukas Smith <smith@pooteeweet.org>
	*/
	class MDB2_Date
	{
	// {{{ mdbNow()

	/**
	* return the current datetime
	*
	* @return string current datetime in the MDB2 format
	* @access public
	*/
	function mdbNow()
	{
	return date('Y-m-d H:i:s');
	}
	// }}}

	// {{{ mdbToday()

	/**
	* return the current date
	*
	* @return string current date in the MDB2 format
	* @access public
	*/
	function mdbToday()
	{
	return date('Y-m-d');
	}
	// }}}

	// {{{ mdbTime()

	/**
	* return the current time
	*
	* @return string current time in the MDB2 format
	* @access public
	*/
	function mdbTime()
	{
	return date('H:i:s');
	}
	// }}}

	// {{{ date2Mdbstamp()

	/**
	* convert a date into a MDB2 timestamp
	*
	* @param int hour of the date
	* @param int minute of the date
	* @param int second of the date
	* @param int month of the date
	* @param int day of the date
	* @param int year of the date
	*
	* @return string a valid MDB2 timestamp
	* @access public
	*/
	function date2Mdbstamp($hour = null, $minute = null, $second = null,
	$month = null, $day = null, $year = null)
	{
	return MDB2_Date::unix2Mdbstamp(mktime($hour, $minute, $second, $month, $day, $year, -1));
	}
	// }}}

	// {{{ unix2Mdbstamp()

	/**
	* convert a unix timestamp into a MDB2 timestamp
	*
	* @param int a valid unix timestamp
	*
	* @return string a valid MDB2 timestamp
	* @access public
	*/
	function unix2Mdbstamp($unix_timestamp)
	{
	return date('Y-m-d H:i:s', $unix_timestamp);
	}
	// }}}

	// {{{ mdbstamp2Unix()

	/**
	* convert a MDB2 timestamp into a unix timestamp
	*
	* @param int a valid MDB2 timestamp
	* @return string unix timestamp with the time stored in the MDB2 format
	*
	* @access public
	*/
	function mdbstamp2Unix($mdb_timestamp)
	{
	$arr = MDB2_Date::mdbstamp2Date($mdb_timestamp);

	return mktime($arr['hour'], $arr['minute'], $arr['second'], $arr['month'], $arr['day'], $arr['year'], -1);
	}
	// }}}

	// {{{ mdbstamp2Date()

	/**
	* convert a MDB2 timestamp into an array containing all
	* values necessary to pass to php's date() function
	*
	* @param int a valid MDB2 timestamp
	*
	* @return array with the time split
	* @access public
	*/
	function mdbstamp2Date($mdb_timestamp)
	{
	list($arr['year'], $arr['month'], $arr['day'], $arr['hour'], $arr['minute'], $arr['second']) =
	sscanf($mdb_timestamp, "%04u-%02u-%02u %02u:%02u:%02u");
	return $arr;
	}
	// }}}
	}

	?>