inc/Mailer.class.php

   1 <?php
   2
   3 /**
   4  * A class to build and send multi part mails (with HTML content and embedded
   5  * attachments). All mails are assumed to be in UTF-8 encoding.
   6  *
   7  * Attachments are handled in memory so this shouldn't be used to send huge
   8  * files, but then again mail shouldn't be used to send huge files either.
   9  *
  10  * @author Andreas Gohr <andi@splitbrain.org>
  11  */
  12
  13 use dokuwiki\Utf8\PhpString;
  14 use dokuwiki\Utf8\Clean;
  15 use dokuwiki\Extension\Event;
  16
  17 /**
  18  * Mail Handling
  19  */
  20 class Mailer
  21 {
  22     protected $headers   = [];
  23     protected $attach    = [];
  24     protected $html      = '';
  25     protected $text      = '';
  26
  27     protected $boundary  = '';
  28     protected $partid    = '';
  29     protected $sendparam;
  30
  31     protected $allowhtml = true;
  32
  33     protected $replacements = ['text' => [], 'html' => []];
  34
  35     /**
  36      * Constructor
  37      *
  38      * Initializes the boundary strings, part counters and token replacements
  39      */
  40     public function __construct()
  41     {
  42         global $conf;
  43         /* @var Input $INPUT */
  44         global $INPUT;
  45
  46         $server = parse_url(DOKU_URL, PHP_URL_HOST);
  47         if (strpos($server, '.') === false) $server .= '.localhost';
  48
  49         $this->partid   = substr(md5(uniqid(random_int(0, mt_getrandmax()), true)), 0, 8) . '@' . $server;
  50         $this->boundary = '__________' . md5(uniqid(random_int(0, mt_getrandmax()), true));
  51
  52         $listid = implode('.', array_reverse(explode('/', DOKU_BASE))) . $server;
  53         $listid = strtolower(trim($listid, '.'));
  54
  55         $messageid = uniqid(random_int(0, mt_getrandmax()), true) . "@$server";
  56
  57         $this->allowhtml = (bool)$conf['htmlmail'];
  58
  59         // add some default headers for mailfiltering FS#2247
  60         if (!empty($conf['mailreturnpath'])) {
  61             $this->setHeader('Return-Path', $conf['mailreturnpath']);
  62         }
  63         $this->setHeader('X-Mailer', 'DokuWiki');
  64         $this->setHeader('X-DokuWiki-User', $INPUT->server->str('REMOTE_USER'));
  65         $this->setHeader('X-DokuWiki-Title', $conf['title']);
  66         $this->setHeader('X-DokuWiki-Server', $server);
  67         $this->setHeader('X-Auto-Response-Suppress', 'OOF');
  68         $this->setHeader('List-Id', $conf['title'] . ' <' . $listid . '>');
  69         $this->setHeader('Date', date('r'), false);
  70         $this->setHeader('Message-Id', "<$messageid>");
  71
  72         $this->prepareTokenReplacements();
  73     }
  74
  75     /**
  76      * Attach a file
  77      *
  78      * @param string $path  Path to the file to attach
  79      * @param string $mime  Mimetype of the attached file
  80      * @param string $name The filename to use
  81      * @param string $embed Unique key to reference this file from the HTML part
  82      */
  83     public function attachFile($path, $mime, $name = '', $embed = '')
  84     {
  85         if (!$name) {
  86             $name = PhpString::basename($path);
  87         }
  88
  89         $this->attach[] = [
  90             'data'  => file_get_contents($path),
  91             'mime'  => $mime,
  92             'name'  => $name,
  93             'embed' => $embed
  94         ];
  95     }
  96
  97     /**
  98      * Attach a file
  99      *
 100      * @param string $data  The file contents to attach
 101      * @param string $mime  Mimetype of the attached file
 102      * @param string $name  The filename to use
 103      * @param string $embed Unique key to reference this file from the HTML part
 104      */
 105     public function attachContent($data, $mime, $name = '', $embed = '')
 106     {
 107         if (!$name) {
 108             [, $ext] = explode('/', $mime);
 109             $name = count($this->attach) . ".$ext";
 110         }
 111
 112         $this->attach[] = [
 113             'data'  => $data,
 114             'mime'  => $mime,
 115             'name'  => $name,
 116             'embed' => $embed
 117         ];
 118     }
 119
 120     /**
 121      * Callback function to automatically embed images referenced in HTML templates
 122      *
 123      * @param array $matches
 124      * @return string placeholder
 125      */
 126     protected function autoEmbedCallBack($matches)
 127     {
 128         static $embeds = 0;
 129         $embeds++;
 130
 131         // get file and mime type
 132         $media = cleanID($matches[1]);
 133         [, $mime] = mimetype($media);
 134         $file = mediaFN($media);
 135         if (!file_exists($file)) return $matches[0]; //bad reference, keep as is
 136
 137         // attach it and set placeholder
 138         $this->attachFile($file, $mime, '', 'autoembed' . $embeds);
 139         return '%%autoembed' . $embeds . '%%';
 140     }
 141
 142     /**
 143      * Add an arbitrary header to the mail
 144      *
 145      * If an empy value is passed, the header is removed
 146      *
 147      * @param string $header the header name (no trailing colon!)
 148      * @param string|string[] $value  the value of the header
 149      * @param bool   $clean  remove all non-ASCII chars and line feeds?
 150      */
 151     public function setHeader($header, $value, $clean = true)
 152     {
 153         $header = str_replace(' ', '-', ucwords(strtolower(str_replace('-', ' ', $header)))); // streamline casing
 154         if ($clean) {
 155             $header = preg_replace('/[^a-zA-Z0-9_ \-\.\+\@]+/', '', $header);
 156             $value  = preg_replace('/[^a-zA-Z0-9_ \-\.\+\@<>]+/', '', $value);
 157         }
 158
 159         // empty value deletes
 160         if (is_array($value)) {
 161             $value = array_map('trim', $value);
 162             $value = array_filter($value);
 163             if (!$value) $value = '';
 164         } else {
 165             $value = trim($value);
 166         }
 167         if ($value === '') {
 168             if (isset($this->headers[$header])) unset($this->headers[$header]);
 169         } else {
 170             $this->headers[$header] = $value;
 171         }
 172     }
 173
 174     /**
 175      * Set additional parameters to be passed to sendmail
 176      *
 177      * Whatever is set here is directly passed to PHP's mail() command as last
 178      * parameter. Depending on the PHP setup this might break mailing alltogether
 179      *
 180      * @param string $param
 181      */
 182     public function setParameters($param)
 183     {
 184         $this->sendparam = $param;
 185     }
 186
 187     /**
 188      * Set the text and HTML body and apply replacements
 189      *
 190      * This function applies a whole bunch of default replacements in addition
 191      * to the ones specified as parameters
 192      *
 193      * If you pass the HTML part or HTML replacements yourself you have to make
 194      * sure you encode all HTML special chars correctly
 195      *
 196      * @param string $text     plain text body
 197      * @param array  $textrep  replacements to apply on the text part
 198      * @param array  $htmlrep  replacements to apply on the HTML part, null to use $textrep (urls wrapped in <a> tags)
 199      * @param string $html     the HTML body, leave null to create it from $text
 200      * @param bool   $wrap     wrap the HTML in the default header/Footer
 201      */
 202     public function setBody($text, $textrep = null, $htmlrep = null, $html = null, $wrap = true)
 203     {
 204
 205         $htmlrep = (array)$htmlrep;
 206         $textrep = (array)$textrep;
 207
 208         // create HTML from text if not given
 209         if ($html === null) {
 210             $html = $text;
 211             $html = hsc($html);
 212             $html = preg_replace('/^----+$/m', '<hr >', $html);
 213             $html = nl2br($html);
 214         }
 215         if ($wrap) {
 216             $wrapper = rawLocale('mailwrap', 'html');
 217             $html = preg_replace('/\n-- <br \/>.*$/s', '', $html); //strip signature
 218             $html = str_replace('@EMAILSIGNATURE@', '', $html); //strip @EMAILSIGNATURE@
 219             $html = str_replace('@HTMLBODY@', $html, $wrapper);
 220         }
 221
 222         if (strpos($text, '@EMAILSIGNATURE@') === false) {
 223             $text .= '@EMAILSIGNATURE@';
 224         }
 225
 226         // copy over all replacements missing for HTML (autolink URLs)
 227         foreach ($textrep as $key => $value) {
 228             if (isset($htmlrep[$key])) continue;
 229             if (media_isexternal($value)) {
 230                 $htmlrep[$key] = '<a href="' . hsc($value) . '">' . hsc($value) . '</a>';
 231             } else {
 232                 $htmlrep[$key] = hsc($value);
 233             }
 234         }
 235
 236         // embed media from templates
 237         $html = preg_replace_callback(
 238             '/@MEDIA\(([^\)]+)\)@/',
 239             [$this, 'autoEmbedCallBack'],
 240             $html
 241         );
 242
 243         // add default token replacements
 244         $trep = array_merge($this->replacements['text'], $textrep);
 245         $hrep = array_merge($this->replacements['html'], $htmlrep);
 246
 247         // Apply replacements
 248         foreach ($trep as $key => $substitution) {
 249             $text = str_replace('@' . strtoupper($key) . '@', $substitution, $text);
 250         }
 251         foreach ($hrep as $key => $substitution) {
 252             $html = str_replace('@' . strtoupper($key) . '@', $substitution, $html);
 253         }
 254
 255         $this->setHTML($html);
 256         $this->setText($text);
 257     }
 258
 259     /**
 260      * Set the HTML part of the mail
 261      *
 262      * Placeholders can be used to reference embedded attachments
 263      *
 264      * You probably want to use setBody() instead
 265      *
 266      * @param string $html
 267      */
 268     public function setHTML($html)
 269     {
 270         $this->html = $html;
 271     }
 272
 273     /**
 274      * Set the plain text part of the mail
 275      *
 276      * You probably want to use setBody() instead
 277      *
 278      * @param string $text
 279      */
 280     public function setText($text)
 281     {
 282         $this->text = $text;
 283     }
 284
 285     /**
 286      * Add the To: recipients
 287      *
 288      * @see cleanAddress
 289      * @param string|string[]  $address Multiple adresses separated by commas or as array
 290      */
 291     public function to($address)
 292     {
 293         $this->setHeader('To', $address, false);
 294     }
 295
 296     /**
 297      * Add the Cc: recipients
 298      *
 299      * @see cleanAddress
 300      * @param string|string[]  $address Multiple adresses separated by commas or as array
 301      */
 302     public function cc($address)
 303     {
 304         $this->setHeader('Cc', $address, false);
 305     }
 306
 307     /**
 308      * Add the Bcc: recipients
 309      *
 310      * @see cleanAddress
 311      * @param string|string[]  $address Multiple adresses separated by commas or as array
 312      */
 313     public function bcc($address)
 314     {
 315         $this->setHeader('Bcc', $address, false);
 316     }
 317
 318     /**
 319      * Add the From: address
 320      *
 321      * This is set to $conf['mailfrom'] when not specified so you shouldn't need
 322      * to call this function
 323      *
 324      * @see cleanAddress
 325      * @param string  $address from address
 326      */
 327     public function from($address)
 328     {
 329         $this->setHeader('From', $address, false);
 330     }
 331
 332     /**
 333      * Add the mail's Subject: header
 334      *
 335      * @param string $subject the mail subject
 336      */
 337     public function subject($subject)
 338     {
 339         $this->headers['Subject'] = $subject;
 340     }
 341
 342     /**
 343      * Return a clean name which can be safely used in mail address
 344      * fields. That means the name will be enclosed in '"' if it includes
 345      * a '"' or a ','. Also a '"' will be escaped as '\"'.
 346      *
 347      * @param string $name the name to clean-up
 348      * @see cleanAddress
 349      */
 350     public function getCleanName($name)
 351     {
 352         $name = trim($name, " \t\"");
 353         $name = str_replace('"', '\"', $name, $count);
 354         if ($count > 0 || strpos($name, ',') !== false) {
 355             $name = '"' . $name . '"';
 356         }
 357         return $name;
 358     }
 359
 360     /**
 361      * Sets an email address header with correct encoding
 362      *
 363      * Unicode characters will be deaccented and encoded base64
 364      * for headers. Addresses may not contain Non-ASCII data!
 365      *
 366      * If @$addresses is a string then it will be split into multiple
 367      * addresses. Addresses must be separated by a comma. If the display
 368      * name includes a comma then it MUST be properly enclosed by '"' to
 369      * prevent spliting at the wrong point.
 370      *
 371      * Example:
 372      *   cc("föö <foo@bar.com>, me@somewhere.com","TBcc");
 373      *   to("foo, Dr." <foo@bar.com>, me@somewhere.com");
 374      *
 375      * @param string|string[]  $addresses Multiple adresses separated by commas or as array
 376      * @return false|string  the prepared header (can contain multiple lines)
 377      */
 378     public function cleanAddress($addresses)
 379     {
 380         $headers = '';
 381         if (!is_array($addresses)) {
 382             $count = preg_match_all('/\s*(?:("[^"]*"[^,]+),*)|([^,]+)\s*,*/', $addresses, $matches, PREG_SET_ORDER);
 383             $addresses = [];
 384             if ($count !== false && is_array($matches)) {
 385                 foreach ($matches as $match) {
 386                     $addresses[] = rtrim($match[0], ',');
 387                 }
 388             }
 389         }
 390
 391         foreach ($addresses as $part) {
 392             $part = preg_replace('/[\r\n\0]+/', ' ', $part); // remove attack vectors
 393             $part = trim($part);
 394
 395             // parse address
 396             if (preg_match('#(.*?)<(.*?)>#', $part, $matches)) {
 397                 $text = trim($matches[1]);
 398                 $addr = $matches[2];
 399             } else {
 400                 $text = '';
 401                 $addr = $part;
 402             }
 403             // skip empty ones
 404             if (empty($addr)) {
 405                 continue;
 406             }
 407
 408             // FIXME: is there a way to encode the localpart of a emailaddress?
 409             if (!Clean::isASCII($addr)) {
 410                 msg(hsc("E-Mail address <$addr> is not ASCII"), -1, __LINE__, __FILE__, MSG_ADMINS_ONLY);
 411                 continue;
 412             }
 413
 414             if (!mail_isvalid($addr)) {
 415                 msg(hsc("E-Mail address <$addr> is not valid"), -1, __LINE__, __FILE__, MSG_ADMINS_ONLY);
 416                 continue;
 417             }
 418
 419             // text was given
 420             if (!empty($text) && !isWindows()) { // No named recipients for To: in Windows (see FS#652)
 421                 // add address quotes
 422                 $addr = "<$addr>";
 423
 424                 if (defined('MAILHEADER_ASCIIONLY')) {
 425                     $text = Clean::deaccent($text);
 426                     $text = Clean::strip($text);
 427                 }
 428
 429                 if (strpos($text, ',') !== false || !Clean::isASCII($text)) {
 430                     $text = '=?UTF-8?B?' . base64_encode($text) . '?=';
 431                 }
 432             } else {
 433                 $text = '';
 434             }
 435
 436             // add to header comma seperated
 437             if ($headers != '') {
 438                 $headers .= ', ';
 439             }
 440             $headers .= $text . ' ' . $addr;
 441         }
 442
 443         $headers = trim($headers);
 444         if (empty($headers)) return false;
 445
 446         return $headers;
 447     }
 448
 449
 450     /**
 451      * Prepare the mime multiparts for all attachments
 452      *
 453      * Replaces placeholders in the HTML with the correct CIDs
 454      *
 455      * @return string mime multiparts
 456      */
 457     protected function prepareAttachments()
 458     {
 459         $mime = '';
 460         $part = 1;
 461         // embedded attachments
 462         foreach ($this->attach as $media) {
 463             $media['name'] = str_replace(':', '_', cleanID($media['name'], true));
 464
 465             // create content id
 466             $cid = 'part' . $part . '.' . $this->partid;
 467
 468             // replace wildcards
 469             if ($media['embed']) {
 470                 $this->html = str_replace('%%' . $media['embed'] . '%%', 'cid:' . $cid, $this->html);
 471             }
 472
 473             $mime .= '--' . $this->boundary . MAILHEADER_EOL;
 474             $mime .= $this->wrappedHeaderLine('Content-Type', $media['mime'] . '; id="' . $cid . '"');
 475             $mime .= $this->wrappedHeaderLine('Content-Transfer-Encoding', 'base64');
 476             $mime .= $this->wrappedHeaderLine('Content-ID', "<$cid>");
 477             if ($media['embed']) {
 478                 $mime .= $this->wrappedHeaderLine('Content-Disposition', 'inline; filename=' . $media['name']);
 479             } else {
 480                 $mime .= $this->wrappedHeaderLine('Content-Disposition', 'attachment; filename=' . $media['name']);
 481             }
 482             $mime .= MAILHEADER_EOL; //end of headers
 483             $mime .= chunk_split(base64_encode($media['data']), 74, MAILHEADER_EOL);
 484
 485             $part++;
 486         }
 487         return $mime;
 488     }
 489
 490     /**
 491      * Build the body and handles multi part mails
 492      *
 493      * Needs to be called before prepareHeaders!
 494      *
 495      * @return string the prepared mail body, false on errors
 496      */
 497     protected function prepareBody()
 498     {
 499
 500         // no HTML mails allowed? remove HTML body
 501         if (!$this->allowhtml) {
 502             $this->html = '';
 503         }
 504
 505         // check for body
 506         if (!$this->text && !$this->html) {
 507             return false;
 508         }
 509
 510         // add general headers
 511         $this->headers['MIME-Version'] = '1.0';
 512
 513         $body = '';
 514
 515         if (!$this->html && !count($this->attach)) { // we can send a simple single part message
 516             $this->headers['Content-Type']              = 'text/plain; charset=UTF-8';
 517             $this->headers['Content-Transfer-Encoding'] = 'base64';
 518             $body .= chunk_split(base64_encode($this->text), 72, MAILHEADER_EOL);
 519         } else { // multi part it is
 520             $body .= "This is a multi-part message in MIME format." . MAILHEADER_EOL;
 521
 522             // prepare the attachments
 523             $attachments = $this->prepareAttachments();
 524
 525             // do we have alternative text content?
 526             if ($this->text && $this->html) {
 527                 $this->headers['Content-Type'] = 'multipart/alternative;' . MAILHEADER_EOL .
 528                     '  boundary="' . $this->boundary . 'XX"';
 529                 $body .= '--' . $this->boundary . 'XX' . MAILHEADER_EOL;
 530                 $body .= 'Content-Type: text/plain; charset=UTF-8' . MAILHEADER_EOL;
 531                 $body .= 'Content-Transfer-Encoding: base64' . MAILHEADER_EOL;
 532                 $body .= MAILHEADER_EOL;
 533                 $body .= chunk_split(base64_encode($this->text), 72, MAILHEADER_EOL);
 534                 $body .= '--' . $this->boundary . 'XX' . MAILHEADER_EOL;
 535                 $body .= 'Content-Type: multipart/related;' . MAILHEADER_EOL .
 536                     '  boundary="' . $this->boundary . '";' . MAILHEADER_EOL .
 537                     '  type="text/html"' . MAILHEADER_EOL;
 538                 $body .= MAILHEADER_EOL;
 539             }
 540
 541             $body .= '--' . $this->boundary . MAILHEADER_EOL;
 542             $body .= 'Content-Type: text/html; charset=UTF-8' . MAILHEADER_EOL;
 543             $body .= 'Content-Transfer-Encoding: base64' . MAILHEADER_EOL;
 544             $body .= MAILHEADER_EOL;
 545             $body .= chunk_split(base64_encode($this->html), 72, MAILHEADER_EOL);
 546             $body .= MAILHEADER_EOL;
 547             $body .= $attachments;
 548             $body .= '--' . $this->boundary . '--' . MAILHEADER_EOL;
 549
 550             // close open multipart/alternative boundary
 551             if ($this->text && $this->html) {
 552                 $body .= '--' . $this->boundary . 'XX--' . MAILHEADER_EOL;
 553             }
 554         }
 555
 556         return $body;
 557     }
 558
 559     /**
 560      * Cleanup and encode the headers array
 561      */
 562     protected function cleanHeaders()
 563     {
 564         global $conf;
 565
 566         // clean up addresses
 567         if (empty($this->headers['From'])) $this->from($conf['mailfrom']);
 568         $addrs = ['To', 'From', 'Cc', 'Bcc', 'Reply-To', 'Sender'];
 569         foreach ($addrs as $addr) {
 570             if (isset($this->headers[$addr])) {
 571                 $this->headers[$addr] = $this->cleanAddress($this->headers[$addr]);
 572             }
 573         }
 574
 575         if (isset($this->headers['Subject'])) {
 576             // add prefix to subject
 577             if (empty($conf['mailprefix'])) {
 578                 if (PhpString::strlen($conf['title']) < 20) {
 579                     $prefix = '[' . $conf['title'] . ']';
 580                 } else {
 581                     $prefix = '[' . PhpString::substr($conf['title'], 0, 20) . '...]';
 582                 }
 583             } else {
 584                 $prefix = '[' . $conf['mailprefix'] . ']';
 585             }
 586             if (!str_starts_with($this->headers['Subject'], $prefix)) {
 587                 $this->headers['Subject'] = $prefix . ' ' . $this->headers['Subject'];
 588             }
 589
 590             // encode subject
 591             if (defined('MAILHEADER_ASCIIONLY')) {
 592                 $this->headers['Subject'] = Clean::deaccent($this->headers['Subject']);
 593                 $this->headers['Subject'] = Clean::strip($this->headers['Subject']);
 594             }
 595             if (!Clean::isASCII($this->headers['Subject'])) {
 596                 $this->headers['Subject'] = '=?UTF-8?B?' . base64_encode($this->headers['Subject']) . '?=';
 597             }
 598         }
 599     }
 600
 601     /**
 602      * Returns a complete, EOL terminated header line, wraps it if necessary
 603      *
 604      * @param string $key
 605      * @param string $val
 606      * @return string line
 607      */
 608     protected function wrappedHeaderLine($key, $val)
 609     {
 610         return wordwrap("$key: $val", 78, MAILHEADER_EOL . '  ') . MAILHEADER_EOL;
 611     }
 612
 613     /**
 614      * Create a string from the headers array
 615      *
 616      * @returns string the headers
 617      */
 618     protected function prepareHeaders()
 619     {
 620         $headers = '';
 621         foreach ($this->headers as $key => $val) {
 622             if ($val === '' || $val === null) continue;
 623             $headers .= $this->wrappedHeaderLine($key, $val);
 624         }
 625         return $headers;
 626     }
 627
 628     /**
 629      * return a full email with all headers
 630      *
 631      * This is mainly intended for debugging and testing but could also be
 632      * used for MHT exports
 633      *
 634      * @return string the mail, false on errors
 635      */
 636     public function dump()
 637     {
 638         $this->cleanHeaders();
 639         $body = $this->prepareBody();
 640         if ($body === false) return false;
 641         $headers = $this->prepareHeaders();
 642
 643         return $headers . MAILHEADER_EOL . $body;
 644     }
 645
 646     /**
 647      * Prepare default token replacement strings
 648      *
 649      * Populates the '$replacements' property.
 650      * Should be called by the class constructor
 651      */
 652     protected function prepareTokenReplacements()
 653     {
 654         global $INFO;
 655         global $conf;
 656         /* @var Input $INPUT */
 657         global $INPUT;
 658         global $lang;
 659
 660         $ip   = clientIP();
 661         $cip  = gethostsbyaddrs($ip);
 662         $name = $INFO['userinfo']['name'] ?? '';
 663         $mail = $INFO['userinfo']['mail'] ?? '';
 664
 665         $this->replacements['text'] = [
 666             'DATE' => dformat(),
 667             'BROWSER' => $INPUT->server->str('HTTP_USER_AGENT'),
 668             'IPADDRESS' => $ip,
 669             'HOSTNAME' => $cip,
 670             'TITLE' => $conf['title'],
 671             'DOKUWIKIURL' => DOKU_URL,
 672             'USER' => $INPUT->server->str('REMOTE_USER'),
 673             'NAME' => $name,
 674             'MAIL' => $mail
 675         ];
 676
 677         $signature = str_replace(
 678             '@DOKUWIKIURL@',
 679             $this->replacements['text']['DOKUWIKIURL'],
 680             $lang['email_signature_text']
 681         );
 682         $this->replacements['text']['EMAILSIGNATURE'] = "\n-- \n" . $signature . "\n";
 683
 684         $this->replacements['html'] = [
 685             'DATE' => '<i>' . hsc(dformat()) . '</i>',
 686             'BROWSER' => hsc($INPUT->server->str('HTTP_USER_AGENT')),
 687             'IPADDRESS' => '<code>' . hsc($ip) . '</code>',
 688             'HOSTNAME' => '<code>' . hsc($cip) . '</code>',
 689             'TITLE' => hsc($conf['title']),
 690             'DOKUWIKIURL' => '<a href="' . DOKU_URL . '">' . DOKU_URL . '</a>',
 691             'USER' => hsc($INPUT->server->str('REMOTE_USER')),
 692             'NAME' => hsc($name),
 693             'MAIL' => '<a href="mailto:"' . hsc($mail) . '">' . hsc($mail) . '</a>'
 694         ];
 695         $signature = $lang['email_signature_text'];
 696         if (!empty($lang['email_signature_html'])) {
 697             $signature = $lang['email_signature_html'];
 698         }
 699         $signature = str_replace(
 700             ['@DOKUWIKIURL@', "\n"],
 701             [$this->replacements['html']['DOKUWIKIURL'], '<br />'],
 702             $signature
 703         );
 704         $this->replacements['html']['EMAILSIGNATURE'] = $signature;
 705     }
 706
 707     /**
 708      * Send the mail
 709      *
 710      * Call this after all data was set
 711      *
 712      * @triggers MAIL_MESSAGE_SEND
 713      * @return bool true if the mail was successfully passed to the MTA
 714      */
 715     public function send()
 716     {
 717         global $lang;
 718         $success = false;
 719
 720         // prepare hook data
 721         $data = [
 722             // pass the whole mail class to plugin
 723             'mail'    => $this,
 724             // pass references for backward compatibility
 725             'to'      => &$this->headers['To'],
 726             'cc'      => &$this->headers['Cc'],
 727             'bcc'     => &$this->headers['Bcc'],
 728             'from'    => &$this->headers['From'],
 729             'subject' => &$this->headers['Subject'],
 730             'body'    => &$this->text,
 731             'params'  => &$this->sendparam,
 732             'headers' => '', // plugins shouldn't use this
 733             // signal if we mailed successfully to AFTER event
 734             'success' => &$success,
 735         ];
 736
 737         // do our thing if BEFORE hook approves
 738         $evt = new Event('MAIL_MESSAGE_SEND', $data);
 739         if ($evt->advise_before(true)) {
 740             // clean up before using the headers
 741             $this->cleanHeaders();
 742
 743             // any recipients?
 744             if (
 745                 trim($this->headers['To']) === '' &&
 746                 trim($this->headers['Cc']) === '' &&
 747                 trim($this->headers['Bcc']) === ''
 748             ) return false;
 749
 750             // The To: header is special
 751             if (array_key_exists('To', $this->headers)) {
 752                 $to = (string)$this->headers['To'];
 753                 unset($this->headers['To']);
 754             } else {
 755                 $to = '';
 756             }
 757
 758             // so is the subject
 759             if (array_key_exists('Subject', $this->headers)) {
 760                 $subject = (string)$this->headers['Subject'];
 761                 unset($this->headers['Subject']);
 762             } else {
 763                 $subject = '';
 764             }
 765
 766             // make the body
 767             $body = $this->prepareBody();
 768             if ($body === false) return false;
 769
 770             // cook the headers
 771             $headers = $this->prepareHeaders();
 772             // add any headers set by legacy plugins
 773             if (trim($data['headers'])) {
 774                 $headers .= MAILHEADER_EOL . trim($data['headers']);
 775             }
 776
 777             if (!function_exists('mail')) {
 778                 $emsg = $lang['email_fail'] . $subject;
 779                 error_log($emsg);
 780                 msg(hsc($emsg), -1, __LINE__, __FILE__, MSG_MANAGERS_ONLY);
 781                 $evt->advise_after();
 782                 return false;
 783             }
 784
 785             // send the thing
 786             if ($to === '') $to = '(undisclosed-recipients)'; // #1422
 787             if ($this->sendparam === null) {
 788                 $success = @mail($to, $subject, $body, $headers);
 789             } else {
 790                 $success = @mail($to, $subject, $body, $headers, $this->sendparam);
 791             }
 792         }
 793         // any AFTER actions?
 794         $evt->advise_after();
 795         return $success;
 796     }
 797 }