- Fix IDNA support when IDN/INTL modules are in use (#1487742)

alecpl

2011-02-03 e8d5bdc84ecfdf6fe5008655215a258bbdf0c521

 program/include/rcube_ldap.php

@@ -3,8 +3,8 @@
 +-----------------------------------------------------------------------+
 | program/include/rcube_ldap.php                                        |
 |                                                                       |
 | This file is part of the RoundCube Webmail client                     |
 | Copyright (C) 2006-2009, RoundCube Dev. - Switzerland                 |
 | This file is part of the Roundcube Webmail client                     |
 | Copyright (C) 2006-2011, The Roundcube Dev Team                       |
 | Licensed under the GNU GPL                                            |
 |                                                                       |
 | PURPOSE:                                                              |
@@ -12,6 +12,7 @@
 |                                                                       |
 +-----------------------------------------------------------------------+
 | Author: Thomas Bruederli <roundcube@gmail.com>                        |
 |         Andreas Dick <andudi (at) gmx (dot) ch>                       |
 +-----------------------------------------------------------------------+

 $Id$
@@ -26,38 +27,89 @@
 */
class rcube_ldap extends rcube_addressbook
{
  var $conn;
  var $prop = array();
  var $fieldmap = array();
  
  var $filter = '';
  var $result = null;
  var $ldap_result = null;
  var $sort_col = '';
  
  protected $conn;
  protected $prop = array();
  protected $fieldmap = array();

  protected $filter = '';
  protected $result = null;
  protected $ldap_result = null;
  protected $sort_col = '';
  protected $mail_domain = '';
  protected $debug = false;

  /** public properties */
  var $primary_key = 'ID';
  var $readonly = true;
  var $list_page = 1;
  var $page_size = 10;
  var $ready = false;
  
  
  public $primary_key = 'ID';
  public $readonly = true;
  public $groups = false;
  public $list_page = 1;
  public $page_size = 10;
  public $group_id = 0;
  public $ready = false;
  public $coltypes = array();

  private $group_cache = array();
  private $group_members = array();


  /**
   * Object constructor
   *
   * @param array LDAP connection properties
   * @param array    LDAP connection properties
   * @param boolean    Enables debug mode
   * @param string    Current user mail domain name
   * @param integer User-ID
   */
  function __construct($p)
  function __construct($p, $debug=false, $mail_domain=NULL)
  {
    $this->prop = $p;
    
    foreach ($p as $prop => $value)
      if (preg_match('/^(.+)_field$/', $prop, $matches))
        $this->fieldmap[$matches[1]] = $value;

    $this->sort_col = $p["sort"];
    // check if groups are configured
    if (is_array($p['groups']))
      $this->groups = true;
    
    // fieldmap property is given
    if (is_array($p['fieldmap'])) {
      foreach ($p['fieldmap'] as $rf => $lf)
        $this->fieldmap[$rf] = $this->_attr_name(strtolower($lf));
    }
    else {
      // read deprecated *_field properties to remain backwards compatible
      foreach ($p as $prop => $value)
        if (preg_match('/^(.+)_field$/', $prop, $matches))
          $this->fieldmap[$matches[1]] = $this->_attr_name(strtolower($value));
    }
    
    // use fieldmap to advertise supported coltypes to the application
    foreach ($this->fieldmap as $col => $lf) {
      list($col, $type) = explode(':', $col);
      if (!is_array($this->coltypes[$col])) {
        $subtypes = $type ? array($type) : null;
        $this->coltypes[$col] = array('limit' => 2, 'subtypes' => $subtypes);
      }
      else if ($type) {
        $this->coltypes[$col]['subtypes'][] = $type;
        $this->coltypes[$col]['limit']++;
      }
      if ($type && !$this->fieldmap[$col])
        $this->fieldmap[$col] = $lf;
    }
    
    if ($this->fieldmap['street'] && $this->fieldmap['locality'])
      $this->coltypes['address'] = array('limit' => 1);
    else if ($this->coltypes['address'])
      $this->coltypes['address'] = array('type' => 'textarea', 'childs' => null, 'limit' => 1, 'size' => 40);

    // make sure 'required_fields' is an array
    if (!is_array($this->prop['required_fields']))
      $this->prop['required_fields'] = (array) $this->prop['required_fields'];

    foreach ($this->prop['required_fields'] as $key => $val)
      $this->prop['required_fields'][$key] = $this->_attr_name(strtolower($val));

    $this->sort_col = $p['sort'];
    $this->debug = $debug;
    $this->mail_domain = $mail_domain;

    $this->connect();
  }
@@ -71,11 +123,13 @@
    global $RCMAIL;
    
    if (!function_exists('ldap_connect'))
      raise_error(array('code' => 100, 'type' => 'ldap', 'message' => "No ldap support in this installation of PHP"), true);
      raise_error(array('code' => 100, 'type' => 'ldap',
        'file' => __FILE__, 'line' => __LINE__,
        'message' => "No ldap support in this installation of PHP"), true);

    if (is_resource($this->conn))
      return true;
    

    if (!is_array($this->prop['hosts']))
      $this->prop['hosts'] = array($this->prop['hosts']);

@@ -84,17 +138,23 @@

    foreach ($this->prop['hosts'] as $host)
    {
      $host = rcube_idn_to_ascii(rcube_parse_host($host));
      $this->_debug("C: Connect [$host".($this->prop['port'] ? ':'.$this->prop['port'] : '')."]");

      if ($lc = @ldap_connect($host, $this->prop['port']))
      {
        if ($this->prop['use_tls']===true)
          if (!ldap_start_tls($lc))
            continue;

        $this->_debug("S: OK");

        ldap_set_option($lc, LDAP_OPT_PROTOCOL_VERSION, $this->prop['ldap_version']);
        $this->prop['host'] = $host;
        $this->conn = $lc;
        break;
      }
      $this->_debug("S: NOT OK");
    }
    
    if (is_resource($this->conn))
@@ -102,27 +162,51 @@
      $this->ready = true;

      // User specific access, generate the proper values to use.
      if ($this->prop["user_specific"]) {
      if ($this->prop['user_specific']) {
        // No password set, use the session password
        if (empty($this->prop['bind_pass'])) {
          $this->prop['bind_pass'] = $RCMAIL->decrypt_passwd($_SESSION["password"]);
          $this->prop['bind_pass'] = $RCMAIL->decrypt($_SESSION['password']);
        }

        // Get the pieces needed for variable replacement.
        $fu = $RCMAIL->user->get_username();
        list($u, $d) = explode('@', $fu);
        
        $dc = 'dc='.strtr($d, array('.' => ',dc=')); // hierarchal domain string

        $replaces = array('%dc' => $dc, '%d' => $d, '%fu' => $fu, '%u' => $u);

        if ($this->prop['search_base_dn'] && $this->prop['search_filter']) {
          // Search for the dn to use to authenticate
          $this->prop['search_base_dn'] = strtr($this->prop['search_base_dn'], $replaces);
          $this->prop['search_filter'] = strtr($this->prop['search_filter'], $replaces);

          $this->_debug("S: searching with base {$this->prop['search_base_dn']} for {$this->prop['search_filter']}");

          $res = ldap_search($this->conn, $this->prop['search_base_dn'], $this->prop['search_filter'], array('uid'));
          if ($res && ($entry = ldap_first_entry($this->conn, $res))) {
            $bind_dn = ldap_get_dn($this->conn, $entry);

            $this->_debug("S: search returned dn: $bind_dn");

            if ($bind_dn) {
              $this->prop['bind_dn'] = $bind_dn;
              $dn = ldap_explode_dn($bind_dn, 1);
              $replaces['%dn'] = $dn[0];
            }
          }
        }
        // Replace the bind_dn and base_dn variables.
        $replaces = array('%fu' => $fu, '%u' => $u, '%d' => $d);
        $this->prop['bind_dn'] = strtr($this->prop['bind_dn'], $replaces);
        $this->prop['base_dn'] = strtr($this->prop['base_dn'], $replaces);
      }
      

      if (!empty($this->prop['bind_dn']) && !empty($this->prop['bind_pass']))
        $this->ready = $this->bind($this->prop['bind_dn'], $this->prop['bind_pass']);
    }
    else
      raise_error(array('code' => 100, 'type' => 'ldap', 'message' => "Could not connect to any LDAP server, tried $host:{$this->prop[port]} last"), true);
      raise_error(array('code' => 100, 'type' => 'ldap',
        'file' => __FILE__, 'line' => __LINE__,
        'message' => "Could not connect to any LDAP server, last tried $host:{$this->prop[port]}"), true);

    // See if the directory is writeable.
    if ($this->prop['writable']) {
@@ -145,13 +229,18 @@
      return false;
    }
    
    $this->_debug("C: Bind [dn: $dn] [pass: $pass]");
    
    if (@ldap_bind($this->conn, $dn, $pass)) {
      $this->_debug("S: OK");
      return true;
    }

    $this->_debug("S: ".ldap_error($this->conn));

    raise_error(array(
        'code' => ldap_errno($this->conn),
        'type' => 'ldap',
        'code' => ldap_errno($this->conn), 'type' => 'ldap',
   'file' => __FILE__, 'line' => __LINE__,
        'message' => "Bind failed for dn=$dn: ".ldap_error($this->conn)),
        true);

@@ -166,7 +255,8 @@
  {
    if ($this->conn)
    {
      @ldap_unbind($this->conn);
      $this->_debug("C: Close");
      ldap_unbind($this->conn);
      $this->conn = null;
    }
  }
@@ -244,19 +334,19 @@
      $filter = $this->prop['filter'];
      $this->set_search_set($filter);
    }
    

    // exec LDAP search if no result resource is stored
    if ($this->conn && !$this->ldap_result)
      $this->_exec_search();
    
    // count contacts for this user
    $this->result = $this->count();
    

    // we have a search result resource
    if ($this->ldap_result && $this->result->count > 0)
    {
      if ($this->sort_col && $this->prop['scope'] !== "base")
        @ldap_sort($this->conn, $this->ldap_result, $this->sort_col);
      if ($this->sort_col && $this->prop['scope'] !== 'base')
        ldap_sort($this->conn, $this->ldap_result, $this->sort_col);

      $start_row = $subset < 0 ? $this->result->first + $this->page_size + $subset : $this->result->first;
      $last_row = $this->result->first + $this->page_size;
@@ -265,6 +355,21 @@
      $entries = ldap_get_entries($this->conn, $this->ldap_result);
      for ($i = $start_row; $i < min($entries['count'], $last_row); $i++)
        $this->result->add($this->_ldap2result($entries[$i]));
    }

    // temp hack for filtering group members
    if ($this->group_id)
    {
        $result = new rcube_result_set();
        while ($record = $this->result->iterate())
        {
            if ($this->group_members[$record['ID']])
            {
                $result->add($record);
                $result->count++;
            }
        }
        $this->result = $result;
    }

    return $this->result;
@@ -276,10 +381,13 @@
   *
   * @param array   List of fields to search in
   * @param string  Search value
   * @param boolean True for strict, False for partial (fuzzy) matching
   * @param boolean True if results are requested, False if count only
   * @param boolean (Not used)
   * @param array   List of fields that cannot be empty
   * @return array  Indexed list of contact records and 'count' value
   */
  function search($fields, $value, $strict=false, $select=true)
  function search($fields, $value, $strict=false, $select=true, $nocount=false, $required=array())
  {
    // special treatment for ID-based search
    if ($fields == 'ID' || $fields == $this->primary_key)
@@ -310,10 +418,19 @@
          $filter .= "($f=$wc" . rcube_ldap::quote_string($value) . "$wc)";
    }
    $filter .= ')';
    

    // add required (non empty) fields filter
    $req_filter = '';
    foreach ((array)$required as $field)
      if ($f = $this->_map_field($field))
        $req_filter .= "($f=*)";

    if (!empty($req_filter))
      $filter = '(&' . $req_filter . $filter . ')';

    // avoid double-wildcard if $value is empty
    $filter = preg_replace('/\*+/', '*', $filter);
    

    // add general filter to query
    if (!empty($this->prop['filter']))
      $filter = '(&(' . preg_replace('/^\(|\)$/', '', $this->prop['filter']) . ')' . $filter . ')';
@@ -381,13 +498,23 @@
    $res = null;
    if ($this->conn && $dn)
    {
      $this->ldap_result = @ldap_read($this->conn, base64_decode($dn), "(objectclass=*)", array_values($this->fieldmap));
      $entry = @ldap_first_entry($this->conn, $this->ldap_result);
      
      $dn = base64_decode($dn);

      $this->_debug("C: Read [dn: $dn] [(objectclass=*)]");
    
      if ($this->ldap_result = @ldap_read($this->conn, $dn, '(objectclass=*)', array_values($this->fieldmap)))
        $entry = ldap_first_entry($this->conn, $this->ldap_result);
      else
        $this->_debug("S: ".ldap_error($this->conn));

      if ($entry && ($rec = ldap_get_attributes($this->conn, $entry)))
      {
        $this->_debug("S: OK"/* . print_r($rec, true)*/);

        $rec = array_change_key_case($rec, CASE_LOWER);

        // Add in the dn for the entry.
        $rec["dn"] = base64_decode($dn);
        $rec['dn'] = $dn;
        $res = $this->_ldap2result($rec);
        $this->result = new rcube_result_set(1);
        $this->result->add($res);
@@ -408,31 +535,45 @@
  {
    // Map out the column names to their LDAP ones to build the new entry.
    $newentry = array();
    $newentry["objectClass"] = $this->prop["LDAP_Object_Classes"];
    foreach ($save_cols as $col => $val) {
      $fld = "";
      $fld = $this->_map_field($col);
      if ($fld != "") {
    $newentry['objectClass'] = $this->prop['LDAP_Object_Classes'];
    foreach ($this->fieldmap as $col => $fld) {
      $val = $save_cols[$col];
      if (is_array($val))
        $val = array_filter($val);  // remove empty entries
      if ($fld && $val) {
        // The field does exist, add it to the entry.
        $newentry[$fld] = $val;
      } // end if
    } // end foreach

    // Verify that the required fields are set.
    // We know that the email address is required as a default of rcube, so
    // we will default its value into any unfilled required fields.
    foreach ($this->prop["required_fields"] as $fld) {
    foreach ($this->prop['required_fields'] as $fld) {
      $missing = null;
      if (!isset($newentry[$fld])) {
        $newentry[$fld] = $newentry[$this->_map_field("email")];
      } // end if
    } // end foreach
        $missing[] = $fld;
      }
    }
    
    // abort process if requiered fields are missing
    // TODO: generate message saying which fields are missing
    if ($missing) {
      $this->set_error(self::ERROR_INCOMPLETE, 'formincomplete');
      return false;
    }

    // Build the new entries DN.
    $dn = $this->prop["LDAP_rdn"]."=".$newentry[$this->prop["LDAP_rdn"]].",".$this->prop['base_dn'];
    $res = @ldap_add($this->conn, $dn, $newentry);
    $dn = $this->prop['LDAP_rdn'].'='.rcube_ldap::quote_string($newentry[$this->prop['LDAP_rdn']], true).','.$this->prop['base_dn'];

    $this->_debug("C: Add [dn: $dn]: ".print_r($newentry, true));

    $res = ldap_add($this->conn, $dn, $newentry);
    if ($res === FALSE) {
      $this->_debug("S: ".ldap_error($this->conn));
      $this->set_error(self::ERROR_SAVING, 'errorsaving');
      return false;
    } // end if

    $this->_debug("S: OK");

    return base64_encode($dn);
  }
@@ -454,10 +595,9 @@
    $newdata = array();
    $replacedata = array();
    $deletedata = array();
    foreach ($save_cols as $col => $val) {
      $fld = "";
      $fld = $this->_map_field($col);
      if ($fld != "") {
    foreach ($this->fieldmap as $col => $fld) {
      $val = $save_cols[$col];
      if ($fld) {
        // The field does exist compare it to the ldap record.
        if ($record[$col] != $val) {
          // Changed, but find out how.
@@ -465,9 +605,9 @@
            // Field was not set prior, need to add it.
            $newdata[$fld] = $val;
          } // end if
          elseif ($val == "") {
          elseif ($val == '') {
            // Field supplied is empty, verify that it is not required.
            if (!in_array($fld, $this->prop["required_fields"])) {
            if (!in_array($fld, $this->prop['required_fields'])) {
              // It is not, safe to clear.
              $deletedata[$fld] = $record[$col];
            } // end if
@@ -480,31 +620,63 @@
      } // end if
    } // end foreach

    // Update the entry as required.
    $dn = base64_decode($id);

    // Update the entry as required.
    if (!empty($deletedata)) {
      // Delete the fields.
      $res = @ldap_mod_del($this->conn, $dn, $deletedata);
      if ($res === FALSE) {
      $this->_debug("C: Delete [dn: $dn]: ".print_r($deletedata, true));
      if (!ldap_mod_del($this->conn, $dn, $deletedata)) {
        $this->_debug("S: ".ldap_error($this->conn));
        $this->set_error(self::ERROR_SAVING, 'errorsaving');
        return false;
      } // end if
      }
      $this->_debug("S: OK");
    } // end if

    if (!empty($replacedata)) {
      // Handle RDN change
      if ($replacedata[$this->prop['LDAP_rdn']]) {
        $newdn = $this->prop['LDAP_rdn'].'='
          .rcube_ldap::quote_string($replacedata[$this->prop['LDAP_rdn']], true)
          .','.$this->prop['base_dn'];
        if ($dn != $newdn) {
          $newrdn = $this->prop['LDAP_rdn'].'='
            .rcube_ldap::quote_string($replacedata[$this->prop['LDAP_rdn']], true);
          unset($replacedata[$this->prop['LDAP_rdn']]);
        }
      }
      // Replace the fields.
      $res = @ldap_mod_replace($this->conn, $dn, $replacedata);
      if ($res === FALSE) {
        return false;
      if (!empty($replacedata)) {
        $this->_debug("C: Replace [dn: $dn]: ".print_r($replacedata, true));
        if (!ldap_mod_replace($this->conn, $dn, $replacedata)) {
          $this->_debug("S: ".ldap_error($this->conn));
          return false;
        }
        $this->_debug("S: OK");
      } // end if
    } // end if

    if (!empty($newdata)) {
      // Add the fields.
      $res = @ldap_mod_add($this->conn, $dn, $newdata);
      if ($res === FALSE) {
      $this->_debug("C: Add [dn: $dn]: ".print_r($newdata, true));
      if (!ldap_mod_add($this->conn, $dn, $newdata)) {
        $this->_debug("S: ".ldap_error($this->conn));
        $this->set_error(self::ERROR_SAVING, 'errorsaving');
        return false;
      } // end if
      }
      $this->_debug("S: OK");
    } // end if

    // Handle RDN change
    if (!empty($newrdn)) {
      $this->_debug("C: Rename [dn: $dn] [dn: $newrdn]");
      if (@ldap_rename($this->conn, $dn, $newrdn, NULL, TRUE)) {
        $this->_debug("S: ".ldap_error($this->conn));
        return base64_encode($newdn);
      }
      $this->_debug("S: OK");
    }

    return true;
  }
@@ -520,19 +692,23 @@
  {
    if (!is_array($ids)) {
      // Not an array, break apart the encoded DNs.
      $dns = explode(",", $ids);
      $dns = explode(',', $ids);
    } // end if

    foreach ($dns as $id) {
      $dn = base64_decode($id);
      $this->_debug("C: Delete [dn: $dn]");
      // Delete the record.
      $res = @ldap_delete($this->conn, $dn);
      $res = ldap_delete($this->conn, $dn);
      if ($res === FALSE) {
        $this->_debug("S: ".ldap_error($this->conn));
        $this->set_error(self::ERROR_SAVING, 'errorsaving');
        return false;
      } // end if
      $this->_debug("S: OK");
    } // end foreach

    return true;
    return count($dns);
  }


@@ -541,23 +717,32 @@
   *
   * @access private
   */
  function _exec_search()
  private function _exec_search()
  {
    if ($this->ready && $this->filter)
    if ($this->ready)
    {
      $filter = $this->filter ? $this->filter : '(objectclass=*)';
      $function = $this->prop['scope'] == 'sub' ? 'ldap_search' : ($this->prop['scope'] == 'base' ? 'ldap_read' : 'ldap_list');
      $this->ldap_result = $function($this->conn, $this->prop['base_dn'], $this->filter, array_values($this->fieldmap), 0, 0);
      return true;

      $this->_debug("C: Search [".$filter."]");

      if ($this->ldap_result = @$function($this->conn, $this->prop['base_dn'], $filter,
          array_values($this->fieldmap), 0, (int) $this->prop['sizelimit'], (int) $this->prop['timelimit'])
      ) {
        $this->_debug("S: ".ldap_count_entries($this->conn, $this->ldap_result)." record(s)");
        return true;
      } else
        $this->_debug("S: ".ldap_error($this->conn));
    }
    else
      return false;
    
    return false;
  }
  
  
  /**
   * @access private
   */
  function _ldap2result($rec)
  private function _ldap2result($rec)
  {
    $out = array();
    
@@ -566,8 +751,18 @@
    
    foreach ($this->fieldmap as $rf => $lf)
    {
      if ($rec[$lf]['count'])
        $out[$rf] = $rec[$lf][0];
      for ($i=0; $i < $rec[$lf]['count']; $i++) {
        if (!($value = $rec[$lf][$i]))
          continue;
        if ($rf == 'email' && $this->mail_domain && !strpos($value, '@'))
          $out[$rf][] = sprintf('%s@%s', $value, $this->mail_domain);
        else if (in_array($rf, array('street','zipcode','locality','country','region')))
          $out['address'][$i][$rf] = $value;
        else if ($rec[$lf]['count'] > 1)
          $out[$rf][] = $value;
        else
          $out[$rf] = $value;
      }
    }
    
    return $out;
@@ -577,21 +772,299 @@
  /**
   * @access private
   */
  function _map_field($field)
  private function _map_field($field)
  {
    return $this->fieldmap[$field];
  }
  
  
  /**
   * @static
   * @access private
   */
  function quote_string($str)
  private function _attr_name($name)
  {
    return strtr($str, array('*'=>'\2a', '('=>'\28', ')'=>'\29', '\\'=>'\5c'));
    // list of known attribute aliases
    $aliases = array(
      'gn' => 'givenname',
      'rfc822mailbox' => 'email',
      'userid' => 'uid',
      'emailaddress' => 'email',
      'pkcs9email' => 'email',
    );
    return isset($aliases[$name]) ? $aliases[$name] : $name;
  }


}
  /**
   * @access private
   */
  private function _debug($str)
  {
    if ($this->debug)
      write_log('ldap', $str);
  }
  

  /**
   * @static
   */
  function quote_string($str, $dn=false)
  {
    // take firt entry if array given
    if (is_array($str))
      $str = reset($str);
    
    if ($dn)
      $replace = array(','=>'\2c', '='=>'\3d', '+'=>'\2b', '<'=>'\3c',
        '>'=>'\3e', ';'=>'\3b', '\\'=>'\5c', '"'=>'\22', '#'=>'\23');
    else
      $replace = array('*'=>'\2a', '('=>'\28', ')'=>'\29', '\\'=>'\5c',
        '/'=>'\2f');

    return strtr($str, $replace);
  }


    /**
     * Setter for the current group
     * (empty, has to be re-implemented by extending class)
     */
    function set_group($group_id)
    {
        if ($group_id)
        {
            if (! $this->group_cache) $this->list_groups();
            $cache = $this->group_cache[$group_id]['members'];

            $members = array();
            for ($i=1; $i<$cache["count"]; $i++)
            {
                $member_dn = base64_encode($cache[$i]);
                $members[$member_dn] = 1;
            }
            $this->group_members = $members;
            $this->group_id = $group_id;
        }
        else $this->group_id = 0;
    }

    /**
     * List all active contact groups of this source
     *
     * @param string  Optional search string to match group name
     * @return array  Indexed list of contact groups, each a hash array
     */
    function list_groups($search = null)
    {
        if (!$this->prop['groups'])
          return array();

        $base_dn = $this->prop['groups']['base_dn'];
        $filter = $this->prop['groups']['filter'];

        $res = ldap_search($this->conn, $base_dn, $filter, array('cn','member'));
        if ($res === false)
        {
            $this->_debug("S: ".ldap_error($this->conn));
            $this->set_error(self::ERROR_SAVING, 'errorsaving');
            return array();
        }
        $ldap_data = ldap_get_entries($this->conn, $res);

        $groups = array();
        $group_sortnames = array();
        for ($i=0; $i<$ldap_data["count"]; $i++)
        {
            $group_name = $ldap_data[$i]['cn'][0];
            $group_id = base64_encode($group_name);
            $groups[$group_id]['ID'] = $group_id;
            $groups[$group_id]['name'] = $group_name;
            $groups[$group_id]['members'] = $ldap_data[$i]['member'];
            $group_sortnames[] = strtolower($group_name);
        }
        array_multisort($group_sortnames, SORT_ASC, SORT_STRING, $groups);

        $this->group_cache = $groups;
        return $groups;
    }

    /**
     * Create a contact group with the given name
     *
     * @param string The group name
     * @return mixed False on error, array with record props in success
     */
    function create_group($group_name)
    {
        if (!$this->group_cache)
            $this->list_groups();

        $base_dn = $this->prop['groups']['base_dn'];
        $new_dn = "cn=$group_name,$base_dn";
        $new_gid = base64_encode($group_name);

        $new_entry = array(
            'objectClass' => array('top', 'groupOfNames'),
            'cn' => $group_name,
            'member' => '',
        );

        $res = ldap_add($this->conn, $new_dn, $new_entry);
        if ($res === false)
        {
            $this->_debug("S: ".ldap_error($this->conn));
            $this->set_error(self::ERROR_SAVING, 'errorsaving');
            return false;
        }
        return array('id' => $new_gid, 'name' => $group_name);
    }

    /**
     * Delete the given group and all linked group members
     *
     * @param string Group identifier
     * @return boolean True on success, false if no data was changed
     */
    function delete_group($group_id)
    {
        if (!$this->group_cache)
            $this->list_groups();

        $base_dn = $this->prop['groups']['base_dn'];
        $group_name = $this->group_cache[$group_id]['name'];

        $del_dn = "cn=$group_name,$base_dn";
        $res = ldap_delete($this->conn, $del_dn);
        if ($res === false)
        {
            $this->_debug("S: ".ldap_error($this->conn));
            $this->set_error(self::ERROR_SAVING, 'errorsaving');
            return false;
        }
        return true;
    }

    /**
     * Rename a specific contact group
     *
     * @param string Group identifier
     * @param string New name to set for this group
     * @return boolean New name on success, false if no data was changed
     */
    function rename_group($group_id, $new_name)
    {
        if (!$this->group_cache)
            $this->list_groups();

        $base_dn = $this->prop['groups']['base_dn'];
        $group_name = $this->group_cache[$group_id]['name'];
        $old_dn = "cn=$group_name,$base_dn";
        $new_rdn = "cn=$new_name";

        $res = ldap_rename($this->conn, $old_dn, $new_rdn, NULL, TRUE);
        if ($res === false)
        {
            $this->_debug("S: ".ldap_error($this->conn));
            $this->set_error(self::ERROR_SAVING, 'errorsaving');
            return false;
        }
        return $new_name;
    }

    /**
     * Add the given contact records the a certain group
     *
     * @param string  Group identifier
     * @param array   List of contact identifiers to be added
     * @return int    Number of contacts added
     */
    function add_to_group($group_id, $contact_ids)
    {
        if (!$this->group_cache)
            $this->list_groups();

        $base_dn = $this->prop['groups']['base_dn'];
        $group_name = $this->group_cache[$group_id]['name'];
        $group_dn = "cn=$group_name,$base_dn";

        $new_attrs = array();
        foreach (explode(",", $contact_ids) as $id)
            $new_attrs['member'][] = base64_decode($id);

        $res = ldap_mod_add($this->conn, $group_dn, $new_attrs);
        if ($res === false)
        {
            $this->_debug("S: ".ldap_error($this->conn));
            $this->set_error(self::ERROR_SAVING, 'errorsaving');
            return 0;
        }
        return count($new_attrs['member']);
    }

    /**
     * Remove the given contact records from a certain group
     *
     * @param string  Group identifier
     * @param array   List of contact identifiers to be removed
     * @return int    Number of deleted group members
     */
    function remove_from_group($group_id, $contact_ids)
    {
        if (!$this->group_cache)
            $this->list_groups();

        $base_dn = $this->prop['groups']['base_dn'];
        $group_name = $this->group_cache[$group_id]['name'];
        $group_dn = "cn=$group_name,$base_dn";

        $del_attrs = array();
        foreach (explode(",", $contact_ids) as $id)
            $del_attrs['member'][] = base64_decode($id);

        $res = ldap_mod_del($this->conn, $group_dn, $del_attrs);
        if ($res === false)
        {
            $this->_debug("S: ".ldap_error($this->conn));
            $this->set_error(self::ERROR_SAVING, 'errorsaving');
            return 0;
        }
        return count($del_attrs['member']);
    }

    /**
     * Get group assignments of a specific contact record
     *
     * @param mixed Record identifier
     *
     * @return array List of assigned groups as ID=>Name pairs
     * @since 0.5-beta
     */
    function get_record_groups($contact_id)
    {
        if (!$this->prop['groups'])
            return array();

        $base_dn = $this->prop['groups']['base_dn'];
        $contact_dn = base64_decode($contact_id);
        $filter = "(member=$contact_dn)";

        $res = ldap_search($this->conn, $base_dn, $filter, array('cn'));
        if ($res === false)
        {
            $this->_debug("S: ".ldap_error($this->conn));
            $this->set_error(self::ERROR_SAVING, 'errorsaving');
            return array();
        }
        $ldap_data = ldap_get_entries($this->conn, $res);

        $groups = array();
        for ($i=0; $i<$ldap_data["count"]; $i++)
        {
            $group_name = $ldap_data[$i]['cn'][0];
            $group_id = base64_encode($group_name);
            $groups[$group_id] = $group_id;
        }
        return $groups;
    }
}