Source for file addressbook.php

Documentation is available at addressbook.php

  1. <?php
  2.  
  3. /**
  4.  * functions/addressbook.php - Functions and classes for the addressbook system
  5.  *
  6.  * Functions require SM_PATH and support of forms.php functions
  7.  *
  8.  * @copyright &copy; 1999-2006 The SquirrelMail Project Team
  9.  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  10.  * @version $Id: addressbook.php,v 1.47.2.21 2006/10/07 11:58:42 tokul Exp $
  11.  * @package squirrelmail
  12.  * @subpackage addressbook
  13.  */
  14.  
  15. /**
  16.  * If SM_PATH isn't defined, define it.  Required to include files.
  17.  * @ignore
  18.  */
  19. if (!defined('SM_PATH'))  {
  20.     define('SM_PATH','../');
  21. }
  22.  
  23. /* make sure that display_messages.php is loaded */
  24. include_once(SM_PATH . 'functions/display_messages.php');
  25.  
  26. global $addrbook_dsn, $addrbook_global_dsn;
  27.  
  28. /**
  29.    Create and initialize an addressbook object.
  30.    Returns the created object
  31. */
  32. function addressbook_init($showerr = true, $onlylocal = false) {
  33.     global $data_dir, $username, $color, $ldap_server, $address_book_global_filename;
  34.     global $addrbook_dsn, $addrbook_table;
  35.     // Shared file based address book globals
  36.     global $abook_global_file, $abook_global_file_writeable, $abook_global_file_listing;
  37.     // Shared DB based address book globals
  38.     global $addrbook_global_dsn, $addrbook_global_table, $addrbook_global_writeable, $addrbook_global_listing;
  39.     // Record size restriction in file based address books
  40.     global $abook_file_line_length;
  41.  
  42.     /* Create a new addressbook object */
  43.     $abook = new AddressBook;
  44.  
  45.     /* Create empty error message */
  46.     $abook_init_error='';
  47.  
  48.     /*
  49.         Always add a local backend. We use *either* file-based *or* a
  50.         database addressbook. If $addrbook_dsn is set, the database
  51.         backend is used. If not, addressbooks are stores in files.
  52.     */
  53.     if (isset($addrbook_dsn) && !empty($addrbook_dsn)) {
  54.         /* Database */
  55.         if (!isset($addrbook_table) || empty($addrbook_table)) {
  56.             $addrbook_table = 'address';
  57.         }
  58.         $r = $abook->add_backend('database', Array('dsn' => $addrbook_dsn,
  59.                             'owner' => $username,
  60.                             'table' => $addrbook_table));
  61.         if (!$r && $showerr) {
  62.             $abook_init_error.=_("Error initializing address book database.") .' '. $abook->error;
  63.         }
  64.     } else {
  65.         /* File */
  66.         $filename = getHashedFile($username, $data_dir, "$username.abook");
  67.         $r = $abook->add_backend('local_file', Array('filename' => $filename,
  68.                                                      'line_length' => $abook_file_line_length,
  69.                                                      'create'   => true));
  70.         if(!$r && $showerr) {
  71.             $abook_init_error.=sprintf( _("Error opening file %s"), $filename );
  72.         }
  73.     }
  74.  
  75.     /* This would be for the global addressbook */
  76.     if (isset($abook_global_file) && isset($abook_global_file_writeable)
  77.         && trim($abook_global_file)!=''){
  78.         // Detect place of address book
  79.         if (! preg_match("/[\/\\\]/",$abook_global_file)) {
  80.             /* no path chars, address book stored in data directory
  81.              * make sure that there is a slash between data directory
  82.              * and address book file name
  83.              */
  84.             $abook_global_filename=$data_dir
  85.                 . ((substr($data_dir, -1) != '/') ? '/' : '')
  86.                 . $abook_global_file;
  87.         } elseif (preg_match("/^\/|\w:/",$abook_global_file)) {
  88.             // full path is set in options (starts with slash or x:)
  89.             $abook_global_filename=$abook_global_file;
  90.         } else {
  91.             $abook_global_filename=SM_PATH . $abook_global_file;
  92.         }
  93.         $r = $abook->add_backend('local_file',array('filename'=>$abook_global_filename,
  94.                                                     'name' => _("Global address book"),
  95.                                                     'detect_writeable' => false,
  96.                                                     'line_length' => $abook_file_line_length,
  97.                                                     'writeable'=> $abook_global_file_writeable,
  98.                                                     'listing' => $abook_global_file_listing));
  99.         if (!$r && $showerr) {
  100.             if ($abook_init_error!='') $abook_init_error.="\n";
  101.             $abook_init_error.=_("Error initializing global address book.") . "\n" . $abook->error;
  102.         }
  103.     }
  104.  
  105.     /* Load global addressbook from SQL if configured */
  106.     if (isset($addrbook_global_dsn) && !empty($addrbook_global_dsn)) {
  107.         /* Database configured */
  108.         if (!isset($addrbook_global_table) || empty($addrbook_global_table)) {
  109.             $addrbook_global_table = 'global_abook';
  110.         }
  111.         $r = $abook->add_backend('database',
  112.                                  Array('dsn' => $addrbook_global_dsn,
  113.                                        'owner' => 'global',
  114.                                        'name' => _("Global address book"),
  115.                                        'writeable' => $addrbook_global_writeable,
  116.                                        'listing' => $addrbook_global_listing,
  117.                                        'table' => $addrbook_global_table));
  118.         if (!$r && $showerr) {
  119.             if ($abook_init_error!='') $abook_init_error.="\n";
  120.             $abook_init_error.=_("Error initializing global address book.") . "\n" . $abook->error;
  121.     }
  122.     }
  123.  
  124.     /*
  125.      * hook allows to include different address book backends.
  126.      * plugins should extract $abook and $r from arguments
  127.      * and use same add_backend commands as above functions.
  128.      * @since 1.5.1 and 1.4.5
  129.      */
  130.     $hookReturn = do_hook('abook_init', $abook, $r);
  131.     $abook = $hookReturn[1];
  132.     $r = $hookReturn[2];
  133.  
  134.     if (! $onlylocal) {
  135.     /* Load configured LDAP servers (if PHP has LDAP support) */
  136.     if (isset($ldap_server) && is_array($ldap_server) && function_exists('ldap_connect')) {
  137.         reset($ldap_server);
  138.         while (list($undef,$param) = each($ldap_server)) {
  139.             if (is_array($param)) {
  140.                 $r = $abook->add_backend('ldap_server', $param);
  141.                 if (!$r && $showerr) {
  142.                         if ($abook_init_error!='') $abook_init_error.="\n";
  143.                         $abook_init_error.=sprintf(_("Error initializing LDAP server %s:") .
  144.                             "\n", $param['host']);
  145.                         $abook_init_error.= $abook->error;
  146.                     }
  147.                 }
  148.             }
  149.         }
  150.     } // end of remote abook backends init
  151.  
  152.     /**
  153.      * display address book init errors.
  154.      */
  155.     if ($abook_init_error!='' && $showerr) {
  156.         $abook_init_error = htmlspecialchars($abook_init_error);
  157.         error_box($abook_init_error,$color);
  158.     }
  159.  
  160.     /* Return the initialized object */
  161.     return $abook;
  162. }
  163.  
  164.  
  165. /*
  166.  *   Had to move this function outside of the Addressbook Class
  167.  *   PHP 4.0.4 Seemed to be having problems with inline functions.
  168.  */
  169. function addressbook_cmp($a,$b) {
  170.  
  171.     if($a['backend'] > $b['backend']) {
  172.         return 1;
  173.     } else if($a['backend'] < $b['backend']) {
  174.         return -1;
  175.     }
  176.  
  177.     return (strtolower($a['name']) > strtolower($b['name'])) ? 1 : -1;
  178.  
  179. }
  180.  
  181. /**
  182.  * Sort array by the key "name"
  183.  */
  184. function alistcmp($a,$b) {
  185.     $abook_sort_order=get_abook_sort();
  186.  
  187.     switch ($abook_sort_order) {
  188.     case 0:
  189.     case 1:
  190.       $abook_sort='nickname';
  191.       break;
  192.     case 4:
  193.     case 5:
  194.       $abook_sort='email';
  195.       break;
  196.     case 6:
  197.     case 7:
  198.       $abook_sort='label';
  199.       break;
  200.     case 2:
  201.     case 3:
  202.     case 8:
  203.     default:
  204.       $abook_sort='name';
  205.     }
  206.  
  207.     if ($a['backend'] > $b['backend']) {
  208.         return 1;
  209.     } else {
  210.         if ($a['backend'] < $b['backend']) {
  211.             return -1;
  212.         }
  213.     }
  214.  
  215.     if( (($abook_sort_order+2) % 2) == 1) {
  216.       return (strtolower($a[$abook_sort]) < strtolower($b[$abook_sort])) ? 1 : -1;
  217.     } else {
  218.       return (strtolower($a[$abook_sort]) > strtolower($b[$abook_sort])) ? 1 : -1;
  219.     }
  220. }
  221.  
  222. /**
  223.  * Address book sorting options
  224.  *
  225.  * returns address book sorting order
  226.  * @return integer book sorting options order
  227.  */
  228. function get_abook_sort() {
  229.     global $data_dir, $username;
  230.  
  231.     /* get sorting order */
  232.     if(sqgetGlobalVar('abook_sort_order', $temp, SQ_GET)) {
  233.       $abook_sort_order = (int) $temp;
  234.  
  235.       if ($abook_sort_order < 0 or $abook_sort_order > 8)
  236.         $abook_sort_order=8;
  237.  
  238.       setPref($data_dir, $username, 'abook_sort_order', $abook_sort_order);
  239.     } else {
  240.       /* get previous sorting options. default to unsorted */
  241.       $abook_sort_order = getPref($data_dir, $username, 'abook_sort_order', 8);
  242.     }
  243.  
  244.     return $abook_sort_order;
  245. }
  246.  
  247. /**
  248.  * This function shows the address book sort button.
  249.  *
  250.  * @param integer $abook_sort_order current sort value
  251.  * @param string $alt_tag alt tag value (string visible to text only browsers)
  252.  * @param integer $Down sort value when list is sorted ascending
  253.  * @param integer $Up sort value when list is sorted descending
  254.  * @return string html code with sorting images and urls
  255.  * @since 1.5.1 and 1.4.6
  256.  */
  257. function show_abook_sort_button($abook_sort_order, $alt_tag, $Down, $Up ) {
  258.     global $form_url;
  259.  
  260.      /* Figure out which image we want to use. */
  261.     if ($abook_sort_order != $Up && $abook_sort_order != $Down) {
  262.         $img = 'sort_none.png';
  263.         $which = $Up;
  264.     } elseif ($abook_sort_order == $Up) {
  265.         $img = 'up_pointer.png';
  266.         $which = $Down;
  267.     } else {
  268.         $img = 'down_pointer.png';
  269.         $which = 8;
  270.     }
  271.  
  272.       /* Now that we have everything figured out, show the actual button. */
  273.     return ' <a href="' . $form_url .'?abook_sort_order=' . $which
  274.          . '"><img src="../images/' . $img
  275.          . '" border="0" width="12" height="10" alt="' . $alt_tag . '" title="'
  276.          . _("Click here to change the sorting of the address list") .'" /></a>';
  277. }
  278.  
  279.  
  280. /**
  281.  * This is the main address book class that connect all the
  282.  * backends and provide services to the functions above.
  283.  * @package squirrelmail
  284.  */
  285.  
  286. class AddressBook {
  287.  
  288.     var $backends    = array();
  289.     var $numbackends = 0;
  290.     var $error       = '';
  291.     var $localbackend = 0;
  292.     var $localbackendname = '';
  293.     var $add_extra_field = false;
  294.  
  295.       // Constructor function.
  296.         function AddressBook() {
  297.         $this->localbackendname = _("Personal address book");
  298.     }
  299.  
  300.     /*
  301.      * Return an array of backends of a given type,
  302.      * or all backends if no type is specified.
  303.      */
  304.     function get_backend_list($type = '') {
  305.         $ret = array();
  306.         for ($i = 1 ; $i <= $this->numbackends ; $i++) {
  307.             if (empty($type) || $type == $this->backends[$i]->btype) {
  308.                 $ret[] = &$this->backends[$i];
  309.             }
  310.         }
  311.         return $ret;
  312.     }
  313.  
  314.  
  315.     /*
  316.        ========================== Public ========================
  317.  
  318.         Add a new backend. $backend is the name of a backend
  319.         (without the abook_ prefix), and $param is an optional
  320.         mixed variable that is passed to the backend constructor.
  321.         See each of the backend classes for valid parameters.
  322.      */
  323.     function add_backend($backend, $param = '') {
  324.         $backend_name = 'abook_' . $backend;
  325.         eval('$newback = new ' . $backend_name . '($param);');
  326.         if(!empty($newback->error)) {
  327.             $this->error = $newback->error;
  328.             return false;
  329.         }
  330.  
  331.         $this->numbackends++;
  332.  
  333.         $newback->bnum = $this->numbackends;
  334.         $this->backends[$this->numbackends] = $newback;
  335.  
  336.         /* Store ID of first local backend added */
  337.         if ($this->localbackend == 0 && $newback->btype == 'local') {
  338.             $this->localbackend = $this->numbackends;
  339.             $this->localbackendname = $newback->sname;
  340.         }
  341.  
  342.         return $this->numbackends;
  343.     }
  344.  
  345.  
  346.     /*
  347.      * This function takes a $row array as returned by the addressbook
  348.      * search and returns an e-mail address with the full name or
  349.      * nickname optionally prepended.
  350.      */
  351.  
  352.     function full_address($row) {
  353.         global $addrsrch_fullname, $data_dir, $username;
  354.         $prefix = getPref($data_dir, $username, 'addrsrch_fullname');
  355.         if (($prefix != "" || (isset($addrsrch_fullname) &&
  356.             $prefix == $addrsrch_fullname)) && $prefix != 'noprefix') {
  357.             $name = ($prefix == 'nickname' ? $row['nickname'] : $row['name']);
  358.             return $name . ' <' . trim($row['email']) . '>';
  359.         } else {
  360.             return trim($row['email']);
  361.         }
  362.     }
  363.  
  364.     /*
  365.         Return a list of addresses matching expression in
  366.         all backends of a given type.
  367.     */
  368.     function search($expression, $bnum = -1) {
  369.         $ret = array();
  370.         $this->error = '';
  371.  
  372.         /* Search all backends */
  373.         if ($bnum == -1) {
  374.             $sel = $this->get_backend_list('');
  375.             $failed = 0;
  376.             for ($i = 0 ; $i < sizeof($sel) ; $i++) {
  377.                 $backend = &$sel[$i];
  378.                 $backend->error = '';
  379.                 $res = $backend->search($expression);
  380.                 if (is_array($res)) {
  381.                     $ret = array_merge($ret, $res);
  382.                 } else {
  383.                     $this->error .= "\n" . $backend->error;
  384.                     $failed++;
  385.                 }
  386.             }
  387.  
  388.             /* Only fail if all backends failed */
  389.             if( $failed >= sizeof( $sel ) ) {
  390.                 $ret = FALSE;
  391.             }
  392.  
  393.         }  else {
  394.  
  395.             /* Search only one backend */
  396.  
  397.             $ret = $this->backends[$bnum]->search($expression);
  398.             if (!is_array($ret)) {
  399.                 $this->error .= "\n" . $this->backends[$bnum]->error;
  400.                 $ret = FALSE;
  401.             }
  402.         }
  403.  
  404.         return( $ret );
  405.     }
  406.  
  407.  
  408.     /* Return a sorted search */
  409.     function s_search($expression, $bnum = -1) {
  410.  
  411.         $ret = $this->search($expression, $bnum);
  412.         if ( is_array( $ret ) ) {
  413.             usort($ret, 'addressbook_cmp');
  414.         }
  415.         return $ret;
  416.     }
  417.  
  418.  
  419.     /*
  420.      *  Lookup an address by alias. Only possible in
  421.      *  local backends.
  422.      */
  423.     function lookup($alias, $bnum = -1) {
  424.  
  425.         $ret = array();
  426.  
  427.         if ($bnum > -1) {
  428.             $res = $this->backends[$bnum]->lookup($alias);
  429.             if (is_array($res)) {
  430.                return $res;
  431.             } else {
  432.                $this->error = $this->backends[$bnum]->error;
  433.                return false;
  434.             }
  435.         }
  436.  
  437.         $sel = $this->get_backend_list('local');
  438.         for ($i = 0 ; $i < sizeof($sel) ; $i++) {
  439.             $backend = &$sel[$i];
  440.             $backend->error = '';
  441.             $res = $backend->lookup($alias);
  442.             if (is_array($res)) {
  443.                if(!empty($res))
  444.               return $res;
  445.             } else {
  446.                $this->error = $backend->error;
  447.                return false;
  448.             }
  449.         }
  450.  
  451.         return $ret;
  452.     }
  453.  
  454.  
  455.     /* Return all addresses */
  456.     function list_addr($bnum = -1) {
  457.         $ret = array();
  458.  
  459.         if ($bnum == -1) {
  460.             $sel = $this->get_backend_list('');
  461.         } else {
  462.             $sel = array(0 => &$this->backends[$bnum]);
  463.         }
  464.  
  465.         for ($i = 0 ; $i < sizeof($sel) ; $i++) {
  466.             $backend = &$sel[$i];
  467.             $backend->error = '';
  468.             $res = $backend->list_addr();
  469.             if (is_array($res)) {
  470.                $ret = array_merge($ret, $res);
  471.             } else {
  472.                $this->error = $backend->error;
  473.                return false;
  474.             }
  475.         }
  476.  
  477.         return $ret;
  478.     }
  479.  
  480.     /*
  481.      * Create a new address from $userdata, in backend $bnum.
  482.      * Return the backend number that the/ address was added
  483.      * to, or false if it failed.
  484.      */
  485.     function add($userdata, $bnum) {
  486.  
  487.         /* Validate data */
  488.         if (!is_array($userdata)) {
  489.             $this->error = _("Invalid input data");
  490.             return false;
  491.         }
  492.         if (empty($userdata['firstname']) && empty($userdata['lastname'])) {
  493.             $this->error = _("Name is missing");
  494.             return false;
  495.         }
  496.         if (empty($userdata['email'])) {
  497.             $this->error = _("E-mail address is missing");
  498.             return false;
  499.         }
  500.         if (empty($userdata['nickname'])) {
  501.             $userdata['nickname'] = $userdata['email'];
  502.         }
  503.  
  504.         if (eregi('[ \\:\\|\\#\\"\\!]', $userdata['nickname'])) {
  505.             $this->error = _("Nickname contains illegal characters");
  506.             return false;
  507.         }
  508.  
  509.         /* Check that specified backend accept new entries */
  510.         if (!$this->backends[$bnum]->writeable) {
  511.             $this->error = _("Address book is read-only");
  512.             return false;
  513.         }
  514.  
  515.         /* Add address to backend */
  516.         $res = $this->backends[$bnum]->add($userdata);
  517.         if ($res) {
  518.             return $bnum;
  519.         } else {
  520.             $this->error = $this->backends[$bnum]->error;
  521.             return false;
  522.         }
  523.  
  524.         return false;  // Not reached
  525.     } /* end of add() */
  526.  
  527.  
  528.     /*
  529.      * Remove the user identified by $alias from backend $bnum
  530.      * If $alias is an array, all users in the array are removed.
  531.      */
  532.     function remove($alias, $bnum) {
  533.  
  534.         /* Check input */
  535.         if (empty($alias)) {
  536.             return true;
  537.         }
  538.  
  539.         /* Convert string to single element array */
  540.         if (!is_array($alias)) {
  541.             $alias = array(0 => $alias);
  542.         }
  543.  
  544.         /* Check that specified backend is writable */
  545.         if (!$this->backends[$bnum]->writeable) {
  546.             $this->error = _("Address book is read-only");
  547.             return false;
  548.         }
  549.  
  550.         /* Remove user from backend */
  551.         $res = $this->backends[$bnum]->remove($alias);
  552.         if ($res) {
  553.             return $bnum;
  554.         } else {
  555.             $this->error = $this->backends[$bnum]->error;
  556.             return false;
  557.         }
  558.  
  559.         return FALSE;  /* Not reached */
  560.     } /* end of remove() */
  561.  
  562.  
  563.     /*
  564.      * Remove the user identified by $alias from backend $bnum
  565.      * If $alias is an array, all users in the array are removed.
  566.      */
  567.     function modify($alias, $userdata, $bnum) {
  568.  
  569.         /* Check input */
  570.         if (empty($alias) || !is_string($alias)) {
  571.             return true;
  572.         }
  573.  
  574.         /* Validate data */
  575.         if(!is_array($userdata)) {
  576.             $this->error = _("Invalid input data");
  577.             return false;
  578.         }
  579.         if (empty($userdata['firstname']) && empty($userdata['lastname'])) {
  580.             $this->error = _("Name is missing");
  581.             return false;
  582.         }
  583.         if (empty($userdata['email'])) {
  584.             $this->error = _("E-mail address is missing");
  585.             return false;
  586.         }
  587.  
  588.         if (eregi('[\\: \\|\\#"\\!]', $userdata['nickname'])) {
  589.             $this->error = _("Nickname contains illegal characters");
  590.             return false;
  591.         }
  592.  
  593.         if (empty($userdata['nickname'])) {
  594.             $userdata['nickname'] = $userdata['email'];
  595.         }
  596.  
  597.         /* Check that specified backend is writable */
  598.         if (!$this->backends[$bnum]->writeable) {
  599.             $this->error = _("Address book is read-only");;
  600.             return false;
  601.         }
  602.  
  603.         /* Modify user in backend */
  604.         $res = $this->backends[$bnum]->modify($alias, $userdata);
  605.         if ($res) {
  606.             return $bnum;
  607.         } else {
  608.             $this->error = $this->backends[$bnum]->error;
  609.             return false;
  610.         }
  611.  
  612.         return FALSE;  /* Not reached */
  613.     } /* end of modify() */
  614.  
  615.  
  616. } /* End of class Addressbook */
  617.  
  618. /**
  619.  * Generic backend that all other backends extend
  620.  * @package squirrelmail
  621.  */
  622. class addressbook_backend {
  623.  
  624.     /* Variables that all backends must provide. */
  625.     var $btype      = 'dummy';
  626.     var $bname      = 'dummy';
  627.     var $sname      = 'Dummy backend';
  628.  
  629.     /*
  630.      * Variables common for all backends, but that
  631.      * should not be changed by the backends.
  632.      */
  633.     var $bnum       = -1;
  634.     var $error      = '';
  635.     var $writeable  = false;
  636.  
  637.     function set_error($string) {
  638.         $this->error = '[' . $this->sname . '] ' . $string;
  639.         return false;
  640.     }
  641.  
  642.  
  643.     /* ========================== Public ======================== */
  644.  
  645.     function search($expression) {
  646.         $this->set_error('search not implemented');
  647.         return false;
  648.     }
  649.  
  650.     function lookup($alias) {
  651.         $this->set_error('lookup not implemented');
  652.         return false;
  653.     }
  654.  
  655.     function list_addr() {
  656.         $this->set_error('list_addr not implemented');
  657.         return false;
  658.     }
  659.  
  660.     function add($userdata) {
  661.         $this->set_error('add not implemented');
  662.         return false;
  663.     }
  664.  
  665.     function remove($alias) {
  666.         $this->set_error('delete not implemented');
  667.         return false;
  668.     }
  669.  
  670.     function modify($alias, $newuserdata) {
  671.         $this->set_error('modify not implemented');
  672.         return false;
  673.     }
  674.  
  675. }
  676.  
  677. /*
  678.   PHP 5 requires that the class be made first, which seems rather
  679.   logical, and should have been the way it was generated the first time.
  680. */
  681.  
  682. require_once(SM_PATH . 'functions/abook_local_file.php');
  683. require_once(SM_PATH . 'functions/abook_ldap_server.php');
  684.  
  685. /* Only load database backend if database is configured */
  686. if((isset($addrbook_dsn) && !empty($addrbook_dsn)) ||
  687.  (isset($addrbook_global_dsn) && !empty($addrbook_global_dsn))) {
  688.   include_once(SM_PATH . 'functions/abook_database.php');
  689. }
  690.  
  691. /*
  692.  * hook allows adding different address book classes.
  693.  * class must follow address book class coding standards.
  694.  *
  695.  * see addressbook_backend class and functions/abook_*.php files.
  696.  * @since 1.5.1 and 1.4.5
  697.  */
  698. do_hook('abook_add_class');
  699. ?>

Documentation generated on Sat, 07 Oct 2006 16:29:47 +0300 by phpDocumentor 1.3.0RC6