[795] | 1 | <?php |
---|
| 2 | /**************************************************************************\ |
---|
| 3 | * eGroupWare * |
---|
| 4 | * http://www.egroupware.org * |
---|
| 5 | * -------------------------------------------- * |
---|
| 6 | * This program is free software; you can redistribute it and/or modify it * |
---|
| 7 | * under the terms of the GNU General Public License as published by the * |
---|
| 8 | * Free Software Foundation; either version 2 of the License, or (at your * |
---|
| 9 | * option) any later version. * |
---|
| 10 | \**************************************************************************/ |
---|
| 11 | |
---|
| 12 | /** |
---|
| 13 | * Implements common LDAP methods |
---|
| 14 | * @author Sidnei Augusto Drovetto Jr. - drovetto@gmail.com |
---|
| 15 | * @version 1.0 |
---|
| 16 | * @package Workflow |
---|
| 17 | * @license http://www.gnu.org/copyleft/gpl.html GPL |
---|
| 18 | */ |
---|
| 19 | class WorkflowLDAP |
---|
| 20 | { |
---|
| 21 | /** |
---|
| 22 | * @var resource $dataSource Recurso de conexão com o LDAP |
---|
| 23 | * @access private |
---|
| 24 | */ |
---|
| 25 | private $dataSource; |
---|
| 26 | |
---|
| 27 | /** |
---|
| 28 | * @var string $userContext Contexto do usuário |
---|
| 29 | * @access private |
---|
| 30 | */ |
---|
| 31 | private $userContext; |
---|
| 32 | |
---|
| 33 | /** |
---|
| 34 | * @var string $groupContext Contexto do grupo |
---|
| 35 | * @access private |
---|
| 36 | */ |
---|
| 37 | private $groupContext; |
---|
| 38 | |
---|
| 39 | /** |
---|
| 40 | * @var string $ldapContext Contexto do LDAP |
---|
| 41 | * @access private |
---|
| 42 | */ |
---|
| 43 | private $ldapContext; |
---|
| 44 | |
---|
| 45 | /** |
---|
| 46 | * Construtor da classe |
---|
| 47 | * @return object |
---|
| 48 | * @access public |
---|
| 49 | */ |
---|
| 50 | function WorkflowLDAP() |
---|
| 51 | { |
---|
[2372] | 52 | $this->dataSource =& Factory::getInstance('WorkflowObjects')->getLDAP(); |
---|
[795] | 53 | |
---|
| 54 | /* get the required parameters */ |
---|
| 55 | $info = (isset($GLOBALS['phpgw_info']['server']['ldap_context'])) ? |
---|
| 56 | $GLOBALS['phpgw_info']['server'] : |
---|
| 57 | $_SESSION['phpgw_info']['workflow']['server']; |
---|
| 58 | $ldapConfigValues = galaxia_get_config_values(array('ldap_user_context' => '', 'ldap_group_context' => '')); |
---|
| 59 | if (empty($ldapConfigValues['ldap_user_context'])) |
---|
| 60 | $ldapConfigValues['ldap_user_context'] = $info['ldap_context']; |
---|
| 61 | if (empty($ldapConfigValues['ldap_group_context'])) |
---|
| 62 | $ldapConfigValues['ldap_group_context'] = $info['ldap_group_context']; |
---|
| 63 | $this->userContext = $ldapConfigValues['ldap_user_context']; |
---|
| 64 | $this->groupContext = $ldapConfigValues['ldap_group_context']; |
---|
| 65 | $this->ldapContext = $ldapConfigValues['ldap_user_context']; |
---|
| 66 | |
---|
| 67 | $this->cache = array( |
---|
| 68 | 'getEntities' => array(), |
---|
| 69 | 'getUserGroups' => array(), |
---|
| 70 | 'getGroupUsers' => array(), |
---|
| 71 | 'getOrganizations' => array(), |
---|
| 72 | 'getNames' => array() |
---|
| 73 | ); |
---|
| 74 | } |
---|
| 75 | |
---|
| 76 | /** |
---|
| 77 | * Checa se um método, e seus parâmetros, já estãoe em cache |
---|
| 78 | * @param string $methodName O nome do método que se quer verificar |
---|
| 79 | * @param string $parameters Parâmetros passados para o método (serializados) |
---|
| 80 | * @return bool true se foi encontrada uma versão em cache dos dados solicitados e false caso contrário |
---|
| 81 | * @access private |
---|
| 82 | */ |
---|
| 83 | private function checkCache($methodName, $parameters) |
---|
| 84 | { |
---|
| 85 | return isset($this->cache[$methodName][$parameters]); |
---|
| 86 | } |
---|
| 87 | |
---|
| 88 | /** |
---|
| 89 | * Pega a informação, em cache, de um método e seus parâmetros |
---|
| 90 | * @param string $methodName O nome do método que está em cache |
---|
| 91 | * @param string $parameters Parâmetros passados para o método (serializados) |
---|
| 92 | * @return mixed O retorno do método usando os parâmetros passados |
---|
| 93 | * @access private |
---|
| 94 | */ |
---|
| 95 | private function getCache($methodName, $parameters) |
---|
| 96 | { |
---|
| 97 | return $this->cache[$methodName][$parameters]; |
---|
| 98 | } |
---|
| 99 | |
---|
| 100 | /** |
---|
| 101 | * Coloca em cache um método e seus parâmetros |
---|
| 102 | * @param string $methodName O nome do método |
---|
| 103 | * @param string $parameters Parâmetros passados para o método (serializados) |
---|
| 104 | * @param mixed $output Saída do método usando os parâmetros passados |
---|
| 105 | * @return mixed A saída igual ao parâmetro $output |
---|
| 106 | * @access private |
---|
| 107 | */ |
---|
| 108 | private function setCache($methodName, $parameters, $output) |
---|
| 109 | { |
---|
| 110 | $this->cache[$methodName][$parameters] = $output; |
---|
| 111 | return $output; |
---|
| 112 | } |
---|
| 113 | |
---|
| 114 | /** |
---|
| 115 | * Faz consultas ao LDAP |
---|
| 116 | * @param string $context Contexto das entidades |
---|
| 117 | * @param string $filter Filtro utilizado para selecionar as entidades desejadas |
---|
| 118 | * @param array $elements Array dos campos que se deseja obter |
---|
| 119 | * @param bool $depthSearch Indica se a busca deve incluir sub-árvores ou não |
---|
| 120 | * @param string $elementSort O elemento pelo qual se quer ordenar o resultado |
---|
| 121 | * @return mixed Array do resultado. Ou false em caso de erro |
---|
| 122 | * @access private |
---|
| 123 | */ |
---|
| 124 | private function runLDAP($context, $filter, $elements, $depthSearch = false, $elementSort = null) |
---|
| 125 | { |
---|
| 126 | if ($depthSearch) |
---|
| 127 | $resourceIdentifier = ldap_search($this->dataSource, $context, $filter, $elements); |
---|
| 128 | else |
---|
| 129 | $resourceIdentifier = ldap_list($this->dataSource, $context, $filter, $elements); |
---|
| 130 | |
---|
| 131 | if (!$resourceIdentifier) |
---|
| 132 | return false; |
---|
| 133 | |
---|
| 134 | if (!is_null($elementSort)) |
---|
| 135 | ldap_sort($this->dataSource, $resourceIdentifier, $elementSort); |
---|
| 136 | |
---|
| 137 | $output = ldap_get_entries($this->dataSource, $resourceIdentifier); |
---|
| 138 | return $output; |
---|
| 139 | } |
---|
| 140 | |
---|
| 141 | /** |
---|
| 142 | * Faz consultas ao LDAP (inclusive com campos binários) |
---|
| 143 | * @param string $context Contexto das entidades |
---|
| 144 | * @param string $filter Filtro utilizado para selecionar as entidades desejadas |
---|
| 145 | * @param array $elements Array dos campos que se deseja obter |
---|
| 146 | * @param bool $depthSearch Indica se a busca deve incluir sub-árvores ou não |
---|
| 147 | * @param string $elementSort O elemento pelo qual se quer ordenar o resultado |
---|
| 148 | * @return mixed Array do resultado. Ou false em caso de erro |
---|
| 149 | * @access private |
---|
| 150 | */ |
---|
| 151 | private function runBinaryLDAP($context, $filter, $elements, $depthSearch = false, $elementSort = null) |
---|
| 152 | { |
---|
| 153 | if ($depthSearch) |
---|
| 154 | $resourceIdentifier = ldap_search($this->dataSource, $context, $filter, $elements); |
---|
| 155 | else |
---|
| 156 | $resourceIdentifier = ldap_list($this->dataSource, $context, $filter, $elements); |
---|
| 157 | |
---|
| 158 | if (!$resourceIdentifier) |
---|
| 159 | return false; |
---|
| 160 | |
---|
| 161 | if (!is_null($elementSort)) |
---|
| 162 | ldap_sort($this->dataSource, $resourceIdentifier, $elementSort); |
---|
| 163 | |
---|
| 164 | $entry = ldap_first_entry($this->dataSource, $resourceIdentifier); |
---|
| 165 | if (!$entry) |
---|
| 166 | return array(); |
---|
| 167 | |
---|
| 168 | $output = array(); |
---|
| 169 | $counter = 0; |
---|
| 170 | do |
---|
| 171 | { |
---|
| 172 | $attributes = ldap_get_attributes($this->dataSource, $entry); |
---|
| 173 | for ($i = 0; $i < $attributes['count']; $i++) |
---|
| 174 | $output[$counter][$attributes[$i]] = ldap_get_values_len($this->dataSource, $entry, $attributes[$i]); |
---|
| 175 | |
---|
| 176 | $counter++; |
---|
| 177 | } while ($entry = ldap_next_entry($this->dataSource, $entry)); |
---|
| 178 | |
---|
| 179 | return $output; |
---|
| 180 | } |
---|
| 181 | |
---|
| 182 | /** |
---|
| 183 | * Busca entidades (usuários, grupos ou listas públicas) do LDAP |
---|
| 184 | * @param string $context Contexto das entidades |
---|
| 185 | * @param string $filter Filtro utilizado para selecionar as entidades desejadas |
---|
| 186 | * @param array $elements Array dos campos que representa, nesta ordem: o ID, o nome e o e-mail da entidade |
---|
| 187 | * @param char $type O tipo da entidade: 'u' para usuários; 'g' para grupos; e 'l' para listas públicas |
---|
| 188 | * @param bool $depthSearch Indica se a busca deve incluir sub-árvores ou não |
---|
| 189 | * @return array Array das entidades |
---|
| 190 | * @access private |
---|
| 191 | */ |
---|
| 192 | private function getEntities($context, $filter, $elements, $type, $depthSearch = false) |
---|
| 193 | { |
---|
| 194 | /* check if the required information is in cache */ |
---|
| 195 | $methodName = 'getEntities'; |
---|
| 196 | $parameters = serialize(func_get_args()); |
---|
| 197 | if ($this->checkCache($methodName, $parameters)) |
---|
| 198 | return $this->getCache($methodName, $parameters); |
---|
| 199 | |
---|
| 200 | $result = $this->runLDAP($context, $filter, $elements, $depthSearch, $elements[1]); |
---|
| 201 | |
---|
| 202 | $output = array(); |
---|
| 203 | for ($i = 0; $i < $result['count']; $i++) |
---|
| 204 | { |
---|
| 205 | $output[] = array( |
---|
| 206 | 'id' => $result[$i][$elements[0]][0], |
---|
| 207 | 'name' => $result[$i][$elements[1]][0], |
---|
| 208 | 'type' => $type, |
---|
| 209 | 'mail' => $result[$i][$elements[2]][0]); |
---|
| 210 | } |
---|
| 211 | |
---|
| 212 | /* store the information in cache and return the output */ |
---|
| 213 | return $this->setCache($methodName, $parameters, $output); |
---|
| 214 | } |
---|
| 215 | |
---|
| 216 | /** |
---|
| 217 | * Retorna os grupos de um usuário |
---|
| 218 | * @param int $userID O ID do usuário |
---|
| 219 | * @return array Array dos grupos |
---|
| 220 | * @access public |
---|
| 221 | */ |
---|
| 222 | function getUserGroups($userID) |
---|
| 223 | { |
---|
| 224 | /* do not perform any search if the user is '*' */ |
---|
| 225 | if ($userID == '*') |
---|
| 226 | return array(); |
---|
| 227 | |
---|
| 228 | /* check if the required information is in cache */ |
---|
| 229 | $methodName = 'getUserGroups'; |
---|
| 230 | $parameters = serialize(func_get_args()); |
---|
| 231 | if ($this->checkCache($methodName, $parameters)) |
---|
| 232 | return $this->getCache($methodName, $parameters); |
---|
| 233 | |
---|
| 234 | /* check for error in connection */ |
---|
| 235 | if (!$this->dataSource) |
---|
| 236 | return false; |
---|
| 237 | |
---|
| 238 | /* first, get the UID */ |
---|
| 239 | $resourceIdentifier = ldap_search($this->dataSource, $this->userContext, "(&(phpgwaccounttype=u)(uidnumber={$userID}))", array('uid')); |
---|
| 240 | $result = ldap_get_entries($this->dataSource, $resourceIdentifier); |
---|
| 241 | if (!isset($result[0]['uid'][0])) |
---|
| 242 | return false; |
---|
| 243 | $userLogin = $result[0]['uid'][0]; |
---|
| 244 | |
---|
| 245 | /* initialize some variables */ |
---|
| 246 | $output = array(); |
---|
| 247 | |
---|
| 248 | /* search the LDAP tree */ |
---|
| 249 | $resourceIdentifier = ldap_search($this->dataSource, $this->groupContext, "(&(phpgwaccounttype=g)(memberuid={$userLogin}))", array('gidnumber')); |
---|
| 250 | $result = ldap_get_entries($this->dataSource, $resourceIdentifier); |
---|
| 251 | for ($i = 0; $i < $result['count']; $i++) |
---|
| 252 | $output[] = $result[$i]['gidnumber'][0]; |
---|
| 253 | |
---|
| 254 | /* store the information in cache and return the output */ |
---|
| 255 | return $this->setCache($methodName, $parameters, $output); |
---|
| 256 | } |
---|
| 257 | |
---|
| 258 | /** |
---|
| 259 | * Retorna os usuários de um grupo |
---|
| 260 | * @param int $groupID O ID do grupo |
---|
| 261 | * @return array Array dos usuários |
---|
| 262 | * @access public |
---|
| 263 | */ |
---|
| 264 | function getGroupUsers($groupID) |
---|
| 265 | { |
---|
| 266 | /* check if the required information is in cache */ |
---|
| 267 | $methodName = 'getGroupUsers'; |
---|
| 268 | $parameters = serialize(func_get_args()); |
---|
| 269 | if ($this->checkCache($methodName, $parameters)) |
---|
| 270 | return $this->getCache($methodName, $parameters); |
---|
| 271 | |
---|
| 272 | /* check for error in connection */ |
---|
| 273 | if (!$this->dataSource) |
---|
| 274 | return false; |
---|
| 275 | |
---|
| 276 | /* first, we get the UIDs that are members of the group */ |
---|
| 277 | $resourceIdentifier = ldap_search($this->dataSource, $this->ldapContext, "(&(phpgwaccounttype=g)(gidnumber={$groupID}))", array('memberuid')); |
---|
| 278 | $result = ldap_get_entries($this->dataSource, $resourceIdentifier); |
---|
| 279 | if (!isset($result[0]['memberuid'][0])) |
---|
| 280 | return false; |
---|
| 281 | |
---|
| 282 | $userLogins = $result[0]['memberuid']; |
---|
| 283 | unset($userLogins['count']); |
---|
| 284 | |
---|
| 285 | /* load the user information ten users at a time. This approach was proven to be faster on some systems */ |
---|
| 286 | $result = array(); |
---|
| 287 | while (count($userLogins) > 0) |
---|
| 288 | { |
---|
| 289 | $selectedUserLogins = array_splice($userLogins, 0, 10); |
---|
| 290 | $resourceIdentifier = ldap_search($this->dataSource, $this->ldapContext, "(&(phpgwaccounttype=u)(|" . implode('', array_map(create_function('$a', 'return "(uid={$a})";'), $selectedUserLogins)) . "))", array('cn', 'uidnumber')); |
---|
| 291 | $result = array_merge($result, ldap_get_entries($this->dataSource, $resourceIdentifier)); |
---|
| 292 | unset($result['count']); |
---|
| 293 | } |
---|
| 294 | |
---|
| 295 | $output = array(); |
---|
| 296 | $userCount = count($result); |
---|
| 297 | for ($i = 0; $i < $userCount; $i++) |
---|
| 298 | $output[] = array( |
---|
| 299 | 'account_id' => $result[$i]['uidnumber'][0], |
---|
| 300 | 'account_name' => $result[$i]['cn'][0]); |
---|
| 301 | |
---|
| 302 | /* sort the result */ |
---|
| 303 | usort($output, create_function('$a,$b', 'return strcasecmp($a[\'account_name\'],$b[\'account_name\']);')); |
---|
| 304 | |
---|
| 305 | /* store the information in cache and return the output */ |
---|
| 306 | return $this->setCache($methodName, $parameters, $output); |
---|
| 307 | } |
---|
| 308 | |
---|
| 309 | /** |
---|
| 310 | * Retorna as organizações do nível raiz |
---|
| 311 | * @return array Array de organizações |
---|
| 312 | * @access public |
---|
| 313 | */ |
---|
| 314 | function getOrganizations() |
---|
| 315 | { |
---|
| 316 | /* check if the required information is in cache */ |
---|
| 317 | $methodName = 'getOrganizations'; |
---|
| 318 | $parameters = serialize(func_get_args()); |
---|
| 319 | if ($this->checkCache($methodName, $parameters)) |
---|
| 320 | return $this->getCache($methodName, $parameters); |
---|
| 321 | |
---|
| 322 | /* check for error in connection */ |
---|
| 323 | if (!$this->dataSource) |
---|
| 324 | return false; |
---|
| 325 | |
---|
| 326 | /* load the sectors of level 0 as organizations, then format the data */ |
---|
| 327 | $output = array_map(create_function('$a', 'return $a[\'ou\'];'), $this->getSectors()); |
---|
| 328 | |
---|
| 329 | /* store the information in cache and return the output */ |
---|
| 330 | return $this->setCache($methodName, $parameters, $output); |
---|
| 331 | } |
---|
| 332 | |
---|
| 333 | /** |
---|
| 334 | * Retorna os setores de um determinado contexto |
---|
| 335 | * @param string $organization A organização a partir da qual a busca deve inciar. Utilize null para o nível raiz |
---|
| 336 | * @param bool $recursive Indica se a busca deve ser recursiva ou não. true indica que deve ser recursiva e false que não deve ser recursiva |
---|
| 337 | * @param string $contextBase A base do contexto. Utilize null para o contexto padrão |
---|
| 338 | * @param int $level Indica o nível atual de recursão |
---|
| 339 | * @return array Array de setores |
---|
| 340 | * @access public |
---|
| 341 | */ |
---|
| 342 | function getSectors($organization = null, $recursive = false, $contextBase = null, $level = 0) |
---|
| 343 | { |
---|
| 344 | /* determines the context in which the search will be performed */ |
---|
| 345 | $context = (!is_null($contextBase) ? $contextBase : $this->ldapContext); |
---|
| 346 | $context = (!is_null($organization) ? 'ou=' . $organization . ',' : '') . $context; |
---|
| 347 | |
---|
| 348 | /* search for the sectors */ |
---|
| 349 | $resourceIdentifier = @ldap_list($this->dataSource, $context, '(objectClass=organizationalUnit)', array('ou')); |
---|
| 350 | if ($resourceIdentifier === false) |
---|
| 351 | return false; |
---|
| 352 | |
---|
| 353 | ldap_sort($this->dataSource, $resourceIdentifier, 'ou'); |
---|
| 354 | $result = ldap_get_entries($this->dataSource, $resourceIdentifier); |
---|
| 355 | |
---|
| 356 | /* collect the data */ |
---|
| 357 | $output = array(); |
---|
| 358 | for ($i = 0; $i < $result['count']; $i++) |
---|
| 359 | { |
---|
| 360 | $output[] = array( |
---|
| 361 | 'dn' => $result[$i]['dn'], |
---|
| 362 | 'ou' => $result[$i]['ou'][0], |
---|
| 363 | 'level' => $level); |
---|
| 364 | |
---|
| 365 | /* if requested, perform a recursive search */ |
---|
| 366 | if ($recursive) |
---|
| 367 | $output = array_merge($output, $this->getSectors($result[$i]['ou'][0], $recursive, $context, $level + 1)); |
---|
| 368 | } |
---|
| 369 | |
---|
| 370 | return $output; |
---|
| 371 | } |
---|
| 372 | |
---|
| 373 | /** |
---|
| 374 | * Retorna os usuários de um determinado contexto |
---|
| 375 | * @param string $context O contexto a partir do qual a busca deve começar |
---|
| 376 | * @return array Array dos usuários encontrados |
---|
| 377 | * @access public |
---|
| 378 | */ |
---|
| 379 | function getUsers($context) |
---|
| 380 | { |
---|
| 381 | $filter = '(&(phpgwaccounttype=u)(!(phpgwAccountVisible=-1)))'; |
---|
| 382 | $elements = array('uidnumber', 'cn', 'mail'); |
---|
| 383 | return $this->getEntities($context, $filter, $elements, 'u', false); |
---|
| 384 | } |
---|
| 385 | |
---|
| 386 | /** |
---|
| 387 | * Retorna os grupos de um determinado contexto |
---|
| 388 | * @param string $context O contexto a partir do qual a busca deve começar |
---|
| 389 | * @return array Array dos grupos encontrados |
---|
| 390 | * @access public |
---|
| 391 | */ |
---|
| 392 | function getGroups($context) |
---|
| 393 | { |
---|
| 394 | $filter = '(phpgwaccounttype=g)'; |
---|
| 395 | $elements = array('gidnumber', 'cn', 'mail'); |
---|
| 396 | return $this->getEntities($context, $filter, $elements, 'g', false); |
---|
| 397 | } |
---|
| 398 | |
---|
| 399 | /** |
---|
| 400 | * Retorna listas públicas de um determinado contexto |
---|
| 401 | * @param string $context O contexto a partir do qual a busca deve começar |
---|
| 402 | * @return array Array das listas públicas encontradas |
---|
| 403 | * @access public |
---|
| 404 | */ |
---|
| 405 | function getPublicLists($context) |
---|
| 406 | { |
---|
| 407 | $filter = '(phpgwaccounttype=l)'; |
---|
| 408 | $elements = array('uidnumber', 'cn', 'mail'); |
---|
| 409 | return $this->getEntities($context, $filter, $elements, 'l', false); |
---|
| 410 | } |
---|
| 411 | |
---|
| 412 | /** |
---|
| 413 | * Retornar informação sobre um usuário |
---|
| 414 | * @param int $userID O ID do usuário |
---|
| 415 | * @return mixed Array contento informação sobre um usuário ou false se o usuário não for encontrado |
---|
| 416 | * @access public |
---|
| 417 | */ |
---|
| 418 | function getUserInfo($userID) |
---|
| 419 | { |
---|
| 420 | $filter = '(&(phpgwaccounttype=u)(uidnumber=' . $userID . '))'; |
---|
| 421 | $elements = array('uidnumber', 'cn', 'mail'); |
---|
| 422 | $output = $this->getEntities($this->ldapContext, $filter, $elements, 'u', true); |
---|
| 423 | if (count($output) == 1) |
---|
| 424 | return $output[0]; |
---|
| 425 | else |
---|
| 426 | return false; |
---|
| 427 | } |
---|
| 428 | |
---|
| 429 | function getUserPicture($userID) |
---|
| 430 | { |
---|
| 431 | $userID = (int) $userID; |
---|
| 432 | $filter = '(&(phpgwaccounttype=u)(uidnumber=' . $userID . '))'; |
---|
| 433 | $elements = array('jpegPhoto'); |
---|
| 434 | $result = $this->runBinaryLDAP($this->ldapContext, $filter, $elements, true); |
---|
| 435 | |
---|
| 436 | if (isset($result[0]['jpegPhoto'][0])) |
---|
| 437 | return $result[0]['jpegPhoto'][0]; |
---|
| 438 | |
---|
| 439 | return false; |
---|
| 440 | } |
---|
| 441 | |
---|
| 442 | /** |
---|
| 443 | * Retrieves information about a group |
---|
| 444 | * @param int $userID The ID of the group |
---|
| 445 | * @return mixed Array containing information about a group or false if the group is not found |
---|
| 446 | * @access public |
---|
| 447 | */ |
---|
| 448 | function getGroupInfo($groupID) |
---|
| 449 | { |
---|
| 450 | $filter = '(&(phpgwaccounttype=g)(gidnumber=' . $groupID . '))'; |
---|
| 451 | $elements = array('gidnumber', 'cn', 'mail'); |
---|
| 452 | $output = $this->getEntities($this->ldapContext, $filter, $elements, 'g', true); |
---|
| 453 | if (count($output) == 1) |
---|
| 454 | return $output[0]; |
---|
| 455 | else |
---|
| 456 | return false; |
---|
| 457 | } |
---|
| 458 | |
---|
| 459 | /** |
---|
| 460 | * Retorna o tipo de uma entidade |
---|
| 461 | * @param int $entityID O ID da entidade |
---|
| 462 | * @return string O tipo da entidade ('g' para grupo e 'u' para usuário) |
---|
| 463 | * @access public |
---|
| 464 | */ |
---|
| 465 | function getEntityType($entityID) |
---|
| 466 | { |
---|
| 467 | if ($entityID == '*') |
---|
| 468 | return false; |
---|
| 469 | |
---|
| 470 | $output = $this->getUserInfo($entityID); |
---|
| 471 | if (is_array($output)) |
---|
| 472 | return 'u'; |
---|
| 473 | else |
---|
| 474 | { |
---|
| 475 | $output = $this->getGroupInfo($entityID); |
---|
| 476 | if (is_array($output)) |
---|
| 477 | return 'g'; |
---|
| 478 | } |
---|
| 479 | |
---|
| 480 | return false; |
---|
| 481 | } |
---|
| 482 | |
---|
| 483 | /** |
---|
| 484 | * Retorna o nome de uma entidade |
---|
| 485 | * @param int $entityID O ID da entidade |
---|
| 486 | * @return string O nome da entidade |
---|
| 487 | * @access public |
---|
| 488 | */ |
---|
| 489 | function getName($entityID) |
---|
| 490 | { |
---|
| 491 | if ($entityID == '*') |
---|
| 492 | return '*'; |
---|
| 493 | $output = $this->getUserInfo($entityID); |
---|
| 494 | if (is_array($output)) |
---|
| 495 | return $output['name']; |
---|
| 496 | else |
---|
| 497 | { |
---|
| 498 | $output = $this->getGroupInfo($entityID); |
---|
| 499 | if (is_array($output)) |
---|
| 500 | return $output['name']; |
---|
| 501 | } |
---|
| 502 | } |
---|
| 503 | |
---|
| 504 | /** |
---|
| 505 | * Retorna os nomes de uma entidade |
---|
| 506 | * @param array $entitiesID Os IDs das entidades |
---|
| 507 | * @return string Os nomes das entidades |
---|
| 508 | * @access public |
---|
| 509 | */ |
---|
| 510 | function getNames($entitiesID) |
---|
| 511 | { |
---|
| 512 | /* check if the required information is in cache */ |
---|
| 513 | $methodName = 'getNames'; |
---|
| 514 | $parameters = serialize(func_get_args()); |
---|
| 515 | if ($this->checkCache($methodName, $parameters)) |
---|
| 516 | return $this->getCache($methodName, $parameters); |
---|
| 517 | |
---|
| 518 | /* check for error in connection */ |
---|
| 519 | if (!$this->dataSource) |
---|
| 520 | return false; |
---|
| 521 | |
---|
| 522 | /* check for '*' */ |
---|
| 523 | $asteriskIndex = array_search('*', $entitiesID); |
---|
| 524 | if ($asteriskIndex !== false) |
---|
| 525 | unset($entitiesID[$asteriskIndex]); |
---|
| 526 | |
---|
| 527 | /* load the entity information ten entities at a time. This approach was proven to be faster on some systems */ |
---|
| 528 | $result = array(); |
---|
| 529 | while (count($entitiesID) > 0) |
---|
| 530 | { |
---|
| 531 | $selectedEntitiesID = array_splice($entitiesID, 0, 10); |
---|
| 532 | $resourceIdentifier = ldap_search($this->dataSource, $this->ldapContext, "(|" . implode('', array_map(create_function('$a', 'return "(|(&(uidnumber={$a})(|(phpgwaccounttype=u)(phpgwaccounttype=l)))(&(gidnumber={$a})(phpgwaccounttype=g)))";'), array_unique($selectedEntitiesID))) . ')', array('cn', 'uidnumber', 'gidnumber', 'phpgwaccounttype')); |
---|
| 533 | $result = array_merge($result, ldap_get_entries($this->dataSource, $resourceIdentifier)); |
---|
| 534 | unset($result['count']); |
---|
| 535 | } |
---|
| 536 | |
---|
| 537 | $output = array(); |
---|
| 538 | $entityCount = count($result); |
---|
| 539 | for ($i = 0; $i < $entityCount; $i++) |
---|
| 540 | $output[] = array( |
---|
| 541 | 'id' => ($result[$i]['phpgwaccounttype'][0] == 'g') ? $result[$i]['gidnumber'][0] : $result[$i]['uidnumber'][0], |
---|
| 542 | 'name' => $result[$i]['cn'][0]); |
---|
| 543 | |
---|
| 544 | if ($asteriskIndex !== false) |
---|
| 545 | $output[] = array('id' => '*', 'name' => '*'); |
---|
| 546 | |
---|
| 547 | /* sort the result */ |
---|
| 548 | usort($output, create_function('$a,$b', 'return strcasecmp($a[\'name\'],$b[\'name\']);')); |
---|
| 549 | |
---|
| 550 | /* store the information in cache and return the output */ |
---|
| 551 | return $this->setCache($methodName, $parameters, $output); |
---|
| 552 | } |
---|
| 553 | |
---|
| 554 | /** |
---|
| 555 | * Faz uma busca (em todo o catálogo) por um nome |
---|
| 556 | * @param string $searchTerm O termo que está sendo procurado (pode conter '*') |
---|
| 557 | * @param bool $includeUsers Indica se na busca devem ser incluídos os registros referentes a usuários (true por padrão) |
---|
| 558 | * @param bool $includeGroups Indica se na busca devem ser incluídos os registros referentes a grupos (false por padrão) |
---|
| 559 | * @param bool $includeLists Indica se na busca devem ser incluídos os registros referentes a listas (false por padrão) |
---|
| 560 | * @return array Uma array contendo os registros encontrados |
---|
| 561 | * @access public |
---|
| 562 | */ |
---|
| 563 | function search($searchTerm, $includeUsers = true, $includeGroups = false, $includeLists = false, $context = null) |
---|
| 564 | { |
---|
| 565 | if (!($includeUsers || $includeGroups || $includeLists)) |
---|
| 566 | return false; |
---|
| 567 | |
---|
| 568 | if (is_null($context)) |
---|
| 569 | $context = $this->ldapContext; |
---|
| 570 | |
---|
| 571 | /* check for error in connection */ |
---|
| 572 | if (!$this->dataSource) |
---|
| 573 | return false; |
---|
| 574 | |
---|
| 575 | $entityFilter = array(); |
---|
| 576 | if ($includeUsers) |
---|
| 577 | $entityFilter[] = '(phpgwaccounttype=u)'; |
---|
| 578 | if ($includeGroups) |
---|
| 579 | $entityFilter[] = '(phpgwaccounttype=g)'; |
---|
| 580 | if ($includeLists) |
---|
| 581 | $entityFilter[] = '(phpgwaccounttype=l)'; |
---|
| 582 | |
---|
| 583 | if (count($entityFilter) > 1) |
---|
| 584 | $entityFilter = '(|' . implode('', $entityFilter) . ')'; |
---|
| 585 | else |
---|
| 586 | $entityFilter = $entityFilter[0]; |
---|
| 587 | |
---|
| 588 | $filter = "(&{$entityFilter}(cn={$searchTerm})(!(phpgwAccountVisible=-1)))"; |
---|
| 589 | $resourceIdentifier = ldap_search($this->dataSource, $context, $filter, array('cn', 'uidnumber', 'gidnumber', 'phpgwaccounttype', 'mail')); |
---|
| 590 | ldap_sort($this->dataSource, $resourceIdentifier, 'cn'); |
---|
| 591 | $result = ldap_get_entries($this->dataSource, $resourceIdentifier); |
---|
| 592 | |
---|
| 593 | $output = array(); |
---|
| 594 | for ($i = 0; $i < $result['count']; $i++) |
---|
| 595 | $output[] = array( |
---|
| 596 | 'id' => ($result[$i]['phpgwaccounttype'][0] == 'g') ? $result[$i]['gidnumber'][0] : $result[$i]['uidnumber'][0], |
---|
| 597 | 'name' => $result[$i]['cn'][0], |
---|
| 598 | 'mail' => $result[$i]['mail'][0], |
---|
| 599 | 'type' => $result[$i]['phpgwaccounttype'][0], |
---|
| 600 | 'dn' => $result[$i]['dn'] |
---|
| 601 | ); |
---|
| 602 | |
---|
| 603 | /* store the information in cache and return the output */ |
---|
| 604 | return $output; |
---|
| 605 | } |
---|
| 606 | |
---|
| 607 | /** |
---|
| 608 | * Retorna o contexto de usuários do LDAP |
---|
| 609 | * @return string O contexto de usuários do LDAP |
---|
| 610 | * @access public |
---|
| 611 | */ |
---|
| 612 | function getUserContext() |
---|
| 613 | { |
---|
| 614 | return $this->userContext; |
---|
| 615 | } |
---|
| 616 | |
---|
| 617 | /** |
---|
| 618 | * Retorna o contexto de grupos do LDAP |
---|
| 619 | * @return string O contexto de grupos do LDAP |
---|
| 620 | * @access public |
---|
| 621 | */ |
---|
| 622 | function getGroupContext() |
---|
| 623 | { |
---|
| 624 | return $this->groupContext; |
---|
| 625 | } |
---|
| 626 | |
---|
| 627 | /** |
---|
| 628 | * Retorna o contexto do LDAP |
---|
| 629 | * @return string O contexto do LDAP |
---|
| 630 | * @access public |
---|
| 631 | */ |
---|
| 632 | function getLDAPContext() |
---|
| 633 | { |
---|
| 634 | return $this->ldapContext; |
---|
| 635 | } |
---|
| 636 | |
---|
| 637 | /** |
---|
| 638 | * Retorna a organização de um DN |
---|
| 639 | * @param mixed $DN O DN do usuário |
---|
| 640 | * @return mixed Uma string contendo a organização ou false caso não seja achada a organização |
---|
| 641 | * @access public |
---|
| 642 | */ |
---|
| 643 | public function getOrganizationFromDN($DN) |
---|
| 644 | { |
---|
| 645 | $userContext = str_replace(' ', '', $this->userContext); |
---|
| 646 | $DN = str_replace(' ', '', $DN); |
---|
| 647 | $userInfo = array_reverse(explode(',', substr($DN, 0, - (strlen($userContext) + 1)))); |
---|
| 648 | foreach ($userInfo as $attributePair) |
---|
| 649 | { |
---|
| 650 | list($name, $value) = explode('=', $attributePair, 2); |
---|
| 651 | if ($name === 'ou') |
---|
| 652 | return $value; |
---|
| 653 | } |
---|
| 654 | |
---|
| 655 | return false; |
---|
| 656 | } |
---|
| 657 | } |
---|
| 658 | ?> |
---|