include/emails.inc.php

   1 <?php
   2 /***************************************************************************
   3  *  Copyright (C) 2003-2011 Polytechnique.org                              *
   4  *  http://opensource.polytechnique.org/                                   *
   5  *                                                                         *
   6  *  This program is free software; you can redistribute it and/or modify   *
   7  *  it under the terms of the GNU General Public License as published by   *
   8  *  the Free Software Foundation; either version 2 of the License, or      *
   9  *  (at your option) any later version.                                    *
  10  *                                                                         *
  11  *  This program is distributed in the hope that it will be useful,        *
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  14  *  GNU General Public License for more details.                           *
  15  *                                                                         *
  16  *  You should have received a copy of the GNU General Public License      *
  17  *  along with this program; if not, write to the Free Software            *
  18  *  Foundation, Inc.,                                                      *
  19  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA                *
  20  ***************************************************************************/
  21
  22 define('SUCCESS', 1);
  23 define('ERROR_INACTIVE_REDIRECTION', 2);
  24 define('ERROR_INVALID_EMAIL', 3);
  25 define('ERROR_LOOP_EMAIL', 4);
  26
  27 // Checks if an email update is required in MLs and aliases.
  28 // This occurs when the user don't have email permissions and her email has changed.
  29 function require_email_update(User $user, $new_email)
  30 {
  31     Platal::assert(!is_null($user), 'User cannot be null.');
  32
  33     return !$user->checkPerms(User::PERM_MAIL) && strtolower($new_email) != strtolower($user->forlifeEmail());
  34 }
  35
  36 function format_email_alias($email)
  37 {
  38     if ($user = User::getSilent($email)) {
  39         return $user->forlifeEmail();
  40     }
  41     if (isvalid_email($email)) {
  42         return $email;
  43     }
  44     return null;
  45 }
  46
  47 function add_to_list_alias($email, $local_part, $domain, $type = 'alias')
  48 {
  49     $email = format_email_alias($email);
  50     if (is_null($email)) {
  51         return false;
  52     }
  53
  54     XDB::execute('INSERT IGNORE INTO  email_virtual (email, domain, redirect, type)
  55                               SELECT  {?}, id, {?}, {?}
  56                                 FROM  email_virtual_domains
  57                                WHERE  name = {?}',
  58                  $local_part, $email, $type, $domain);
  59     return true;
  60 }
  61
  62 function delete_from_list_alias($email, $local_part, $domain, $type = 'alias')
  63 {
  64     $email = format_email_alias($email);
  65     if (is_null($email)) {
  66         return false;
  67     }
  68
  69     XDB::execute('DELETE  v
  70                     FROM  email_virtual         AS v
  71               INNER JOIN  email_virtual_domains AS m ON (v.domain = m.id)
  72               INNER JOIN  email_virtual_domains AS d ON (d.aliasing = m.id)
  73                    WHERE  v.email = {?} AND d.name = {?} AND v.redirect = {?} AND type = {?}',
  74                  $local_part, $domain, $email, $type);
  75     return true;
  76 }
  77
  78 function update_list_alias($email, $former_email, $local_part, $domain, $type = 'alias')
  79 {
  80     $email = format_email_alias($email);
  81     if (is_null($email)) {
  82         return false;
  83     }
  84
  85     XDB::execute('UPDATE  email_virtual         AS v
  86               INNER JOIN  email_virtual_domains AS d ON (v.domain = d.id)
  87                      SET  v.redirect = {?}
  88                    WHERE  v.redirect = {?} AND d.name = {?} AND v.email = {?} AND v.type = {?}',
  89                  $email, $former_email, $domain, $local_part, $type);
  90     return true;
  91 }
  92
  93 // Updates an email in all aliases (groups and events).
  94 function update_alias_user($former_email, $new_email)
  95 {
  96     XDB::execute('UPDATE  email_virtual
  97                      SET  redirect = {?}
  98                    WHERE  redirect = {?} AND (type = \'alias\' OR type = \'event\')',
  99                  $new_email, $former_email);
 100 }
 101
 102 function list_alias_members($local_part, $domain)
 103 {
 104     $emails = XDB::fetchColumn('SELECT  DISTINCT(redirect)
 105                                   FROM  email_virtual         AS v
 106                             INNER JOIN  email_virtual_domains AS m ON (v.domain = m.id)
 107                             INNER JOIN  email_virtual_domains AS d ON (d.aliasing = m.id)
 108                                  WHERE  v.email = {?} AND d.name = {?} AND type = \'alias\'',
 109                                $local_part, $domain);
 110
 111     $users = array();
 112     $nonusers = array();
 113     foreach ($emails as $email) {
 114         if ($user = User::getSilent($email)) {
 115             $users[] = $user;
 116         } else {
 117             $nonusers[] = $email;
 118         }
 119     }
 120
 121     return array(
 122         'users'    => $users,
 123         'nonusers' => $nonusers
 124     );
 125 }
 126
 127 function delete_list_alias($local_part, $domain)
 128 {
 129     XDB::execute('DELETE  v
 130                     FROM  email_virtual         AS v
 131               INNER JOIN  email_virtual_domains AS m ON (v.domain = m.id)
 132               INNER JOIN  email_virtual_domains AS d ON (d.aliasing = m.id)
 133                    WHERE  v.email = {?} AND d.name = {?} AND type = \'alias\'',
 134                  $local_part, $domain);
 135 }
 136
 137 function iterate_list_alias($domain)
 138 {
 139     return XDB::fetchColumn('SELECT  CONCAT(v.email, \'@\', m.name)
 140                                FROM  email_virtual         AS v
 141                          INNER JOIN  email_virtual_domains AS m ON (v.domain = m.id)
 142                               WHERE  m.name = {?} AND v.type = \'alias\'
 143                            GROUP BY  v.email',
 144                             $domain);
 145 }
 146
 147 function create_list($local_part, $domain)
 148 {
 149     global $globals;
 150
 151     $redirect = $domain . '_' . $local_part . '+';
 152     foreach(array('post', 'owner', 'admin', 'bounces', 'unsubscribe') as $suffix) {
 153         XDB::execute('INSERT IGNORE INTO  email_virtual (email, domain, redirect, type)
 154                                   SELECT  {?}, id, {?}, \'list\'
 155                                     FROM  email_virtual_domains
 156                                    WHERE  name = {?}',
 157                      ($suffix == 'post') ? $local_part : $local_part . '-' . $suffix,
 158                      $redirect . $suffix . '@' . $globals->lists->redirect_domain, $domain);
 159     }
 160 }
 161
 162 function delete_list($local_part, $domain)
 163 {
 164     global $globals;
 165
 166     $redirect = $domain . '_' . $local_part . '+';
 167     foreach(array('post', 'owner', 'admin', 'bounces', 'unsubscribe') as $suffix) {
 168         XDB::execute('DELETE FROM  email_virtual
 169                             WHERE  redirect = {?} AND type = \'list\'',
 170                      $redirect . $suffix . '@' . $globals->lists->redirect_domain);
 171     }
 172 }
 173
 174 function list_exist($local_part, $domain)
 175 {
 176     return XDB::fetchOneCell('SELECT  COUNT(*)
 177                                 FROM  email_virtual         AS v
 178                           INNER JOIN  email_virtual_domains AS m ON (v.domain = m.id)
 179                           INNER JOIN  email_virtual_domains AS d ON (m.id = d.aliasing)
 180                                WHERE  v.email = {?} AND d.name = {?}',
 181                              $local_part, $domain);
 182 }
 183
 184 // function mark_broken_email() {{{1
 185 function mark_broken_email($email, $admin = false)
 186 {
 187     $email = valide_email($email);
 188     if (empty($email) || $email == '@') {
 189         return;
 190     }
 191
 192     $user = XDB::fetchOneAssoc('SELECT  r1.uid, a.hruid, a.full_name, r1.broken_level != 0 AS broken, COUNT(r2.uid) AS nb_mails,
 193                                         s.email AS alias, DATE_ADD(r1.last, INTERVAL 14 DAY) < CURDATE() as notify
 194                                   FROM  email_redirect_account AS r1
 195                             INNER JOIN  accounts               AS a  ON (a.uid = r1.uid)
 196                             INNER JOIN  email_source_account   AS s  ON (a.uid = s.uid AND s.flags = \'bestalias\')
 197                              LEFT JOIN  email_redirect_account AS r2 ON (a.uid = r2.uid AND r1.redirect != r2.redirect AND
 198                                                                          r2.broken_level = 0 AND r2.flags = \'active\' AND
 199                                                                          (r2.type = \'smtp\' OR r2.type = \'googleapps\'))
 200                                  WHERE  r1.redirect = {?}
 201                               GROUP BY  r1.uid', $email);
 202
 203     if ($user) {
 204         // Mark address as broken.
 205         if (!$user['broken']) {
 206             XDB::execute('UPDATE  email_redirect_account
 207                              SET  broken_date = NOW(), last = NOW(), broken_level = 1
 208                            WHERE  redirect = {?}', $email);
 209         } elseif ($admin) {
 210             XDB::execute('UPDATE  email_redirect_account
 211                              SET  last = CURDATE(), broken_level = broken_level + 1
 212                            WHERE  redirect = {?} AND DATE_ADD(last, INTERVAL 14 DAY) < CURDATE()',
 213                          $email);
 214         } else {
 215             XDB::execute('UPDATE  email_redirect_account
 216                              SET  broken_level = 1
 217                            WHERE  redirect = {?} AND broken_level = 0', $email);
 218         }
 219     }
 220
 221     return $user;
 222 }
 223
 224 // function fix_bestalias() {{{1
 225 // Checks for an existing 'bestalias' among the the current user's aliases, and
 226 // eventually selects a new bestalias when required.
 227 function fix_bestalias(User $user)
 228 {
 229     // First check if the bestalias is properly set.
 230     $alias_count = XDB::fetchOneCell('SELECT  COUNT(*)
 231                                         FROM  email_source_account
 232                                        WHERE  uid = {?} AND FIND_IN_SET(\'bestalias\', flags) AND expire IS NULL',
 233                                      $user->id());
 234
 235     if ($alias_count > 1) {
 236         // If too many bestaliases, delete the bestalias flag from all this
 237         // user's emails (this should never happen).
 238         XDB::execute("UPDATE  email_source_account
 239                          SET  flags = TRIM(BOTH ',' FROM REPLACE(CONCAT(',', flags, ','), ',bestalias,', ','))
 240                        WHERE  uid = {?}",
 241                      $user->id());
 242     }
 243      if ($alias_count != 1) {
 244         // If no bestalias is selected, we choose the shortest email which is not
 245         // related to a usage name and contains a '.'.
 246         XDB::execute("UPDATE  email_source_account
 247                          SET  flags = CONCAT_WS(',', IF(flags = '', NULL, flags), 'bestalias')
 248                        WHERE  uid = {?} AND expire IS NULL
 249                     ORDER BY  NOT FIND_IN_SET('usage', flags), email LIKE '%.%', LENGTH(email)
 250                        LIMIT  1",
 251                      $user->id());
 252      }
 253
 254     // First check if best_domain is properly set.
 255     $domain_count = XDB::fetchOneCell('SELECT  COUNT(*)
 256                                          FROM  accounts              AS a
 257                                    INNER JOIN  email_source_account  AS s ON (s.uid = a.uid AND FIND_IN_SET(\'bestalias\', s.flags))
 258                                    INNER JOIN  email_virtual_domains AS d ON (d.id = a.best_domain)
 259                                    INNER JOIN  email_virtual_domains AS m ON (d.aliasing = m.id)
 260                                    INNER JOIN  email_virtual_domains AS v ON (v.aliasing = m.id AND v.id = s.domain)
 261                                         WHERE  a.uid = {?} AND (m.name = {?} OR m.name = {?})',
 262                                       $user->id(), $user->mainEmailDomain(), Platal::globals()->mail->alias_dom);
 263
 264     if ($domain_count == 0) {
 265         XDB::execute('UPDATE  accounts              AS a
 266                   INNER JOIN  email_source_account  AS s ON (s.uid = a.uid AND FIND_IN_SET(\'bestalias\', s.flags))
 267                   INNER JOIN  email_virtual_domains AS d ON (d.aliasing = s.domain AND (d.name = {?} OR d.name = {?}))
 268                          SET  a.best_domain = d.id
 269                        WHERE  a.uid = {?}',
 270                      $user->mainEmailDomain(), Platal::globals()->mail->alias_dom, $user->id());
 271     }
 272
 273
 274 }
 275
 276 // function valide_email() {{{1
 277 // Returns a cleaned-up version of the @p email string. It removes garbage
 278 // characters, and determines the canonical form (without _ and +) for
 279 // Polytechnique.org email addresses.
 280 function valide_email($str)
 281 {
 282     global $globals;
 283
 284     $em = trim(rtrim($str));
 285     $em = str_replace('<', '', $em);
 286     $em = str_replace('>', '', $em);
 287     if (strpos($em, '@') === false) {
 288         return;
 289     }
 290     list($ident, $dom) = explode('@', $em);
 291     if (User::isMainMailDomain($dom)) {
 292         list($ident1) = explode('_', $ident);
 293         list($ident) = explode('+', $ident1);
 294     }
 295     return $ident . '@' . $dom;
 296 }
 297
 298 // function isvalid_email_redirection() {{{1
 299 /** Checks if an email is a suitable redirection.
 300  * @param $email the email to check
 301  * @param $user  the user asking for the redirection
 302  * @return BOOL
 303  */
 304 function isvalid_email_redirection($email, User $user)
 305 {
 306     $valid = isvalid_email($email) && User::isForeignEmailAddress($email);
 307     if (!$user->hasProfile() || ($user->profile()->grad_year > date('Y') - 3)) {
 308         return $valid && !preg_match("/@polytechnique\.edu$/", $email);
 309     } else {
 310         return $valid;
 311     }
 312 }
 313
 314 // function ids_from_mails() {{{1
 315 // Converts an array of emails to an array of email => uid, where email is the
 316 // given email when we found a matching user.
 317 function ids_from_mails(array $emails)
 318 {
 319     // Removes duplicates, if any.
 320     $emails = array_unique($emails);
 321
 322     // Formats and splits by domain type (locally managed or external) emails.
 323     $main_domain_emails = array();
 324     $aux_domain_emails = array();
 325     $other_emails = array();
 326     foreach ($emails as $email) {
 327         if (strpos($email, '@') === false) {
 328             $main_domain_emails[] = $email;
 329         } else {
 330             if (User::isForeignEmailAddress($email)) {
 331                 $other_emails[$email] = strtolower($user . '@' . $domain);
 332             } else {
 333                 list($local_part, $domain) = explode('@', $email);
 334                 list($local_part) = explode('+', $local_part);
 335                 list($local_part) = explode('_', $local_part);
 336                 if (User::isMainMailDomain($domain)) {
 337                     $main_domain_emails[$email] = strtolower($local_part);
 338                 } elseif (User::isAliasMailDomain($domain)) {
 339                     $aux_domain_emails[$email] = strtolower($local_part);
 340                 }
 341             }
 342         }
 343     }
 344
 345     // Retrieves emails from our domains.
 346     $main_domain_uids = XDB::fetchAllAssoc('email',
 347                                            'SELECT  email, uid
 348                                               FROM  email_source_account
 349                                              WHERE  email IN {?} AND type != \'alias_aux\'',
 350                                            array_unique($main_domain_emails));
 351     $aux_domain_uids = XDB::fetchAllAssoc('email',
 352                                           'SELECT  email, uid
 353                                              FROM  email_source_account
 354                                             WHERE  email IN {?} AND type = \'alias_aux\'',
 355                                           array_unique($aux_domain_emails));
 356
 357     // Retrieves emails from redirections.
 358     $other_uids = XDB::fetchAllAssoc('redirect',
 359                                      'SELECT  redirect, uid
 360                                         FROM  email_redirect_account
 361                                        WHERE  redirect IN {?}',
 362                                      array_unique($other_emails));
 363
 364     // Associates given emails with the corresponding uid.
 365     $uids = array();
 366     foreach ($main_domain_emails as $email => $key) {
 367         $uids[$email] = $main_domain_uids[$key];
 368     }
 369     foreach ($aux_domain_emails as $email => $key) {
 370         $uids[$email] = $aux_domain_uids[$key];
 371     }
 372     foreach ($other_emails as $email => $key) {
 373         $uids[$email] = $other_uids[$key];
 374     }
 375
 376     return array_unique($uids);
 377 }
 378
 379 // class Bogo {{{1
 380 // The Bogo class represents a spam filtering level in plat/al architecture.
 381 class Bogo
 382 {
 383     const MAIN_DEFAULT = 'default';
 384     const IMAP_DEFAULT = 'let_spams';
 385
 386     public static $states = array(
 387         0 => 'default',
 388         1 => 'let_spams',
 389         2 => 'tag_spams',
 390         3 => 'tag_and_drop_spams',
 391         4 => 'drop_spams'
 392     );
 393
 394     private $user;
 395     public $state;
 396     public $single_state;
 397     public $redirections;
 398     public $single_redirection;
 399
 400     public function __construct(User $user)
 401     {
 402         if (!$user) {
 403             return;
 404         }
 405
 406         $this->user = &$user;
 407         $res = XDB::fetchOneAssoc('SELECT  COUNT(DISTINCT(action)) AS action_count, COUNT(redirect) AS redirect_count, action
 408                                      FROM  email_redirect_account
 409                                     WHERE  uid = {?} AND (type = \'smtp\' OR type = \'googleapps\') AND flags = \'active\'
 410                                  GROUP BY  uid',
 411                                   $user->id());
 412         if ($res['redirect_count'] == 0) {
 413             return;
 414         }
 415
 416         $this->single_redirection = ($res['redirect_count'] == 1);
 417         $this->redirections = XDB::fetchAllAssoc('SELECT  IF(type = \'googleapps\', type, redirect) AS redirect, type, action
 418                                                     FROM  email_redirect_account
 419                                                    WHERE  uid = {?} AND (type = \'smtp\' OR type = \'googleapps\')
 420                                                 ORDER BY  type, redirect',
 421                                                  $user->id());
 422
 423         foreach ($this->redirections AS &$redirection) {
 424             $redirection['filter'] = array_search($redirection['action'], self::$states);
 425         }
 426         if ($res['action_count'] == 1) {
 427             $this->state = array_search($res['action'], self::$states);
 428             $this->single_state = true;
 429         } else {
 430             $this->single_state = $this->state = false;
 431         }
 432     }
 433
 434     public function changeAll($state)
 435     {
 436         Platal::assert($state >= 0 && $state < count(self::$states), 'Unknown antispam level.');
 437
 438         $this->state = $state;
 439         XDB::execute('UPDATE  email_redirect_account
 440                          SET  action = {?}
 441                        WHERE  uid = {?} AND (type = \'smtp\' OR type = \'googleapps\')',
 442                      self::$states[$this->state], $this->user->id());
 443     }
 444
 445     public function change($redirection, $state)
 446     {
 447         Platal::assert($state >= 0 && $state < count(self::$states), 'Unknown antispam level.');
 448
 449         XDB::execute('UPDATE  email_redirect_account
 450                          SET  action = {?}
 451                        WHERE  uid = {?} AND (type = {?} OR redirect = {?})',
 452                      self::$states[$state], $this->user->id(), $redirection, $redirection);
 453     }
 454 }
 455
 456 // class Email {{{1
 457 // Represents an "email address" used as final recipient for plat/al-managed
 458 // addresses.
 459 class Email
 460 {
 461     // Lists fields to load automatically.
 462     static private $field_names = array('rewrite', 'type', 'action', 'broken_date', 'broken_level', 'last', 'hash', 'allow_rewrite');
 463
 464     // Shortname to realname mapping for known mail storage backends.
 465     static private $display_names = array(
 466         'imap'       => 'Accès de secours aux emails (IMAP)',
 467         'googleapps' => 'Compte Google Apps',
 468     );
 469     static private $storage_domains = array(
 470         'imap'       => 'imap',
 471         'googleapps' => 'g'
 472     );
 473
 474     private $user;
 475
 476     // Basic email properties; $sufficient indicates if the email can be used as
 477     // an unique redirection; $redirect contains the delivery email address.
 478     public $id;
 479     public $type;
 480     public $sufficient;
 481     public $email;
 482     public $display_email;
 483     public $domain;
 484     public $action;
 485     public $filter_level;
 486
 487     // Redirection status properties.
 488     public $active;
 489     public $inactive;
 490     public $broken;
 491     public $disabled;
 492     public $rewrite;
 493     public $allow_rewrite;
 494     public $hash;
 495
 496     // Redirection bounces stats.
 497     public $last;
 498     public $broken_level;
 499     public $broken_date;
 500
 501     public function __construct(User $user, array $row)
 502     {
 503         foreach (self::$field_names as $field) {
 504             if (array_key_exists($field, $row)) {
 505                 $this->$field = $row[$field];
 506             }
 507         }
 508         $this->email = $row['redirect'];
 509
 510         if (array_key_exists($this->type, Email::$display_names)) {
 511             $this->display_email = self::$display_names[$this->type];
 512         } else {
 513             $this->display_email = $this->email;
 514         }
 515         foreach (array('active', 'inactive', 'broken', 'disabled') as $status) {
 516             $this->$status = ($status == $row['flags']);
 517         }
 518         $this->sufficient = ($this->type == 'smtp' || $this->type == 'googleapps');
 519         $this->filter_level = ($this->type == 'imap') ? null : array_search($this->action, Bogo::$states);
 520         if (array_key_exists($this->type , self::$storage_domains)) {
 521             $this->id = $this->type;
 522         } else {
 523             $this->id = str_replace(array('@', '.'), array('_at_', '_dot_'), $this->email);
 524         }
 525         $this->user = &$user;
 526     }
 527
 528     // Activates the email address as a redirection.
 529     public function activate()
 530     {
 531         if ($this->inactive) {
 532             if (in_array($this->type, self::get_allowed_storages($this->user))) {
 533                 self::activate_storage($this->user, $this->type, $this->action);
 534             } else {
 535                 XDB::execute('UPDATE  email_redirect_account
 536                                  SET  broken_level = IF(flags = \'broken\', broken_level - 1, broken_level), flags = \'active\'
 537                                WHERE  uid = {?} AND redirect = {?}',
 538                              $this->user->id(), $this->email);
 539             }
 540             S::logger()->log('email_on', $this->email . ($this->user->id() != S::v('uid') ? "(admin on {$this->user->login()})" : ''));
 541             $this->inactive = false;
 542             $this->active   = true;
 543         }
 544     }
 545
 546     // Deactivates the email address as a redirection.
 547     public function deactivate()
 548     {
 549         if ($this->active) {
 550             if (in_array($this->type, self::get_allowed_storages($this->user))) {
 551                 self::deactivate_storage($this->user, $this->type);
 552             } else {
 553                 XDB::execute('UPDATE  email_redirect_account
 554                                  SET  flags = \'inactive\'
 555                                WHERE  uid = {?} AND redirect = {?}',
 556                              $this->user->id(), $this->email);
 557             }
 558             S::logger()->log('email_off', $this->email . ($this->user->id() != S::v('uid') ? "(admin on {$this->user->login()})" : "") );
 559             $this->inactive = true;
 560             $this->active   = false;
 561         }
 562     }
 563
 564
 565     // Sets the rewrite rule for the given address.
 566     public function set_rewrite($rewrite)
 567     {
 568         if ($this->type != 'smtp' || $this->rewrite == $rewrite) {
 569             return;
 570         }
 571         if (!$rewrite || !isvalid_email($rewrite)) {
 572             $rewrite = '';
 573         }
 574         XDB::execute('UPDATE  email_redirect_account
 575                          SET  rewrite = {?}
 576                        WHERE  uid = {?} AND redirect = {?} AND type = \'smtp\'',
 577                      $rewrite, $this->user->id(), $this->email);
 578         $this->rewrite = $rewrite;
 579         if (!$this->allow_rewrite) {
 580             global $globals;
 581             if (empty($this->hash)) {
 582                 $this->hash = rand_url_id();
 583                 XDB::execute('UPDATE  email_redirect_account
 584                                  SET  hash = {?}
 585                                WHERE  uid = {?} AND redirect = {?} AND type = \'smtp\'',
 586                              $this->hash, $this->user->id(), $this->email);
 587             }
 588             $mail = new PlMailer('emails/rewrite-in.mail.tpl');
 589             $mail->assign('mail', $this);
 590             $mail->assign('user', $this->user);
 591             $mail->assign('baseurl', $globals->baseurl);
 592             $mail->assign('sitename', $globals->core->sitename);
 593             $mail->assign('to', $this->email);
 594             $mail->send($this->user->isEmailFormatHtml());
 595         }
 596     }
 597
 598
 599     // Resets the error counts associated with the redirection.
 600     public function clean_errors()
 601     {
 602         if ($this->type != 'smtp') {
 603             return;
 604         }
 605         if (!S::admin()) {
 606             return false;
 607         }
 608         $this->broken       = 0;
 609         $this->broken_level = 0;
 610         $this->last         = 0;
 611         return XDB::execute('UPDATE  email_redirect_account
 612                                 SET  broken_level = 0, broken_date = 0, last = 0
 613                               WHERE  uid = {?} AND redirect = {?} AND type = \'smtp\'',
 614                             $this->user->id(), $this->email);
 615     }
 616
 617
 618     // Email backend capabilities ('rewrite' refers to From: rewrite for mails
 619     // forwarded by Polytechnique.org's MXs; 'removable' indicates if the email
 620     // can be definitively removed; 'disable' indicates if the email has a third
 621     // status 'disabled' in addition to 'active' and 'inactive').
 622     public function has_rewrite()
 623     {
 624         return ($this->type == 'smtp');
 625     }
 626
 627     public function is_removable()
 628     {
 629         return ($this->type == 'smtp');
 630     }
 631
 632     public function has_disable()
 633     {
 634         return true;
 635     }
 636
 637     public function is_redirection()
 638     {
 639         return ($this->type == 'smtp');
 640     }
 641
 642     // Returns the list of allowed storages for the @p user.
 643     static public function get_allowed_storages(User $user)
 644     {
 645         global $globals;
 646         $storages = array();
 647
 648         // Google Apps storage is available for users with valid Google Apps account.
 649         require_once 'googleapps.inc.php';
 650         if ($user->checkPerms('gapps') &&
 651             $globals->mailstorage->googleapps_domain &&
 652             GoogleAppsAccount::account_status($user->id()) == 'active') {
 653             $storages[] = 'googleapps';
 654         }
 655
 656         // IMAP storage is always visible to administrators, and is allowed for
 657         // everyone when the service is marked as 'active'.
 658         if ($globals->mailstorage->imap_active || S::admin()) {
 659             $storages[] = 'imap';
 660         }
 661
 662         return $storages;
 663     }
 664
 665     static public function make_storage_redirection(User $user, $storage)
 666     {
 667         return $user->hruid . '@' . self::$storage_domains[$storage] . '.' . Platal::globals()->mail->domain;
 668     }
 669
 670     static public function activate_storage(User $user, $storage, $action = null)
 671     {
 672         Platal::assert(in_array($storage, self::get_allowed_storages($user)), 'Unknown storage.');
 673
 674         // We first need to retrieve the value for the antispam filter if not
 675         // provided: it is either the user's redirections common value, or if
 676         // they differ, our default value.
 677         if (is_null($action)) {
 678             $bogo = new Bogo($user);
 679             $action = ($bogo->single_state ? Bogo::$states[$bogo->state] : Bogo::MAIN_DEFAULT);
 680         }
 681
 682         if (!self::is_active_storage($user, $storage)) {
 683             XDB::execute('INSERT INTO  email_redirect_account (uid, type, action, redirect, flags)
 684                                VALUES  ({?}, {?}, {?}, {?}, \'active\')',
 685                          $user->id(), $storage, $action, self::make_storage_redirection($user, $storage));
 686         }
 687     }
 688
 689     static public function deactivate_storage(User $user, $storage)
 690     {
 691         if (in_array($storage, self::get_allowed_storages($user))) {
 692             XDB::execute('DELETE FROM  email_redirect_account
 693                                 WHERE  uid = {?} AND type = {?}',
 694                          $user->id(), $storage);
 695             }
 696     }
 697
 698     static public function is_active_storage(User $user, $storage)
 699     {
 700         if (!in_array($storage, self::get_allowed_storages($user))) {
 701             return false;
 702         }
 703         $res = XDB::fetchOneCell('SELECT  COUNT(*)
 704                                     FROM  email_redirect_account
 705                                    WHERE  uid = {?} AND type = {?} AND flags = \'active\'',
 706                                  $user->id(), $storage);
 707         return !is_null($res) && $res > 0;
 708     }
 709 }
 710 // class Redirect {{{1
 711 // Redirect is a placeholder class for an user's active redirections (third-party
 712 // redirection email, or Polytechnique.org mail storages).
 713 class Redirect
 714 {
 715     private $flags = 'active';
 716     private $user;
 717
 718     public $emails;
 719
 720     public function __construct(User $user)
 721     {
 722         $this->user = &$user;
 723
 724         // Adds third-party email redirections.
 725         $res = XDB::iterator('SELECT  redirect, rewrite, type, action, broken_date, broken_level, last, flags, hash, allow_rewrite
 726                                 FROM  email_redirect_account
 727                                WHERE  uid = {?} AND type != \'homonym\'',
 728                             $user->id());
 729         $this->emails = array();
 730         while ($row = $res->next()) {
 731             $this->emails[] = new Email($user, $row);
 732         }
 733
 734         if ($storages = Email::get_allowed_storages($user)) {
 735             // We first need to retrieve the value for the antispam filter: it is
 736             // either the user's redirections common value, or if they differ, our
 737             // default value.
 738             $bogo = new Bogo($user);
 739             $filter = ($bogo->single_state ? Bogo::$states[$bogo->state] : Bogo::MAIN_DEFAULT);
 740
 741             foreach ($storages as $storage) {
 742                 if (!Email::is_active_storage($user, $storage)) {
 743                     $this->emails[] = new Email($user, array(
 744                             'redirect'      => Email::make_storage_redirection($user, $storage),
 745                             'rewrite'       => '',
 746                             'type'          => $storage,
 747                             'action'        => $filter,
 748                             'broken_date'   => 0,
 749                             'broken_level'  => '0000-00-00',
 750                             'last'          => '0000-00-00',
 751                             'flags'         => 'inactive',
 752                             'hash'          => '',
 753                             'allow_rewrite' => 0));
 754                 }
 755             }
 756         }
 757     }
 758
 759     public function other_active($email)
 760     {
 761         foreach ($this->emails as $mail) {
 762             if ($mail->email != $email && $mail->active && $mail->sufficient) {
 763                 return true;
 764             }
 765         }
 766         return false;
 767     }
 768
 769     public function delete_email($email)
 770     {
 771         if (!$this->other_active($email)) {
 772             return ERROR_INACTIVE_REDIRECTION;
 773         }
 774         XDB::execute('DELETE FROM  email_redirect_account
 775                             WHERE  uid = {?} AND redirect = {?} AND type != \'homonym\'',
 776                      $this->user->id(), $email);
 777         S::logger()->log('email_del', $email . ($this->user->id() != S::v('uid') ? " (admin on {$this->user->login()})" : ""));
 778         foreach ($this->emails as $i => $mail) {
 779             if ($email == $mail->email) {
 780                 unset($this->emails[$i]);
 781             }
 782         }
 783         check_redirect($this);
 784         $this->update_imap();
 785         return SUCCESS;
 786     }
 787
 788     public function add_email($email)
 789     {
 790         $email_stripped = strtolower(trim($email));
 791         if (!isvalid_email($email_stripped)) {
 792             return ERROR_INVALID_EMAIL;
 793         }
 794         if (!isvalid_email_redirection($email_stripped, $this->user)) {
 795             return ERROR_LOOP_EMAIL;
 796         }
 797         // We first need to retrieve the value for the antispam filter: it is
 798         // either the user's redirections common value, or if they differ, our
 799         // default value.
 800         $bogo = new Bogo($this->user);
 801         $filter = ($bogo->single_state ? Bogo::$states[$bogo->state] : Bogo::MAIN_DEFAULT);
 802         // If the email was already present for this user, we reset it to the default values, we thus use REPLACE INTO.
 803         XDB::execute('REPLACE INTO  email_redirect_account (uid, redirect, flags, action)
 804                             VALUES  ({?}, {?}, \'active\', {?})',
 805                      $this->user->id(), $email, $filter);
 806         if ($logger = S::v('log', null)) { // may be absent --> step4.php
 807             S::logger()->log('email_add', $email . ($this->user->id() != S::v('uid') ? " (admin on {$this->user->login()})" : ""));
 808         }
 809         foreach ($this->emails as $mail) {
 810             if ($mail->email == $email_stripped) {
 811                 return SUCCESS;
 812             }
 813         }
 814         $this->emails[] = new Email($this->user, array(
 815                 'redirect'      => $email,
 816                 'rewrite'       => '',
 817                 'type'          => 'smtp',
 818                 'action'        => $filter,
 819                 'broken_date'   => '0000-00-00',
 820                 'broken_level'  => 0,
 821                 'last'          => '0000-00-00',
 822                 'flags'         => 'active',
 823                 'hash'          => null,
 824                 'allow_rewrite' => 0
 825         ));
 826
 827         // security stuff
 828         check_email($email, "Ajout d'une adresse surveillée aux redirections de " . $this->user->login());
 829         check_redirect($this);
 830         $this->update_imap();
 831         return SUCCESS;
 832     }
 833
 834     public function modify_email($emails_actifs, $emails_rewrite)
 835     {
 836         foreach ($this->emails as &$email) {
 837             if (in_array($email->email, $emails_actifs)) {
 838                 $email->activate();
 839             } else {
 840                 $email->deactivate();
 841             }
 842             $email->set_rewrite($emails_rewrite[$email->email]);
 843         }
 844         check_redirect($this);
 845         $this->update_imap();
 846         return SUCCESS;
 847     }
 848
 849     public function modify_one_email($email, $activate)
 850     {
 851         $allinactive = true;
 852         $thisone = false;
 853         foreach ($this->emails as $i=>$mail) {
 854             if ($mail->email == $email) {
 855                 $thisone = $i;
 856             }
 857             $allinactive &= !$mail->active || !$mail->sufficient || $mail->email == $email;
 858         }
 859         if ($thisone === false) {
 860             return ERROR_INVALID_EMAIL;
 861         }
 862         if ($allinactive || $activate) {
 863             $this->emails[$thisone]->activate();
 864         } else {
 865             $this->emails[$thisone]->deactivate();
 866         }
 867         check_redirect($this);
 868         $this->update_imap();
 869         if ($allinactive && !$activate) {
 870             return ERROR_INACTIVE_REDIRECTION;
 871         }
 872         return SUCCESS;
 873     }
 874
 875     public function modify_one_email_redirect($email, $redirect)
 876     {
 877         foreach ($this->emails as &$mail) {
 878             if ($mail->email == $email) {
 879                 $mail->set_rewrite($redirect);
 880                 check_redirect($this);
 881                 $this->update_imap();
 882                 return;
 883             }
 884         }
 885     }
 886
 887     public function clean_errors($email)
 888     {
 889         foreach ($this->emails as &$mail) {
 890             if ($mail->email == $email) {
 891                 check_redirect($this);
 892                 $this->update_imap();
 893                 return $mail->clean_errors();
 894             }
 895         }
 896         return false;
 897     }
 898
 899     public function disable()
 900     {
 901         XDB::execute("UPDATE  email_redirect_account
 902                          SET  flags = 'disable'
 903                        WHERE  flags = 'active' AND uid = {?}", $this->user->id());
 904         foreach ($this->emails as &$mail) {
 905             if ($mail->active && $mail->has_disable()) {
 906                 $mail->disabled = true;
 907                 $mail->active   = false;
 908             }
 909         }
 910         check_redirect($this);
 911         $this->update_imap();
 912     }
 913
 914     public function enable()
 915     {
 916         XDB::execute("UPDATE  email_redirect_account
 917                          SET  flags = 'active'
 918                        WHERE  flags = 'disable' AND uid = {?}", $this->user->id());
 919         foreach ($this->emails as &$mail) {
 920             if ($mail->disabled) {
 921                 $mail->disabled = false;
 922                 $mail->active   = true;
 923             }
 924             check_redirect($this);
 925         }
 926         $this->update_imap();
 927     }
 928
 929     public function get_broken_mx()
 930     {
 931         $res = XDB::query("SELECT  host, text
 932                              FROM  mx_watch
 933                             WHERE  state != 'ok'");
 934         if (!$res->numRows()) {
 935             return array();
 936         }
 937         $mxs = $res->fetchAllAssoc();
 938         $mails = array();
 939         foreach ($this->emails as &$mail) {
 940             if ($mail->active && strstr($mail->email, '@') !== false) {
 941                 list(,$domain) = explode('@', $mail->email);
 942                 getmxrr($domain, $lcl_mxs);
 943                 if (empty($lcl_mxs)) {
 944                     $lcl_mxs = array($domain);
 945                 }
 946                 $broken = false;
 947                 foreach ($mxs as &$mx) {
 948                     foreach ($lcl_mxs as $lcl) {
 949                         if (fnmatch($mx['host'], $lcl)) {
 950                             $broken = $mx['text'];
 951                             break;
 952                         }
 953                     }
 954                     if ($broken) {
 955                         $mails[] = array('mail' => $mail->email, 'text' => $broken);
 956                         break;
 957                     }
 958                 }
 959             }
 960         }
 961         return $mails;
 962     }
 963
 964     public function active_emails()
 965     {
 966         $emails = array();
 967         foreach ($this->emails as $mail) {
 968             if ($mail->active) {
 969                 $emails[] = $mail;
 970             }
 971         }
 972         return $emails;
 973     }
 974
 975     public function get_uid()
 976     {
 977         return $this->user->id();
 978     }
 979
 980     private function update_imap()
 981     {
 982         // Imaps must bounce if and only if the user has no active redirection.
 983         if (!$this->other_active('')) {
 984             XDB::execute('UPDATE  email_redirect_account
 985                              SET  action = \'imap_and_bounce\'
 986                            WHERE  type = \'imap\' AND uid = {?}',
 987                          $this->user->id());
 988         } else {
 989             XDB::execute('UPDATE  email_redirect_account
 990                              SET  action = \'let_spams\'
 991                            WHERE  type = \'imap\' AND uid = {?}',
 992                          $this->user->id());
 993         }
 994     }
 995 }
 996
 997 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8:
 998 ?>