Source for file abook_ldap_server.php

Documentation is available at abook_ldap_server.php

  1. <?php
  2.  
  3. /**
  4.  * abook_ldap_server.php
  5.  *
  6.  * Address book backend for LDAP server
  7.  *
  8.  * LDAP filtering code by Tim Bell
  9.  *   <bhat at users.sourceforge.net> (#539534)
  10.  * ADS limit_scope code by Michael Brown
  11.  *   <mcb30 at users.sourceforge.net> (#1035454)
  12.  * StartTLS code by John Lane
  13.  *   <starfry at users.sourceforge.net> (#1197703)
  14.  * Code for remove, add, modify, lookup by David Härdeman
  15.  *   <david at 2gen.com> (#1495763)
  16.  *
  17.  * This backend uses LDAP person (RFC2256), organizationalPerson (RFC2256)
  18.  * and inetOrgPerson (RFC2798) objects and dn, description, sn, givenname,
  19.  * cn, mail attributes. Other attributes are ignored.
  20.  * 
  21.  * @copyright &copy; 1999-2006 The SquirrelMail Project Team
  22.  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  23.  * @version $Id: abook_ldap_server.php,v 1.42 2006/06/04 12:42:24 tokul Exp $
  24.  * @package squirrelmail
  25.  * @subpackage addressbook
  26.  */
  27.  
  28. /**
  29.  * Address book backend for LDAP server
  30.  *
  31.  * An array with the following elements must be passed to
  32.  * the class constructor (elements marked ? are optional)
  33.  *
  34.  * Main settings:
  35.  * <pre>
  36.  *    host      => LDAP server hostname, IP-address or any other URI compatible
  37.  *                 with used LDAP library.
  38.  *    base      => LDAP server root (base dn). Empty string allowed.
  39.  *  ? port      => LDAP server TCP port number (default: 389)
  40.  *  ? charset   => LDAP server charset (default: utf-8)
  41.  *  ? name      => Name for LDAP server (default "LDAP: hostname")
  42.  *                 Used to tag the result data
  43.  *  ? maxrows   => Maximum # of rows in search result
  44.  *  ? timeout   => Timeout for LDAP operations (in seconds, default: 30)
  45.  *                 Might not work for all LDAP libraries or servers.
  46.  *  ? binddn    => LDAP Bind DN.
  47.  *  ? bindpw    => LDAP Bind Password.
  48.  *  ? protocol  => LDAP Bind protocol.
  49.  * </pre>
  50.  * Advanced settings:
  51.  * <pre>
  52.  *  ? filter    => Filter expression to limit ldap searches
  53.  *  ? limit_scope => Limits scope to base DN (Specific to Win2k3 ADS).
  54.  *  ? listing   => Controls listing of LDAP directory.
  55.  *  ? writeable => Controls write access to address book
  56.  *  ? search_tree => Controls subtree or one level search.
  57.  *  ? starttls  => Controls use of StartTLS on LDAP connections
  58.  * </pre>
  59.  * NOTE. This class should not be used directly. Use addressbook_init()
  60.  *       function instead.
  61.  * @package squirrelmail
  62.  * @subpackage addressbook
  63.  */
  64. class abook_ldap_server extends addressbook_backend {
  65.     /**
  66.      * @var string backend type
  67.      */
  68.     var $btype = 'remote';
  69.     /**
  70.      * @var string backend name
  71.      */
  72.     var $bname = 'ldap_server';
  73.  
  74.     /* Parameters changed by class */
  75.     /**
  76.      * @var string displayed name
  77.      */
  78.     var $sname   = 'LDAP';       /* Service name */
  79.     /**
  80.      * @var string LDAP server name or address or url
  81.      */
  82.     var $server  = '';
  83.     /**
  84.      * @var integer LDAP server port
  85.      */
  86.     var $port    = 389;
  87.     /**
  88.      * @var string LDAP base DN
  89.      */
  90.     var $basedn  = '';
  91.     /**
  92.      * @var string charset used for entries in LDAP server
  93.      */
  94.     var $charset = 'utf-8';
  95.     /**
  96.      * @var object PHP LDAP link ID
  97.      */
  98.     var $linkid  = false;
  99.     /**
  100.      * @var bool True if LDAP server is bound
  101.      */
  102.     var $bound   = false;
  103.     /**
  104.      * @var integer max rows in result
  105.      */
  106.     var $maxrows = 250;
  107.     /**
  108.      * @var string ldap filter
  109.      * @since 1.5.1
  110.      */
  111.     var $filter = '';
  112.     /**
  113.      * @var integer timeout of LDAP operations (in seconds)
  114.      */
  115.     var $timeout = 30;
  116.     /**
  117.      * @var string DN to bind to (non-anonymous bind)
  118.      * @since 1.5.0 and 1.4.3
  119.      */
  120.     var $binddn = '';
  121.     /**
  122.      * @var string  password to bind with (non-anonymous bind)
  123.      * @since 1.5.0 and 1.4.3
  124.      */
  125.     var $bindpw = '';
  126.     /**
  127.      * @var integer protocol used to connect to ldap server
  128.      * @since 1.5.0 and 1.4.3
  129.      */
  130.     var $protocol = '';
  131.     /**
  132.      * @var boolean limits scope to base dn
  133.      * @since 1.5.1
  134.      */
  135.     var $limit_scope = false;
  136.     /**
  137.      * @var boolean controls listing of directory
  138.      * @since 1.5.1
  139.      */
  140.     var $listing = false;
  141.     /**
  142.      * @var boolean true if removing/adding/modifying entries is allowed
  143.      * @since 1.5.2
  144.      */
  145.     var $writeable = false;
  146.     /**
  147.      * @var boolean controls ldap search type.
  148.      *  only first level entries are displayed if set to false
  149.      * @since 1.5.1
  150.      */
  151.     var $search_tree = true;
  152.     /**
  153.      * @var boolean controls use of StartTLS on ldap
  154.      *  connections. Requires php 4.2+ and protocol >= 3
  155.      * @since 1.5.1
  156.      */
  157.     var $starttls = false;
  158.  
  159.     /**
  160.      * Constructor. Connects to database
  161.      * @param array connection options
  162.      */
  163.     function abook_ldap_server($param) {
  164.         if(!function_exists('ldap_connect')) {
  165.             $this->set_error(_("PHP install does not have LDAP support."));
  166.             return;
  167.         }
  168.         if(is_array($param)) {
  169.             $this->server = $param['host'];
  170.             // remove whitespace from basedn
  171.             $this->basedn = preg_replace('/,\s*/',',',trim($param['base']));
  172.  
  173.             if(!empty($param['port']))
  174.                 $this->port = $param['port'];
  175.  
  176.             if(!empty($param['charset']))
  177.                 $this->charset = strtolower($param['charset']);
  178.  
  179.             if(isset($param['maxrows']))
  180.                 $this->maxrows = $param['maxrows'];
  181.  
  182.             if(isset($param['timeout']))
  183.                 $this->timeout = $param['timeout'];
  184.  
  185.             if(isset($param['binddn']))
  186.                 $this->binddn = $param['binddn'];
  187.  
  188.             if(isset($param['bindpw']))
  189.                 $this->bindpw = $param['bindpw'];
  190.  
  191.             if(isset($param['protocol']))
  192.                 $this->protocol = (int) $param['protocol'];
  193.  
  194.             if(isset($param['filter']))
  195.                 $this->filter = trim($param['filter']);
  196.  
  197.             if(isset($param['limit_scope']))
  198.                 $this->limit_scope = (bool) $param['limit_scope'];
  199.  
  200.             if(isset($param['listing']))
  201.                 $this->listing = (bool) $param['listing'];
  202.  
  203.             if(isset($param['writeable'])) {
  204.                 $this->writeable = (bool) $param['writeable'];
  205.                 // switch backend type to local, if it is writable
  206.                 if($this->writeable) $this->btype = 'local';
  207.             }
  208.  
  209.             if(isset($param['search_tree']))
  210.                 $this->search_tree = (bool) $param['search_tree'];
  211.  
  212.             if(isset($param['starttls']))
  213.                 $this->starttls = (bool) $param['starttls'];
  214.  
  215.             if(empty($param['name'])) {
  216.                 $this->sname = 'LDAP: ' . $param['host'];
  217.             } else {
  218.                 $this->sname = $param['name'];
  219.             }
  220.  
  221.             /*
  222.              * don't open LDAP server on addressbook_init(),
  223.              * open ldap connection only on search. Speeds up
  224.              * addressbook_init() call.
  225.              */
  226.             // $this->open(true);
  227.         } else {
  228.             $this->set_error('Invalid argument to constructor');
  229.         }
  230.     }
  231.  
  232.  
  233.     /**
  234.      * Open the LDAP server.
  235.      * @param bool $new is it a new connection
  236.      * @return bool 
  237.      */
  238.     function open($new = false) {
  239.         $this->error = '';
  240.  
  241.         /* Connection is already open */
  242.         if($this->linkid != false && !$new) {
  243.             return true;
  244.         }
  245.  
  246.         $this->linkid = @ldap_connect($this->server, $this->port);
  247.         /**
  248.          * check if connection was successful
  249.          * It does not work with OpenLDAP 2.x libraries. Connect error will be 
  250.          * displayed only on ldap command that tries to make connection 
  251.          * (ldap_start_tls or ldap_bind). 
  252.          */
  253.         if(!$this->linkid) {
  254.             return $this->set_error($this->ldap_error('ldap_connect failed'));
  255.         }
  256.  
  257.         if(!empty($this->protocol)) {
  258.             // make sure that ldap_set_option() is available before using it
  259.             if(! function_exists('ldap_set_option') ||
  260.                !@ldap_set_option($this->linkid, LDAP_OPT_PROTOCOL_VERSION, $this->protocol)) {
  261.                 return $this->set_error('unable to set ldap protocol number');
  262.             }
  263.         }
  264.  
  265.         /**
  266.          * http://www.php.net/ldap-start-tls
  267.          * Check if v3 or newer protocol is used,
  268.          * check if ldap_start_tls function is available.
  269.          * Silently ignore setting, if these requirements are not satisfied.
  270.          * Break with error message if somebody tries to start TLS on
  271.          * ldaps or socket connection.
  272.          */
  273.         if($this->starttls && 
  274.            !empty($this->protocol) && $this->protocol >= 3 &&
  275.            function_exists('ldap_start_tls') ) {
  276.             // make sure that $this->server is not ldaps:// or ldapi:// URL.
  277.             if (preg_match("/^ldap[si]:\/\/.+/i",$this->server)) {
  278.                 return $this->set_error("you can't enable starttls on ldaps and ldapi connections.");
  279.             }
  280.             
  281.             // try starting tls
  282.             if (! @ldap_start_tls($this->linkid)) {
  283.                 // set error if call fails
  284.                 return $this->set_error($this->ldap_error('ldap_start_tls failed'));
  285.             }
  286.         }
  287.  
  288.         if(!empty($this->limit_scope) && $this->limit_scope) {
  289.             if(empty($this->protocol) || intval($this->protocol) < 3) {
  290.                 return $this->set_error('limit_scope requires protocol >= 3');
  291.             }
  292.             // See http://msdn.microsoft.com/library/en-us/ldap/ldap/ldap_server_domain_scope_oid.asp
  293.             $ctrl = array ( "oid" => "1.2.840.113556.1.4.1339", "iscritical" => TRUE );
  294.             /*
  295.              * Option is set only during connection.
  296.              * It does not cause immediate errors with OpenLDAP 2.x libraries.
  297.              */
  298.             if(! function_exists('ldap_set_option') ||
  299.                !@ldap_set_option($this->linkid, LDAP_OPT_SERVER_CONTROLS, array($ctrl))) {
  300.                 return $this->set_error($this->ldap_error('limit domain scope failed'));
  301.             }
  302.         }
  303.  
  304.         // authenticated bind
  305.         if(!empty($this->binddn)) {
  306.             if(!@ldap_bind($this->linkid, $this->binddn, $this->bindpw)) {
  307.                 return $this->set_error($this->ldap_error('authenticated ldap_bind failed'));
  308.             }
  309.         } else {
  310.             // anonymous bind
  311.             if(!@ldap_bind($this->linkid)) {
  312.                 return $this->set_error($this->ldap_error('anonymous ldap_bind failed'));
  313.             }
  314.         }
  315.  
  316.         $this->bound = true;
  317.  
  318.         return true;
  319.     }
  320.  
  321.     /**
  322.      * Encode string to the charset used by this LDAP server
  323.      * @param string string that has to be encoded
  324.      * @return string encoded string
  325.      */
  326.     function charset_encode($str) {
  327.         global $default_charset;
  328.         if($this->charset != $default_charset) {
  329.             return charset_convert($default_charset,$str,$this->charset,false);
  330.         } else {
  331.             return $str;
  332.         }
  333.     }
  334.  
  335.     /**
  336.      * Decode from charset used by this LDAP server to charset used by translation
  337.      *
  338.      * Uses SquirrelMail charset_decode functions
  339.      * @param string string that has to be decoded
  340.      * @return string decoded string
  341.      */
  342.     function charset_decode($str) {
  343.         global $default_charset;
  344.         if ($this->charset != $default_charset) {
  345.             return charset_convert($this->charset,$str,$default_charset,false);
  346.         } else {
  347.             return $str;
  348.         }
  349.     }
  350.  
  351.     /**
  352.      * Sanitizes ldap search strings.
  353.      * See rfc2254
  354.      * @link http://www.faqs.org/rfcs/rfc2254.html
  355.      * @since 1.5.1 and 1.4.5
  356.      * @param string $string 
  357.      * @return string sanitized string
  358.      */
  359.     function ldapspecialchars($string) {
  360.         $sanitized=array('\\' => '\5c',
  361.                          '*' => '\2a',
  362.                          '(' => '\28',
  363.                          ')' => '\29',
  364.                          "\x00" => '\00');
  365.  
  366.         return str_replace(array_keys($sanitized),array_values($sanitized),$string);
  367.     }
  368.  
  369.     /**
  370.      * Prepares user input for use in a ldap query.
  371.      *
  372.      * Function converts input string to character set used in LDAP server
  373.      * (charset_encode() method) and sanitizes it (ldapspecialchars()).
  374.      *
  375.      * @param string $string string to encode
  376.      * @return string ldap encoded string
  377.      * @since 1.5.2
  378.      */
  379.     function quotevalue($string) {
  380.         $sanitized = $this->charset_encode($string);
  381.         return $this->ldapspecialchars($sanitized);
  382.     }
  383.  
  384.     /**
  385.      * Search LDAP server.
  386.      *
  387.      * Warning: You must make sure that ldap query is correctly formated and
  388.      * sanitize use of special ldap keywords.
  389.      * @param string $expression ldap query
  390.      * @param boolean $singleentry (since 1.5.2) whether we are looking for a
  391.      *   single entry. Boolean true forces LDAP_SCOPE_BASE search.
  392.      * @return array search results (false on error)
  393.      * @since 1.5.1
  394.      */
  395.     function ldap_search($expression, $singleentry = false) {
  396.         /* Make sure connection is there */
  397.         if(!$this->open()) {
  398.             return false;
  399.         }
  400.  
  401.         $attributes = array('dn', 'description', 'sn', 'givenname', 'cn', 'mail');
  402.  
  403.         if ($singleentry) {
  404.             // ldap_read - search for one single entry
  405.             $sret = @ldap_read($this->linkid, $expression, "objectClass=*",
  406.                                $attributes, 0, $this->maxrows, $this->timeout);
  407.         } elseif ($this->search_tree) {
  408.             // ldap_search - search subtree
  409.             $sret = @ldap_search($this->linkid, $this->basedn, $expression,
  410.                 $attributes, 0, $this->maxrows, $this->timeout);
  411.         } else {
  412.             // ldap_list - search one level
  413.             $sret = @ldap_list($this->linkid, $this->basedn, $expression,
  414.                 $attributes, 0, $this->maxrows, $this->timeout);
  415.         }
  416.  
  417.         /* Return error if search failed */
  418.         if(!$sret) {
  419.             // Check for LDAP_NO_SUCH_OBJECT (0x20 or 32) error
  420.             if (ldap_errno($this->linkid)==32) {
  421.                 return array();
  422.             } else {
  423.                 return $this->set_error($this->ldap_error('ldap_search failed'));
  424.             }
  425.         }
  426.  
  427.         if(@ldap_count_entries($this->linkid, $sret) <= 0) {
  428.             return array();
  429.         }
  430.  
  431.         /* Get results */
  432.         $ret = array();
  433.         $returned_rows = 0;
  434.         $res = @ldap_get_entries($this->linkid, $sret);
  435.         for($i = 0 ; $i < $res['count'] ; $i++) {
  436.             $row = $res[$i];
  437.  
  438.             /* Extract data common for all e-mail addresses
  439.              * of an object. Use only the first name */      
  440.             $nickname = $this->charset_decode($row['dn']);
  441.  
  442.             /**
  443.              * remove trailing basedn
  444.              * remove whitespaces between RDNs
  445.              * remove leading "cn="
  446.              * which gives nicknames which are shorter while still unique
  447.              */
  448.             $nickname = preg_replace('/,\s*/',',', trim($nickname));
  449.             $offset = strlen($nickname) - strlen($this->basedn);
  450.  
  451.             if($offset > 0 && substr($nickname, $offset) == $this->basedn) {
  452.                 $nickname = substr($nickname, 0, $offset);
  453.                 if(substr($nickname, -1) == ",")
  454.                     $nickname = substr($nickname, 0, -1);
  455.             }
  456.             if(strncasecmp($nickname, "cn=", 3) == 0)
  457.                 $nickname=substr($nickname, 3);         
  458.  
  459.             if(empty($row['description'][0])) {
  460.                 $label = '';
  461.             } else {
  462.                 $label = $this->charset_decode($row['description'][0]);
  463.             }
  464.  
  465.             if(empty($row['givenname'][0])) {
  466.                 $firstname = '';
  467.             } else {
  468.                 $firstname = $this->charset_decode($row['givenname'][0]);
  469.             }
  470.  
  471.             if(empty($row['sn'][0])) {
  472.                 $surname = '';
  473.             } else {
  474.                 // remove whitespace in order to handle sn set to empty string
  475.                 $surname = trim($this->charset_decode($row['sn'][0]));
  476.             }
  477.  
  478.             $fullname = $this->fullname($firstname,$surname);
  479.  
  480.             /* Add one row to result for each e-mail address */
  481.             if(isset($row['mail']['count'])) {
  482.                 for($j = 0 ; $j < $row['mail']['count'] ; $j++) {
  483.                     array_push($ret, array('nickname'  => $nickname,
  484.                    'name'      => $fullname,
  485.                    'firstname' => $firstname,
  486.                    'lastname'  => $surname,
  487.                    'email'     => $row['mail'][$j],
  488.                    'label'     => $label,
  489.                    'backend'   => $this->bnum,
  490.                    'source'    => &$this->sname));
  491.  
  492.                     // Limit number of hits
  493.