411 lines
15 KiB
PHP
411 lines
15 KiB
PHP
<?php
|
|
/**
|
|
* Zend Framework
|
|
*
|
|
* LICENSE
|
|
*
|
|
* This source file is subject to the new BSD license that is bundled
|
|
* with this package in the file LICENSE.txt.
|
|
* It is also available through the world-wide-web at this URL:
|
|
* http://framework.zend.com/license/new-bsd
|
|
* If you did not receive a copy of the license and are unable to
|
|
* obtain it through the world-wide-web, please send an email
|
|
* to license@zend.com so we can send you a copy immediately.
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Ldap
|
|
* @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
* @version $Id$
|
|
*/
|
|
|
|
/**
|
|
* Zend_Ldap_Converter is a collection of useful LDAP related conversion functions.
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Ldap
|
|
* @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
*/
|
|
class Zend_Ldap_Converter
|
|
{
|
|
const STANDARD = 0;
|
|
const BOOLEAN = 1;
|
|
const GENERALIZED_TIME = 2;
|
|
|
|
/**
|
|
* Converts all ASCII chars < 32 to "\HEX"
|
|
*
|
|
* @see Net_LDAP2_Util::asc2hex32() from Benedikt Hallinger <beni@php.net>
|
|
* @link http://pear.php.net/package/Net_LDAP2
|
|
* @author Benedikt Hallinger <beni@php.net>
|
|
*
|
|
* @param string $string String to convert
|
|
* @return string
|
|
*/
|
|
public static function ascToHex32($string)
|
|
{
|
|
for ($i = 0; $i<strlen($string); $i++) {
|
|
$char = substr($string, $i, 1);
|
|
if (ord($char)<32) {
|
|
$hex = dechex(ord($char));
|
|
if (strlen($hex) == 1) $hex = '0' . $hex;
|
|
$string = str_replace($char, '\\' . $hex, $string);
|
|
}
|
|
}
|
|
return $string;
|
|
}
|
|
|
|
/**
|
|
* Converts all Hex expressions ("\HEX") to their original ASCII characters
|
|
*
|
|
* @see Net_LDAP2_Util::hex2asc() from Benedikt Hallinger <beni@php.net>,
|
|
* heavily based on work from DavidSmith@byu.net
|
|
* @link http://pear.php.net/package/Net_LDAP2
|
|
* @author Benedikt Hallinger <beni@php.net>, heavily based on work from DavidSmith@byu.net
|
|
*
|
|
* @param string $string String to convert
|
|
* @return string
|
|
*/
|
|
public static function hex32ToAsc($string)
|
|
{
|
|
// Using a callback, since PHP 5.5 has deprecated the /e modifier in preg_replace.
|
|
$string = preg_replace_callback("/\\\([0-9A-Fa-f]{2})/", array('Zend_Ldap_Converter', '_charHex32ToAsc'), $string);
|
|
return $string;
|
|
}
|
|
|
|
/**
|
|
* Convert a single slash-prefixed character from Hex32 to ASCII.
|
|
* Used as a callback in @see hex32ToAsc()
|
|
* @param array $matches
|
|
*
|
|
* @return string
|
|
*/
|
|
private static function _charHex32ToAsc(array $matches)
|
|
{
|
|
return chr(hexdec($matches[0]));
|
|
}
|
|
|
|
/**
|
|
* Convert any value to an LDAP-compatible value.
|
|
*
|
|
* By setting the <var>$type</var>-parameter the conversion of a certain
|
|
* type can be forced
|
|
*
|
|
* @todo write more tests
|
|
*
|
|
* @param mixed $value The value to convert
|
|
* @param int $ytpe The conversion type to use
|
|
* @return string
|
|
* @throws Zend_Ldap_Converter_Exception
|
|
*/
|
|
public static function toLdap($value, $type = self::STANDARD)
|
|
{
|
|
try {
|
|
switch ($type) {
|
|
case self::BOOLEAN:
|
|
return self::toldapBoolean($value);
|
|
break;
|
|
case self::GENERALIZED_TIME:
|
|
return self::toLdapDatetime($value);
|
|
break;
|
|
default:
|
|
if (is_string($value)) {
|
|
return $value;
|
|
} else if (is_int($value) || is_float($value)) {
|
|
return (string)$value;
|
|
} else if (is_bool($value)) {
|
|
return self::toldapBoolean($value);
|
|
} else if (is_object($value)) {
|
|
if ($value instanceof DateTime) {
|
|
return self::toLdapDatetime($value);
|
|
} else if ($value instanceof Zend_Date) {
|
|
return self::toLdapDatetime($value);
|
|
} else {
|
|
return self::toLdapSerialize($value);
|
|
}
|
|
} else if (is_array($value)) {
|
|
return self::toLdapSerialize($value);
|
|
} else if (is_resource($value) && get_resource_type($value) === 'stream') {
|
|
return stream_get_contents($value);
|
|
} else {
|
|
return null;
|
|
}
|
|
break;
|
|
}
|
|
} catch (Exception $e) {
|
|
throw new Zend_Ldap_Converter_Exception($e->getMessage(), $e->getCode(), $e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts a date-entity to an LDAP-compatible date-string
|
|
*
|
|
* The date-entity <var>$date</var> can be either a timestamp, a
|
|
* DateTime Object, a string that is parseable by strtotime() or a Zend_Date
|
|
* Object.
|
|
*
|
|
* @param integer|string|DateTimt|Zend_Date $date The date-entity
|
|
* @param boolean $asUtc Whether to return the LDAP-compatible date-string
|
|
* as UTC or as local value
|
|
* @return string
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
public static function toLdapDateTime($date, $asUtc = true)
|
|
{
|
|
if (!($date instanceof DateTime)) {
|
|
if (is_int($date)) {
|
|
$date = new DateTime('@' . $date);
|
|
$date->setTimezone(new DateTimeZone(date_default_timezone_get()));
|
|
} else if (is_string($date)) {
|
|
$date = new DateTime($date);
|
|
} else if ($date instanceof Zend_Date) {
|
|
$date = new DateTime($date->get(Zend_Date::ISO_8601));
|
|
} else {
|
|
throw new InvalidArgumentException('Parameter $date is not of the expected type');
|
|
}
|
|
}
|
|
$timezone = $date->format('O');
|
|
if (true === $asUtc) {
|
|
$date->setTimezone(new DateTimeZone('UTC'));
|
|
$timezone = 'Z';
|
|
}
|
|
if ( '+0000' === $timezone ) {
|
|
$timezone = 'Z';
|
|
}
|
|
return $date->format('YmdHis') . $timezone;
|
|
}
|
|
|
|
/**
|
|
* Convert a boolean value to an LDAP-compatible string
|
|
*
|
|
* This converts a boolean value of TRUE, an integer-value of 1 and a
|
|
* case-insensitive string 'true' to an LDAP-compatible 'TRUE'. All other
|
|
* other values are converted to an LDAP-compatible 'FALSE'.
|
|
*
|
|
* @param boolean|integer|string $value The boolean value to encode
|
|
* @return string
|
|
*/
|
|
public static function toLdapBoolean($value)
|
|
{
|
|
$return = 'FALSE';
|
|
if (!is_scalar($value)) {
|
|
return $return;
|
|
}
|
|
if (true === $value || 'true' === strtolower($value) || 1 === $value) {
|
|
$return = 'TRUE';
|
|
}
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Serialize any value for storage in LDAP
|
|
*
|
|
* @param mixed $value The value to serialize
|
|
* @return string
|
|
*/
|
|
public static function toLdapSerialize($value)
|
|
{
|
|
return serialize($value);
|
|
}
|
|
|
|
/**
|
|
* Convert an LDAP-compatible value to a corresponding PHP-value.
|
|
*
|
|
* By setting the <var>$type</var>-parameter the conversion of a certain
|
|
* type can be forced
|
|
* .
|
|
* @param string $value The value to convert
|
|
* @param int $ytpe The conversion type to use
|
|
* @param boolean $dateTimeAsUtc Return DateTime values in UTC timezone
|
|
* @return mixed
|
|
* @throws Zend_Ldap_Converter_Exception
|
|
*/
|
|
public static function fromLdap($value, $type = self::STANDARD, $dateTimeAsUtc = true)
|
|
{
|
|
switch ($type) {
|
|
case self::BOOLEAN:
|
|
return self::fromldapBoolean($value);
|
|
break;
|
|
case self::GENERALIZED_TIME:
|
|
return self::fromLdapDateTime($value);
|
|
break;
|
|
default:
|
|
if (is_numeric($value)) {
|
|
// prevent numeric values to be treated as date/time
|
|
return $value;
|
|
} else if ('TRUE' === $value || 'FALSE' === $value) {
|
|
return self::fromLdapBoolean($value);
|
|
}
|
|
if (preg_match('/^\d{4}[\d\+\-Z\.]*$/', $value)) {
|
|
return self::fromLdapDateTime($value, $dateTimeAsUtc);
|
|
}
|
|
try {
|
|
return self::fromLdapUnserialize($value);
|
|
} catch (UnexpectedValueException $e) { }
|
|
break;
|
|
}
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Convert an LDAP-Generalized-Time-entry into a DateTime-Object
|
|
*
|
|
* CAVEAT: The DateTime-Object returned will alwasy be set to UTC-Timezone.
|
|
*
|
|
* @param string $date The generalized-Time
|
|
* @param boolean $asUtc Return the DateTime with UTC timezone
|
|
* @return DateTime
|
|
* @throws InvalidArgumentException if a non-parseable-format is given
|
|
*/
|
|
public static function fromLdapDateTime($date, $asUtc = true)
|
|
{
|
|
$datepart = array ();
|
|
if (!preg_match('/^(\d{4})/', $date, $datepart) ) {
|
|
throw new InvalidArgumentException('Invalid date format found');
|
|
}
|
|
|
|
if ($datepart[1] < 4) {
|
|
throw new InvalidArgumentException('Invalid date format found (too short)');
|
|
}
|
|
|
|
$time = array (
|
|
// The year is mandatory!
|
|
'year' => $datepart[1],
|
|
'month' => 1,
|
|
'day' => 1,
|
|
'hour' => 0,
|
|
'minute' => 0,
|
|
'second' => 0,
|
|
'offdir' => '+',
|
|
'offsethours' => 0,
|
|
'offsetminutes' => 0
|
|
);
|
|
|
|
$length = strlen($date);
|
|
|
|
// Check for month.
|
|
if ($length >= 6) {
|
|
$month = substr($date, 4, 2);
|
|
if ($month < 1 || $month > 12) {
|
|
throw new InvalidArgumentException('Invalid date format found (invalid month)');
|
|
}
|
|
$time['month'] = $month;
|
|
}
|
|
|
|
// Check for day
|
|
if ($length >= 8) {
|
|
$day = substr($date, 6, 2);
|
|
if ($day < 1 || $day > 31) {
|
|
throw new InvalidArgumentException('Invalid date format found (invalid day)');
|
|
}
|
|
$time['day'] = $day;
|
|
}
|
|
|
|
// Check for Hour
|
|
if ($length >= 10) {
|
|
$hour = substr($date, 8, 2);
|
|
if ($hour < 0 || $hour > 23) {
|
|
throw new InvalidArgumentException('Invalid date format found (invalid hour)');
|
|
}
|
|
$time['hour'] = $hour;
|
|
}
|
|
|
|
// Check for minute
|
|
if ($length >= 12) {
|
|
$minute = substr($date, 10, 2);
|
|
if ($minute < 0 || $minute > 59) {
|
|
throw new InvalidArgumentException('Invalid date format found (invalid minute)');
|
|
}
|
|
$time['minute'] = $minute;
|
|
}
|
|
|
|
// Check for seconds
|
|
if ($length >= 14) {
|
|
$second = substr($date, 12, 2);
|
|
if ($second < 0 || $second > 59) {
|
|
throw new InvalidArgumentException('Invalid date format found (invalid second)');
|
|
}
|
|
$time['second'] = $second;
|
|
}
|
|
|
|
// Set Offset
|
|
$offsetRegEx = '/([Z\-\+])(\d{2}\'?){0,1}(\d{2}\'?){0,1}$/';
|
|
$off = array ();
|
|
if (preg_match($offsetRegEx, $date, $off)) {
|
|
$offset = $off[1];
|
|
if ($offset == '+' || $offset == '-') {
|
|
$time['offdir'] = $offset;
|
|
// we have an offset, so lets calculate it.
|
|
if (isset($off[2])) {
|
|
$offsetHours = substr($off[2], 0, 2);
|
|
if ($offsetHours < 0 || $offsetHours > 12) {
|
|
throw new InvalidArgumentException('Invalid date format found (invalid offset hour)');
|
|
}
|
|
$time['offsethours'] = $offsetHours;
|
|
}
|
|
if (isset($off[3])) {
|
|
$offsetMinutes = substr($off[3], 0, 2);
|
|
if ($offsetMinutes < 0 || $offsetMinutes > 59) {
|
|
throw new InvalidArgumentException('Invalid date format found (invalid offset minute)');
|
|
}
|
|
$time['offsetminutes'] = $offsetMinutes;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Raw-Data is present, so lets create a DateTime-Object from it.
|
|
$offset = $time['offdir']
|
|
. str_pad($time['offsethours'],2,'0',STR_PAD_LEFT)
|
|
. str_pad($time['offsetminutes'],2,'0',STR_PAD_LEFT);
|
|
$timestring = $time['year'] . '-'
|
|
. str_pad($time['month'], 2, '0', STR_PAD_LEFT) . '-'
|
|
. str_pad($time['day'], 2, '0', STR_PAD_LEFT) . ' '
|
|
. str_pad($time['hour'], 2, '0', STR_PAD_LEFT) . ':'
|
|
. str_pad($time['minute'], 2, '0', STR_PAD_LEFT) . ':'
|
|
. str_pad($time['second'], 2, '0', STR_PAD_LEFT)
|
|
. $time['offdir']
|
|
. str_pad($time['offsethours'], 2, '0', STR_PAD_LEFT)
|
|
. str_pad($time['offsetminutes'], 2, '0', STR_PAD_LEFT);
|
|
$date = new DateTime($timestring);
|
|
if ($asUtc) {
|
|
$date->setTimezone(new DateTimeZone('UTC'));
|
|
}
|
|
return $date;
|
|
}
|
|
|
|
/**
|
|
* Convert an LDAP-compatible boolean value into a PHP-compatible one
|
|
*
|
|
* @param string $value The value to convert
|
|
* @return boolean
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
public static function fromLdapBoolean($value)
|
|
{
|
|
if ( 'TRUE' === $value ) {
|
|
return true;
|
|
} else if ( 'FALSE' === $value ) {
|
|
return false;
|
|
} else {
|
|
throw new InvalidArgumentException('The given value is not a boolean value');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unserialize a serialized value to return the corresponding object
|
|
*
|
|
* @param string $value The value to convert
|
|
* @return mixed
|
|
* @throws UnexpectedValueException
|
|
*/
|
|
public static function fromLdapUnserialize($value)
|
|
{
|
|
$v = @unserialize($value);
|
|
if (false===$v && $value != 'b:0;') {
|
|
throw new UnexpectedValueException('The given value could not be unserialized');
|
|
}
|
|
return $v;
|
|
}
|
|
}
|