mirror of
https://github.com/owncloudarchive/contacts.git
synced 2024-12-11 22:24:32 +01:00
427 lines
15 KiB
PHP
427 lines
15 KiB
PHP
<?php
|
|
/**
|
|
* ownCloud - Addressbook LDAP
|
|
*
|
|
* @author Nicolas Mora
|
|
* @copyright 2013 Nicolas Mora mail@babelouest.org
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
|
|
* License as published by the Free Software Foundation
|
|
* version 3 of the License
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
namespace OCA\Contacts\Connector;
|
|
use Sabre\VObject\Component;
|
|
|
|
class LdapConnector {
|
|
|
|
public function __construct($xml_config) {
|
|
try {
|
|
//OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.', setting xml config', \OCP\Util::DEBUG);
|
|
$this->config_content = new \SimpleXMLElement($xml_config);
|
|
} catch (Exception $e) {
|
|
\OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.', error in setting xml config', \OCP\Util::DEBUG);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief transform a ldap entry into an VCard object
|
|
* for each ldap entry which is like "property: value"
|
|
* to a VCard entry which is like "PROPERTY[;PARAMETER=param]:value"
|
|
* @param array $ldap_entry
|
|
* @return OC_VCard
|
|
*/
|
|
public function ldapToVCard($ldapEntry) {
|
|
$vcard = \Sabre\VObject\Component::create('VCARD');
|
|
$vcard->REV = $ldapEntry['modifytimestamp'][0];
|
|
$vcard->{'X-LDAP-DN'} = base64_encode($ldapEntry['dn']);
|
|
// OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.' vcard is '.$vcard->serialize(), \OCP\Util::DEBUG);
|
|
|
|
for ($i=0; $i<$ldapEntry["count"]; $i++) {
|
|
// ldap property name : $ldap_entry[$i]
|
|
$l_property = $ldapEntry[$i];
|
|
for ($j=0;$j<$ldapEntry[$l_property]["count"];$j++){
|
|
|
|
// What to do :
|
|
// convert the ldap property into vcard property, type and position (if needed)
|
|
// $v_params format: array('property' => property, 'type' => array(types), 'position' => position)
|
|
$v_params = $this->getVCardProperty($l_property);
|
|
|
|
foreach ($v_params as $v_param) {
|
|
|
|
if (isset($v_param['unassigned'])) {
|
|
// if the value comes from the unassigned entry, it's a vcard property dumped
|
|
try {
|
|
$property = \Sabre\VObject\Reader::read($ldapEntry[$l_property][$j]);
|
|
$vcard->add($property);
|
|
} catch (exception $e) {
|
|
}
|
|
} else {
|
|
// Checks if a same kind of property already exists in the VCard (property and parameters)
|
|
// if so, sets a property variable with the current data
|
|
// else, creates a property variable
|
|
$v_property = $this->getOrCreateVCardProperty($vcard, $v_param, $j);
|
|
|
|
// modify the property with the new data
|
|
if (strcasecmp($v_param['image'], 'true') == 0) {
|
|
$this->updateVCardImageProperty($v_property, $ldapEntry[$l_property][$j], $vcard->VERSION);
|
|
} else {
|
|
$this->updateVCardProperty($v_property, $ldapEntry[$l_property][$j], $v_param['position']);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!isset($vcard->UID)) {
|
|
$vcard->UID = base64_encode($ldapEntry['dn']);
|
|
}
|
|
$vcard->validate(\Sabre\VObject\Component\VCard::REPAIR);
|
|
return $vcard;
|
|
}
|
|
|
|
/**
|
|
* @brief returns the vcard property corresponding to the ldif parameter
|
|
* creates the property if it doesn't exists yet
|
|
* @param $vcard the vcard to get or create the properties with
|
|
* @param $v_param the parameter the find
|
|
* @param $index the position of the property in the vcard to find
|
|
*/
|
|
public function getOrCreateVCardProperty(&$vcard, $v_param, $index) {
|
|
|
|
// looking for one
|
|
//OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.' entering '.$vcard->serialize(), \OCP\Util::DEBUG);
|
|
$properties = $vcard->select($v_param['property']);
|
|
$counter = 0;
|
|
foreach ($properties as $property) {
|
|
if ($v_param['type'] == null) {
|
|
//OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.' property '.$v_param['type'].' found', \OCP\Util::DEBUG);
|
|
return $property;
|
|
}
|
|
foreach ($property->parameters as $parameter) {
|
|
//OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.' parameter '.$parameter->value.' <> '.$v_param['type'], \OCP\Util::DEBUG);
|
|
if (!strcmp($parameter->value, $v_param['type'])) {
|
|
//OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.' parameter '.$parameter->value.' found', \OCP\Util::DEBUG);
|
|
if ($counter==$index) {
|
|
return $property;
|
|
}
|
|
$counter++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Property not found, creating one
|
|
//OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.', create one '.$v_param['property'].';TYPE='.$v_param['type'], \OCP\Util::DEBUG);
|
|
$line = count($vcard->children) - 1;
|
|
$property = \Sabre\VObject\Property::create($v_param['property']);
|
|
$vcard->add($property);
|
|
if ($v_param['type']!=null) {
|
|
//OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.', creating one '.$v_param['property'].';TYPE='.$v_param['type'], \OCP\Util::DEBUG);
|
|
//\OC_Log::write('ldapconnector', __METHOD__.', creating one '.$v_param['property'].';TYPE='.$v_param['type'], \OC_Log::DEBUG);
|
|
$property->parameters[] = new \Sabre\VObject\Parameter('TYPE', ''.$v_param['type']);
|
|
switch ($v_param['property']) {
|
|
case "ADR":
|
|
//OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.', we have an address '.$v_param['property'].';TYPE='.$v_param['type'], \OCP\Util::DEBUG);
|
|
$property->setValue(";;;;;;");
|
|
break;
|
|
case "FN":
|
|
$property->setValue(";;;;");
|
|
break;
|
|
}
|
|
}
|
|
//OCP\Util::writeLog('ldap_vcard_connector', __METHOD__.' exiting '.$vcard->serialize(), \OCP\Util::DEBUG);
|
|
return $property;
|
|
}
|
|
|
|
/**
|
|
* @brief modifies a vcard property array with the ldap_entry given in parameter at the given position
|
|
*/
|
|
public function updateVCardProperty(&$v_property, $ldap_entry, $position=null) {
|
|
for ($i=0; $i<count($v_property); $i++) {
|
|
if ($position != null) {
|
|
$v_array = explode(";", $v_property[$i]);
|
|
$v_array[intval($position)] = $ldap_entry;
|
|
$v_property[$i]->setValue(implode(";", $v_array));
|
|
} else {
|
|
$v_property[$i]->setValue($ldap_entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief modifies a vcard property array with the image
|
|
*/
|
|
public function updateVCardImageProperty(&$v_property, $ldap_entry, $version) {
|
|
for ($i=0; $i<count($v_property); $i++) {
|
|
$image = new \OC_Image();
|
|
$image->loadFromData($ldap_entry);
|
|
if (strcmp($version, '4.0') == 0) {
|
|
$type = $image->mimeType();
|
|
} else {
|
|
$arrayType = explode('/', $image->mimeType());
|
|
$type = strtoupper(array_pop($arrayType));
|
|
}
|
|
$v_property[$i]->add('ENCODING', 'b');
|
|
$v_property[$i]->add('TYPE', $type);
|
|
$v_property[$i]->setValue($image->__toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief gets the vcard property values from an ldif entry name
|
|
* @param $l_property the ldif property name
|
|
* @return array('property' => property, 'type' => type, 'position' => position)
|
|
*/
|
|
public function getVCardProperty($l_property) {
|
|
$properties = array();
|
|
if (strcmp($l_property, $this->getUnassignedVCardProperty()) == 0) {
|
|
$properties[] = array('unassigned' => true);
|
|
} else {
|
|
foreach ($this->config_content->ldap_entries->ldif_entry as $ldif_entry) {
|
|
if ($l_property == $ldif_entry['name']) {
|
|
// $ldif_entry['name'] is the right config xml
|
|
foreach ($ldif_entry->vcard_entry as $vcard_entry) {
|
|
$type=isset($vcard_entry['type'])?$vcard_entry['type']:"";
|
|
$position=isset($vcard_entry['position'])?$vcard_entry['position']:"";
|
|
$image=isset($ldif_entry['image'])?$ldif_entry['image']:"";
|
|
$properties[] = array('property' => $vcard_entry['property'], 'type' => $type, 'position' => $position, 'image' => $image);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $properties;
|
|
}
|
|
|
|
/**
|
|
* @brief return the ldif entries corresponding to the name and type given in parameter
|
|
* @param $propertyName the name of the vcard parameter
|
|
* @param $propertyType the type of the parameter
|
|
*/
|
|
public function getLdifEntry($propertyName, $propertyType) {
|
|
//\OC_Log::write('ldapconnector', __METHOD__."looking for $propertyName, $propertyType", \OC_Log::DEBUG);
|
|
if ($this->config_content !=null) {
|
|
$ldifEntries = array();
|
|
foreach ($this->config_content->vcard_entries->vcard_entry as $vcardEntry) {
|
|
if (strcasecmp($vcardEntry['property'], $propertyName) == 0 && (!isset($vcardEntry['type']) || strcasecmp($vcardEntry['type'], $propertyType) == 0) && strcasecmp($vcardEntry['enabled'], 'true') == 0) {
|
|
foreach($vcardEntry->ldif_entry as $ldifEntry) {
|
|
$params = array();
|
|
$params['name'] = $ldifEntry['name'];
|
|
if (isset($ldifEntry['vcard_position'])) {
|
|
$params['vcard_position'] = intval($ldifEntry['vcard_position']);
|
|
}
|
|
if (isset($vcardEntry['image']) && strcasecmp($vcardEntry['image'], 'true') == 0) {
|
|
$params['image'] = true;
|
|
} else {
|
|
$params['image'] = false;
|
|
}
|
|
$ldifEntries[] = $params;
|
|
}
|
|
}
|
|
}
|
|
if (count($ldifEntries) == 0) {
|
|
$ldifEntries[] = array('unassigned' => true);
|
|
}
|
|
return $ldifEntries;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @brief transform a vcard into a ldap entry
|
|
* @param VCard $vcard
|
|
* @return array|false
|
|
*/
|
|
public function VCardToLdap($vcard) {
|
|
|
|
$ldifReturn = array(); // Array to return
|
|
foreach ($vcard->children() as $property) {
|
|
// Basically, a $property can be converted into one or multiple ldif entries
|
|
// and also some vcard properties can have data that can be split to fill different ldif entries
|
|
$ldifArray = self::getLdifProperty($property);
|
|
|
|
if (count($ldifArray) > 0) {
|
|
self::updateLdifProperty($ldifReturn, $ldifArray);
|
|
}
|
|
}
|
|
self::validateLdapEntry($ldifReturn);
|
|
return $ldifReturn;
|
|
}
|
|
|
|
/**
|
|
* @brief transform finds the ldif entries associated with the property
|
|
* @param Property $property
|
|
* @return array|false
|
|
*/
|
|
public function getLdifProperty($property) {
|
|
$ldifReturn = array();
|
|
// Only one value per property, so we loop into types
|
|
// then for each one, look into config xml if there are ldif entries matching
|
|
$ldifEntries = self::getLdifEntry($property->name, $property['TYPE']);
|
|
// If one is found, create a tab entry like tab['ldif_entry']
|
|
if ($ldifEntries != null && count($ldifEntries)>0) {
|
|
foreach ($ldifEntries as $ldifEntry) {
|
|
if (isset($ldifEntry['unassigned'])) {
|
|
if ((strcasecmp($property->name, "REV") != 0) && (strcasecmp($property->name, "VERSION") != 0) && (strcasecmp($property->name, "X-LDAP-DN") != 0)) {
|
|
// The unassigned properties are set in the ldap unassignedVCardProperty
|
|
$ldifReturn[(string)$this->getUnassignedVCardProperty()] = array($property->serialize());
|
|
}
|
|
} else {
|
|
// Last, if the ldif entry has a vcard_position set, take only the value in the position index
|
|
$value = $property->value;
|
|
if (isset($ldifEntry['vcard_position'])) {
|
|
//\OC_Log::write('ldapconnector', __METHOD__." position set ".$ldifEntry['vcard_position'], \OC_Log::DEBUG);
|
|
$tmpValues = explode(";", $property->value);
|
|
$value = $tmpValues[$ldifEntry['vcard_position']];
|
|
}
|
|
//\OC_Log::write('ldapconnector', __METHOD__.__METHOD__." entry : ".$ldifEntry['name']." - value : $value", \OC_Log::DEBUG);
|
|
// finally, sets tab['ldif_entry'][] with the value
|
|
if (strcmp($value, "") != 0) {
|
|
if ($ldifEntry['image']) {
|
|
$ldifReturn[(string)$ldifEntry['name']] = array(base64_decode($value));
|
|
} else {
|
|
$ldifReturn[(string)$ldifEntry['name']] = array($value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $ldifReturn;
|
|
}
|
|
|
|
/**
|
|
* @brief updates the ldifEntry with $ldifNewValues
|
|
* @param $ldifEntry the array to modify
|
|
* @param $ldifNewValues the new values
|
|
* @return boolean
|
|
*/
|
|
public function updateLdifProperty(&$ldifEntries, $ldifNewValues) {
|
|
foreach ($ldifNewValues as $key => $value) {
|
|
if (isset($ldifEntries[$key])) {
|
|
$ldifEntries[$key] = array_merge($ldifEntries[$key], $value);
|
|
} else {
|
|
$ldifEntries[$key] = $value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief returns all the ldap entries managed
|
|
* @return array
|
|
*/
|
|
public function getLdapEntries() {
|
|
if ($this->config_content != null) {
|
|
$to_return = array('modifytimestamp');
|
|
|
|
$unassigned = $this->getUnassignedVCardProperty();
|
|
if ($unassigned) {
|
|
$to_return[] = $unassigned;
|
|
}
|
|
|
|
foreach ($this->config_content->ldap_entries[0]->ldif_entry as $ldif_entry) {
|
|
$to_return[] = $ldif_entry['name'];
|
|
}
|
|
return $to_return;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief returns the ldif entry for the VCard properties that don't have a ldap correspondance
|
|
* @return string|false
|
|
*/
|
|
public function getUnassignedVCardProperty() {
|
|
if ($this->config_content != null && $this->config_content->ldap_entries[0]->ldap_core[0]->unassigned_vcard_property['ldap_name'] != null) {
|
|
return ($this->config_content->ldap_entries[0]->ldap_core[0]->unassigned_vcard_property['ldap_name']);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief get the id attribute in the ldap
|
|
* @return string|false
|
|
*/
|
|
public function getLdapId() {
|
|
if ($this->config_content != null && $this->config_content->ldap_entries[0]->ldap_core[0]->ldap_id['name'] != null) {
|
|
return ($this->config_content->ldap_entries[0]->ldap_core[0]->ldap_id['name']);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief get the xml config name
|
|
* @return string|false
|
|
*/
|
|
public function getXmlConfigName() {
|
|
if ($this->config_content != null && $this->config_content['name'] != null) {
|
|
return ($this->config_content['name']);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief checks if the ldapEntry is valid and fixes if possible
|
|
* @param $ldapEntry array
|
|
* @return boolean
|
|
*/
|
|
public function validateLdapEntry(&$ldapEntry) {
|
|
if ($this->config_content != null) {
|
|
$ldapEntry['objectclass'] = array();
|
|
|
|
// Fill $ldapEntry with the objectClass params
|
|
foreach ($this->config_content->ldap_entries[0]->ldap_core[0]->object_class as $object_class) {
|
|
$ldapEntry['objectclass'][] = (string)$object_class['name'];
|
|
}
|
|
|
|
foreach ($this->config_content->ldap_entries[0]->ldap_core[0]->not_null as $not_null) {
|
|
$key = (string)$not_null['name'];
|
|
|
|
// Repair $ldapEntry if a field is null or empty
|
|
if (!array_key_exists($key, $ldapEntry) || strcmp('', $ldapEntry[$key][0]) == 0) {
|
|
|
|
// Switch with another entry
|
|
if (isset($not_null->action_switch[0])) {
|
|
$ldapEntry[$key][0] = $ldapEntry[(string)$not_null->action_switch[0]['name']][0];
|
|
unset($ldapEntry[(string)$not_null->action_switch[0]['name']][0]);
|
|
if (count($ldapEntry[(string)$not_null->action_switch[0]['name']]) == 0) {
|
|
unset($ldapEntry[(string)$not_null->action_switch[0]['name']]);
|
|
}
|
|
} else if (isset($not_null->action_default[0])) {
|
|
// Fill with a default value
|
|
$ldapEntry[$key][0] = (string)$not_null->action_default[0]['value'];
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach ($this->config_content->vcard_entries[0]->vcard_entry as $vcardEntry) {
|
|
foreach ($vcardEntry->ldif_entry as $ldifEntry) {
|
|
// Remove duplicates if relevant
|
|
if (strcmp("true", $ldifEntry['unique'])==0 && array_key_exists((string)$ldifEntry['name'], $ldapEntry)) { // Y aller à coup de "bool array_key_exists ( mixed $key , array $search )"
|
|
// Holy hand-grenade, there are like 3 imbricated loops...
|
|
$ldapEntry[(string)$ldifEntry['name']] = array_unique($ldapEntry[(string)$ldifEntry['name']]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
?>
|