source: pmb4.2/trunk/fuentes/pmb/classes/class.phpmailer.php @ 815

Last change on this file since 815 was 815, checked in by jrpelegrina, 4 years ago

Initial release of pmb 4.2

  • Property svn:executable set to *
File size: 48.8 KB
Line 
1<?php
2// $Id: class.phpmailer.php,v 1.8 2013-04-19 08:20:24 mbertin Exp $
3
4if (stristr($_SERVER['REQUEST_URI'], "class.phpmailer.php")) die("no access");
5
6/*~ class.phpmailer.php
7.---------------------------------------------------------------------------.
8|  Software: PHPMailer - PHP email class                                    |
9|   Version: 2.0.0 rc3                                                      |
10|   Contact: via sourceforge.net support pages (also www.codeworxtech.com)  |
11|      Info: http://phpmailer.sourceforge.net                               |
12|   Support: http://sourceforge.net/projects/phpmailer/                     |
13| ------------------------------------------------------------------------- |
14|    Author: Andy Prevost (project admininistrator)                         |
15|    Author: Brent R. Matzelle (original founder)                           |
16| Copyright (c) 2004-2007, Andy Prevost. All Rights Reserved.               |
17| Copyright (c) 2001-2003, Brent R. Matzelle                                |
18| ------------------------------------------------------------------------- |
19|   License: Distributed under the Lesser General Public License (LGPL)     |
20|            http://www.gnu.org/copyleft/lesser.html                        |
21| This program is distributed in the hope that it will be useful - WITHOUT  |
22| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or     |
23| FITNESS FOR A PARTICULAR PURPOSE.                                         |
24| ------------------------------------------------------------------------- |
25| We offer a number of paid services (www.codeworxtech.com):                |
26| - Web Hosting on highly optimized fast and secure servers                 |
27| - Technology Consulting                                                   |
28| - Oursourcing (highly qualified programmers and graphic designers)        |
29'---------------------------------------------------------------------------'
30
31/**
32 * PHPMailer - PHP email transport class
33 * @package PHPMailer
34 * @author Andy Prevost
35 * @copyright 2004 - 2007 Andy Prevost
36 */
37
38class PHPMailer {
39
40  /////////////////////////////////////////////////
41  // PROPERTIES, PUBLIC
42  /////////////////////////////////////////////////
43
44  /**
45   * Email priority (1 = High, 3 = Normal, 5 = low).
46   * @var int
47   */
48  var $Priority          = 3;
49
50  /**
51   * Sets the CharSet of the message.
52   * @var string
53   */
54  var $CharSet           = 'iso-8859-1';
55
56  /**
57   * Sets the Content-type of the message.
58   * @var string
59   */
60  var $ContentType        = 'text/plain';
61
62  /**
63   * Sets the Encoding of the message. Options for this are "8bit",
64   * "7bit", "binary", "base64", and "quoted-printable".
65   * @var string
66   */
67  var $Encoding          = '8bit';
68
69  /**
70   * Holds the most recent mailer error message.
71   * @var string
72   */
73  var $ErrorInfo         = '';
74
75  /**
76   * Sets the From email address for the message.
77   * @var string
78   */
79  var $From              = 'root@localhost';
80
81  /**
82   * Sets the From name of the message.
83   * @var string
84   */
85  var $FromName          = 'Root User';
86
87  /**
88   * Sets the Sender email (Return-Path) of the message.  If not empty,
89   * will be sent via -f to sendmail or as 'MAIL FROM' in smtp mode.
90   * @var string
91   */
92  var $Sender            = '';
93
94  /**
95   * Sets the Subject of the message.
96   * @var string
97   */
98  var $Subject           = '';
99
100  /**
101   * Sets the Body of the message.  This can be either an HTML or text body.
102   * If HTML then run IsHTML(true).
103   * @var string
104   */
105  var $Body              = '';
106
107  /**
108   * Sets the text-only body of the message.  This automatically sets the
109   * email to multipart/alternative.  This body can be read by mail
110   * clients that do not have HTML email capability such as mutt. Clients
111   * that can read HTML will view the normal Body.
112   * @var string
113   */
114  var $AltBody           = '';
115
116  /**
117   * Sets word wrapping on the body of the message to a given number of
118   * characters.
119   * @var int
120   */
121  var $WordWrap          = 0;
122
123  /**
124   * Method to send mail: ("mail", "sendmail", or "smtp").
125   * @var string
126   */
127  var $Mailer            = 'mail';
128
129  /**
130   * Sets the path of the sendmail program.
131   * @var string
132   */
133  var $Sendmail          = '/usr/sbin/sendmail';
134
135  /**
136   * Path to PHPMailer plugins.  This is now only useful if the SMTP class
137   * is in a different directory than the PHP include path.
138   * @var string
139   */
140  var $PluginDir         = '';
141
142  /**
143   * Holds PHPMailer version.
144   * @var string
145   */
146  var $Version           = "2.0.0 rc3";
147
148  /**
149   * Sets the email address that a reading confirmation will be sent.
150   * @var string
151   */
152  var $ConfirmReadingTo  = '';
153
154  /**
155   * Sets the hostname to use in Message-Id and Received headers
156   * and as default HELO string. If empty, the value returned
157   * by SERVER_NAME is used or 'localhost.localdomain'.
158   * @var string
159   */
160  var $Hostname          = '';
161
162  /////////////////////////////////////////////////
163  // PROPERTIES FOR SMTP
164  /////////////////////////////////////////////////
165
166  /**
167   * Sets the SMTP hosts.  All hosts must be separated by a
168   * semicolon.  You can also specify a different port
169   * for each host by using this format: [hostname:port]
170   * (e.g. "smtp1.example.com:25;smtp2.example.com").
171   * Hosts will be tried in order.
172   * @var string
173   */
174  var $Host        = 'localhost';
175
176  /**
177   * Sets the default SMTP server port.
178   * @var int
179   */
180  var $Port        = 25;
181
182  /**
183   * Sets the SMTP HELO of the message (Default is $Hostname).
184   * @var string
185   */
186  var $Helo        = '';
187
188  /**
189   * Sets connection prefix.
190   * Options are "", "ssl" or "tls"
191   * @var string
192   */
193  var $SMTPSecure = "";
194
195  /**
196   * Sets SMTP authentication. Utilizes the Username and Password variables.
197   * @var bool
198   */
199  var $SMTPAuth     = false;
200
201  /**
202   * Sets SMTP username.
203   * @var string
204   */
205  var $Username     = '';
206
207  /**
208   * Sets SMTP password.
209   * @var string
210   */
211  var $Password     = '';
212
213  /**
214   * Sets the SMTP server timeout in seconds. This function will not
215   * work with the win32 version.
216   * @var int
217   */
218  var $Timeout      = 10;
219
220  /**
221   * Sets SMTP class debugging on or off.
222   * @var bool
223   */
224  var $SMTPDebug    = false;
225
226  /**
227   * Prevents the SMTP connection from being closed after each mail
228   * sending.  If this is set to true then to close the connection
229   * requires an explicit call to SmtpClose().
230   * @var bool
231   */
232  var $SMTPKeepAlive = false;
233
234  /**
235   * Provides the ability to have the TO field process individual
236   * emails, instead of sending to entire TO addresses
237   * @var bool
238   */
239  var $SingleTo = false;
240
241  /////////////////////////////////////////////////
242  // PROPERTIES, PRIVATE
243  /////////////////////////////////////////////////
244
245  var $smtp            = NULL;
246  var $to              = array();
247  var $cc              = array();
248  var $bcc             = array();
249  var $ReplyTo         = array();
250  var $attachment      = array();
251  var $CustomHeader    = array();
252  var $message_type    = '';
253  var $boundary        = array();
254  var $language        = array();
255  var $error_count     = 0;
256  var $LE              = "\n";
257
258  /////////////////////////////////////////////////
259  // METHODS, VARIABLES
260  /////////////////////////////////////////////////
261
262  /**
263   * Sets message type to HTML.
264   * @param bool $bool
265   * @return void
266   */
267  function IsHTML($bool) {
268    if($bool == true) {
269      $this->ContentType = 'text/html';
270    } else {
271      $this->ContentType = 'text/plain';
272    }
273  }
274
275  /**
276   * Sets Mailer to send message using SMTP.
277   * @return void
278   */
279  function IsSMTP() {
280    $this->Mailer = 'smtp';
281  }
282
283  /**
284   * Sets Mailer to send message using PHP mail() function.
285   * @return void
286   */
287  function IsMail() {
288    $this->Mailer = 'mail';
289  }
290
291  /**
292   * Sets Mailer to send message using the $Sendmail program.
293   * @return void
294   */
295  function IsSendmail() {
296    $this->Mailer = 'sendmail';
297  }
298
299  /**
300   * Sets Mailer to send message using the qmail MTA.
301   * @return void
302   */
303  function IsQmail() {
304    $this->Sendmail = '/var/qmail/bin/sendmail';
305    $this->Mailer = 'sendmail';
306  }
307
308  /////////////////////////////////////////////////
309  // METHODS, RECIPIENTS
310  /////////////////////////////////////////////////
311
312  /**
313   * Adds a "To" address.
314   * @param string $address
315   * @param string $name
316   * @return void
317   */
318  function AddAddress($address, $name = '') {
319    $cur = count($this->to);
320    $this->to[$cur][0] = trim($address);
321    $this->to[$cur][1] = $name;
322  }
323
324  /**
325   * Adds a "Cc" address. Note: this function works
326   * with the SMTP mailer on win32, not with the "mail"
327   * mailer.
328   * @param string $address
329   * @param string $name
330   * @return void
331   */
332  function AddCC($address, $name = '') {
333    $cur = count($this->cc);
334    $this->cc[$cur][0] = trim($address);
335    $this->cc[$cur][1] = $name;
336  }
337
338  /**
339   * Adds a "Bcc" address. Note: this function works
340   * with the SMTP mailer on win32, not with the "mail"
341   * mailer.
342   * @param string $address
343   * @param string $name
344   * @return void
345   */
346  function AddBCC($address, $name = '') {
347    $cur = count($this->bcc);
348    $this->bcc[$cur][0] = trim($address);
349    $this->bcc[$cur][1] = $name;
350  }
351
352  /**
353   * Adds a "Reply-To" address.
354   * @param string $address
355   * @param string $name
356   * @return void
357   */
358  function AddReplyTo($address, $name = '') {
359    $cur = count($this->ReplyTo);
360    $this->ReplyTo[$cur][0] = trim($address);
361    $this->ReplyTo[$cur][1] = $name;
362  }
363
364  /////////////////////////////////////////////////
365  // METHODS, MAIL SENDING
366  /////////////////////////////////////////////////
367
368  /**
369   * Creates message and assigns Mailer. If the message is
370   * not sent successfully then it returns false.  Use the ErrorInfo
371   * variable to view description of the error.
372   * @return bool
373   */
374  function Send() {
375    $header = '';
376    $body = '';
377    $result = true;
378
379    if((count($this->to) + count($this->cc) + count($this->bcc)) < 1) {
380      $this->SetError($this->Lang('provide_address'));
381      return false;
382    }
383
384    /* Set whether the message is multipart/alternative */
385    if(!empty($this->AltBody)) {
386      $this->ContentType = 'multipart/alternative';
387    }
388
389    $this->error_count = 0; // reset errors
390    $this->SetMessageType();
391    $header .= $this->CreateHeader();
392    $body = $this->CreateBody();
393
394    if($body == '') {
395      return false;
396    }
397
398    /* Choose the mailer */
399    switch($this->Mailer) {
400      case 'sendmail':
401        $result = $this->SendmailSend($header, $body);
402        break;
403      case 'smtp':
404        $result = $this->SmtpSend($header, $body);
405        break;
406      case 'mail':
407        $result = $this->MailSend($header, $body);
408        break;
409      default:
410        $result = $this->MailSend($header, $body);
411        break;
412        //$this->SetError($this->Mailer . $this->Lang('mailer_not_supported'));
413        //$result = false;
414        //break;
415    }
416
417    return $result;
418  }
419
420  /**
421   * Sends mail using the $Sendmail program.
422   * @access private
423   * @return bool
424   */
425  function SendmailSend($header, $body) {
426    if ($this->Sender != '') {
427      $sendmail = sprintf("%s -oi -f %s -t", escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
428    } else {
429      $sendmail = sprintf("%s -oi -t", escapeshellcmd($this->Sendmail));
430    }
431
432    if(!@$mail = popen($sendmail, 'w')) {
433      $this->SetError($this->Lang('execute') . $this->Sendmail);
434      return false;
435    }
436
437    fputs($mail, $header);
438    fputs($mail, $body);
439
440    $result = pclose($mail) >> 8 & 0xFF;
441    if($result != 0) {
442      $this->SetError($this->Lang('execute') . $this->Sendmail);
443      return false;
444    }
445
446    return true;
447  }
448
449  /**
450   * Sends mail using the PHP mail() function.
451   * @access private
452   * @return bool
453   */
454  function MailSend($header, $body) {
455
456    $to = '';
457    for($i = 0; $i < count($this->to); $i++) {
458      if($i != 0) { $to .= ', '; }
459      $to .= $this->AddrFormat($this->to[$i]);
460    }
461
462    $toArr = explode(',', $to);
463
464    if ($this->Sender != '' && strlen(ini_get('safe_mode'))< 1) {
465      $old_from = ini_get('sendmail_from');
466      ini_set('sendmail_from', $this->Sender);
467      $params = sprintf("-oi -f %s", $this->Sender);
468      if ($this->SingleTo === true && count($toArr) > 1) {
469        foreach ($toArr as $key => $val) {
470          $rt = @mail($val, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header, $params);
471        }
472      } else {
473        $rt = @mail($to, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header, $params);
474      }
475    } else {
476      if ($this->SingleTo === true && count($toArr) > 1) {
477        foreach ($toArr as $key => $val) {
478          $rt = @mail($val, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header, $params);
479        }
480      } else {
481        $rt = @mail($to, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header);
482      }
483    }
484
485    if (isset($old_from)) {
486      ini_set('sendmail_from', $old_from);
487    }
488
489    if(!$rt) {
490      $this->SetError($this->Lang('instantiate'));
491      return false;
492    }
493
494    return true;
495  }
496
497  /**
498   * Sends mail via SMTP using PhpSMTP (Author:
499   * Chris Ryan).  Returns bool.  Returns false if there is a
500   * bad MAIL FROM, RCPT, or DATA input.
501   * @access private
502   * @return bool
503   */
504  function SmtpSend($header, $body) {
505    include_once($this->PluginDir . 'class.smtp.php');
506    $error = '';
507    $bad_rcpt = array();
508
509    if(!$this->SmtpConnect()) {
510      return false;
511    }
512
513    $smtp_from = ($this->Sender == '') ? $this->From : $this->Sender;
514    if(!$this->smtp->Mail($smtp_from)) {
515      $error = $this->Lang('from_failed') . $smtp_from;
516      $this->SetError($error);
517      $this->smtp->Reset();
518      return false;
519    }
520
521    /* Attempt to send attach all recipients */
522    for($i = 0; $i < count($this->to); $i++) {
523      if(!$this->smtp->Recipient($this->to[$i][0])) {
524        $bad_rcpt[] = $this->to[$i][0];
525      }
526    }
527    for($i = 0; $i < count($this->cc); $i++) {
528      if(!$this->smtp->Recipient($this->cc[$i][0])) {
529        $bad_rcpt[] = $this->cc[$i][0];
530      }
531    }
532    for($i = 0; $i < count($this->bcc); $i++) {
533      if(!$this->smtp->Recipient($this->bcc[$i][0])) {
534        $bad_rcpt[] = $this->bcc[$i][0];
535      }
536    }
537
538    if(count($bad_rcpt) > 0) { // Create error message
539      for($i = 0; $i < count($bad_rcpt); $i++) {
540        if($i != 0) {
541          $error .= ', ';
542        }
543        $error .= $bad_rcpt[$i];
544      }
545      $error = $this->Lang('recipients_failed') . $error;
546      $this->SetError($error);
547      $this->smtp->Reset();
548      return false;
549    }
550
551    if(!$this->smtp->Data($header . $body)) {
552      $this->SetError($this->Lang('data_not_accepted'));
553      $this->smtp->Reset();
554      return false;
555    }
556    if($this->SMTPKeepAlive == true) {
557      $this->smtp->Reset();
558    } else {
559      $this->SmtpClose();
560    }
561
562    return true;
563  }
564
565  /**
566   * Initiates a connection to an SMTP server.  Returns false if the
567   * operation failed.
568   * @access private
569   * @return bool
570   */
571  function SmtpConnect() {
572    if($this->smtp == NULL) {
573      $this->smtp = new SMTP();
574    }
575
576    $this->smtp->do_debug = $this->SMTPDebug;
577    $hosts = explode(';', $this->Host);
578    $index = 0;
579    $connection = ($this->smtp->Connected());
580
581    /* Retry while there is no connection */
582    while($index < count($hosts) && $connection == false) {
583      $hostinfo = array();
584      if(preg_match("#^(.+):([0-9]+)$#i", $hosts[$index], $hostinfo)) {
585        $host = $hostinfo[1];
586        $port = $hostinfo[2];
587      } else {
588        $host = $hosts[$index];
589        $port = $this->Port;
590      }
591
592      if($this->smtp->Connect(((!empty($this->SMTPSecure))?$this->SMTPSecure.'://':'').$host, $port, $this->Timeout)) {
593        if ($this->Helo != '') {
594          $this->smtp->Hello($this->Helo);
595        } else {
596          $this->smtp->Hello($this->ServerHostname());
597        }
598
599        $connection = true;
600        if($this->SMTPAuth) {
601          if(!$this->smtp->Authenticate($this->Username, $this->Password)) {
602            $this->SetError($this->Lang('authenticate'));
603            $this->smtp->Reset();
604            $connection = false;
605          }
606        }
607      }
608      $index++;
609    }
610    if(!$connection) {
611      $this->SetError($this->Lang('connect_host'));
612    }
613
614    return $connection;
615  }
616
617  /**
618   * Closes the active SMTP session if one exists.
619   * @return void
620   */
621  function SmtpClose() {
622    if($this->smtp != NULL) {
623      if($this->smtp->Connected()) {
624        $this->smtp->Quit();
625        $this->smtp->Close();
626      }
627    }
628  }
629
630  /**
631   * Sets the language for all class error messages.  Returns false
632   * if it cannot load the language file.  The default language type
633   * is English.
634   * @param string $lang_type Type of language (e.g. Portuguese: "br")
635   * @param string $lang_path Path to the language file directory
636   * @access public
637   * @return bool
638   */
639  function SetLanguage($lang_type, $lang_path = 'language/') {
640    if(file_exists($lang_path.'phpmailer.lang-'.$lang_type.'.php')) {
641      include($lang_path.'phpmailer.lang-'.$lang_type.'.php');
642    } elseif (file_exists($lang_path.'phpmailer.lang-en.php')) {
643      include($lang_path.'phpmailer.lang-en.php');
644    } else {
645      $this->SetError('Could not load language file');
646      return false;
647    }
648    $this->language = $PHPMAILER_LANG;
649
650    return true;
651  }
652
653  /////////////////////////////////////////////////
654  // METHODS, MESSAGE CREATION
655  /////////////////////////////////////////////////
656
657  /**
658   * Creates recipient headers.
659   * @access private
660   * @return string
661   */
662  function AddrAppend($type, $addr) {
663    $addr_str = $type . ': ';
664    $addr_str .= $this->AddrFormat($addr[0]);
665    if(count($addr) > 1) {
666      for($i = 1; $i < count($addr); $i++) {
667        $addr_str .= ', ' . $this->AddrFormat($addr[$i]);
668      }
669    }
670    $addr_str .= $this->LE;
671
672    return $addr_str;
673  }
674
675  /**
676   * Formats an address correctly.
677   * @access private
678   * @return string
679   */
680  function AddrFormat($addr) {
681    if(empty($addr[1])) {
682      $formatted = $this->SecureHeader($addr[0]);
683    } else {
684      $formatted = $this->EncodeHeader($this->SecureHeader($addr[1]), 'phrase') . " <" . $this->SecureHeader($addr[0]) . ">";
685    }
686
687    return $formatted;
688  }
689
690  /**
691   * Wraps message for use with mailers that do not
692   * automatically perform wrapping and for quoted-printable.
693   * Original written by philippe.
694   * @access private
695   * @return string
696   */
697  function WrapText($message, $length, $qp_mode = false) {
698    $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
699
700    $message = $this->FixEOL($message);
701    if (substr($message, -1) == $this->LE) {
702      $message = substr($message, 0, -1);
703    }
704
705    $line = explode($this->LE, $message);
706    $message = '';
707    for ($i=0 ;$i < count($line); $i++) {
708      $line_part = explode(' ', $line[$i]);
709      $buf = '';
710      for ($e = 0; $e<count($line_part); $e++) {
711        $word = $line_part[$e];
712        if ($qp_mode and (strlen($word) > $length)) {
713          $space_left = $length - strlen($buf) - 1;
714          if ($e != 0) {
715            if ($space_left > 20) {
716              $len = $space_left;
717              if (substr($word, $len - 1, 1) == '=') {
718                $len--;
719              } elseif (substr($word, $len - 2, 1) == '=') {
720                $len -= 2;
721              }
722              $part = substr($word, 0, $len);
723              $word = substr($word, $len);
724              $buf .= ' ' . $part;
725              $message .= $buf . sprintf("=%s", $this->LE);
726            } else {
727              $message .= $buf . $soft_break;
728            }
729            $buf = '';
730          }
731          while (strlen($word) > 0) {
732            $len = $length;
733            if (substr($word, $len - 1, 1) == '=') {
734              $len--;
735            } elseif (substr($word, $len - 2, 1) == '=') {
736              $len -= 2;
737            }
738            $part = substr($word, 0, $len);
739            $word = substr($word, $len);
740
741            if (strlen($word) > 0) {
742              $message .= $part . sprintf("=%s", $this->LE);
743            } else {
744              $buf = $part;
745            }
746          }
747        } else {
748          $buf_o = $buf;
749          $buf .= ($e == 0) ? $word : (' ' . $word);
750
751          if (strlen($buf) > $length and $buf_o != '') {
752            $message .= $buf_o . $soft_break;
753            $buf = $word;
754          }
755        }
756      }
757      $message .= $buf . $this->LE;
758    }
759
760    return $message;
761  }
762
763  /**
764   * Set the body wrapping.
765   * @access private
766   * @return void
767   */
768  function SetWordWrap() {
769    if($this->WordWrap < 1) {
770      return;
771    }
772
773    switch($this->message_type) {
774      case 'alt':
775        /* fall through */
776      case 'alt_attachments':
777        $this->AltBody = $this->WrapText($this->AltBody, $this->WordWrap);
778        break;
779      default:
780        $this->Body = $this->WrapText($this->Body, $this->WordWrap);
781        break;
782    }
783  }
784
785  /**
786   * Assembles message header.
787   * @access private
788   * @return string
789   */
790  function CreateHeader() {
791    $result = '';
792
793    /* Set the boundaries */
794    $uniq_id = md5(uniqid(time()));
795    $this->boundary[1] = 'b1_' . $uniq_id;
796    $this->boundary[2] = 'b2_' . $uniq_id;
797
798    $result .= $this->HeaderLine('Date', $this->RFCDate());
799    if($this->Sender == '') {
800      $result .= $this->HeaderLine('Return-Path', trim($this->From));
801    } else {
802      $result .= $this->HeaderLine('Return-Path', trim($this->Sender));
803    }
804
805    /* To be created automatically by mail() */
806    if($this->Mailer != 'mail') {
807      if(count($this->to) > 0) {
808        $result .= $this->AddrAppend('To', $this->to);
809      } elseif (count($this->cc) == 0) {
810        $result .= $this->HeaderLine('To', 'undisclosed-recipients:;');
811      }
812      if(count($this->cc) > 0) {
813        $result .= $this->AddrAppend('Cc', $this->cc);
814      }
815    }
816
817    $from = array();
818    $from[0][0] = trim($this->From);
819    $from[0][1] = $this->FromName;
820    $result .= $this->AddrAppend('From', $from);
821
822    /* sendmail and mail() extract Cc from the header before sending */
823    if((($this->Mailer == 'sendmail') || ($this->Mailer == 'mail')) && (count($this->cc) > 0)) {
824      $result .= $this->AddrAppend('Cc', $this->cc);
825    }
826
827    /* sendmail and mail() extract Bcc from the header before sending */
828    if((($this->Mailer == 'sendmail') || ($this->Mailer == 'mail')) && (count($this->bcc) > 0)) {
829      $result .= $this->AddrAppend('Bcc', $this->bcc);
830    }
831
832    if(count($this->ReplyTo) > 0) {
833      $result .= $this->AddrAppend('Reply-To', $this->ReplyTo);
834    }
835
836    /* mail() sets the subject itself */
837    if($this->Mailer != 'mail') {
838      $result .= $this->HeaderLine('Subject', $this->EncodeHeader($this->SecureHeader($this->Subject)));
839    }
840
841    $result .= sprintf("Message-ID: <%s@%s>%s", $uniq_id, $this->ServerHostname(), $this->LE);
842    $result .= $this->HeaderLine('X-Priority', $this->Priority);
843    $result .= $this->HeaderLine('X-Mailer', 'PHPMailer (phpmailer.sourceforge.net) [version ' . $this->Version . ']');
844
845    if($this->ConfirmReadingTo != '') {
846      $result .= $this->HeaderLine('Disposition-Notification-To', '<' . trim($this->ConfirmReadingTo) . '>');
847    }
848
849    // Add custom headers
850    for($index = 0; $index < count($this->CustomHeader); $index++) {
851      $result .= $this->HeaderLine(trim($this->CustomHeader[$index][0]), $this->EncodeHeader(trim($this->CustomHeader[$index][1])));
852    }
853    $result .= $this->HeaderLine('MIME-Version', '1.0');
854
855    switch($this->message_type) {
856      case 'plain':
857        $result .= $this->HeaderLine('Content-Transfer-Encoding', $this->Encoding);
858        $result .= sprintf("Content-Type: %s; charset=\"%s\"", $this->ContentType, $this->CharSet);
859        break;
860      case 'attachments':
861        /* fall through */
862      case 'alt_attachments':
863        if($this->InlineImageExists()){
864          $result .= sprintf("Content-Type: %s;%s\ttype=\"text/html\";%s\tboundary=\"%s\"%s", 'multipart/related', $this->LE, $this->LE, $this->boundary[1], $this->LE);
865        } else {
866          $result .= $this->HeaderLine('Content-Type', 'multipart/mixed;');
867          $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
868        }
869        break;
870      case 'alt':
871        $result .= $this->HeaderLine('Content-Type', 'multipart/alternative;');
872        $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
873        break;
874    }
875
876    if($this->Mailer != 'mail') {
877      $result .= $this->LE.$this->LE;
878    }
879
880    return $result;
881  }
882
883  /**
884   * Assembles the message body.  Returns an empty string on failure.
885   * @access private
886   * @return string
887   */
888  function CreateBody() {
889    $result = '';
890
891    $this->SetWordWrap();
892
893    switch($this->message_type) {
894      case 'alt':
895        $result .= $this->GetBoundary($this->boundary[1], '', 'text/plain', '');
896        $result .= $this->EncodeString($this->AltBody, $this->Encoding);
897        $result .= $this->LE.$this->LE;
898        $result .= $this->GetBoundary($this->boundary[1], '', 'text/html', '');
899        $result .= $this->EncodeString($this->Body, $this->Encoding);
900        $result .= $this->LE.$this->LE;
901        $result .= $this->EndBoundary($this->boundary[1]);
902        break;
903      case 'plain':
904        $result .= $this->EncodeString($this->Body, $this->Encoding);
905        break;
906      case 'attachments':
907        $result .= $this->GetBoundary($this->boundary[1], '', '', '');
908        $result .= $this->EncodeString($this->Body, $this->Encoding);
909        $result .= $this->LE;
910        $result .= $this->AttachAll();
911        break;
912      case 'alt_attachments':
913        $result .= sprintf("--%s%s", $this->boundary[1], $this->LE);
914        $result .= sprintf("Content-Type: %s;%s" . "\tboundary=\"%s\"%s", 'multipart/alternative', $this->LE, $this->boundary[2], $this->LE.$this->LE);
915        $result .= $this->GetBoundary($this->boundary[2], '', 'text/plain', '') . $this->LE; // Create text body
916        $result .= $this->EncodeString($this->AltBody, $this->Encoding);
917        $result .= $this->LE.$this->LE;
918        $result .= $this->GetBoundary($this->boundary[2], '', 'text/html', '') . $this->LE; // Create the HTML body
919        $result .= $this->EncodeString($this->Body, $this->Encoding);
920        $result .= $this->LE.$this->LE;
921        $result .= $this->EndBoundary($this->boundary[2]);
922        $result .= $this->AttachAll();
923        break;
924    }
925    if($this->IsError()) {
926      $result = '';
927    }
928
929    return $result;
930  }
931
932  /**
933   * Returns the start of a message boundary.
934   * @access private
935   */
936  function GetBoundary($boundary, $charSet, $contentType, $encoding) {
937    $result = '';
938    if($charSet == '') {
939      $charSet = $this->CharSet;
940    }
941    if($contentType == '') {
942      $contentType = $this->ContentType;
943    }
944    if($encoding == '') {
945      $encoding = $this->Encoding;
946    }
947    $result .= $this->TextLine('--' . $boundary);
948    $result .= sprintf("Content-Type: %s; charset = \"%s\"", $contentType, $charSet);
949    $result .= $this->LE;
950    $result .= $this->HeaderLine('Content-Transfer-Encoding', $encoding);
951    $result .= $this->LE;
952
953    return $result;
954  }
955
956  /**
957   * Returns the end of a message boundary.
958   * @access private
959   */
960  function EndBoundary($boundary) {
961    return $this->LE . '--' . $boundary . '--' . $this->LE;
962  }
963
964  /**
965   * Sets the message type.
966   * @access private
967   * @return void
968   */
969  function SetMessageType() {
970    if(count($this->attachment) < 1 && strlen($this->AltBody) < 1) {
971      $this->message_type = 'plain';
972    } else {
973      if(count($this->attachment) > 0) {
974        $this->message_type = 'attachments';
975      }
976      if(strlen($this->AltBody) > 0 && count($this->attachment) < 1) {
977        $this->message_type = 'alt';
978      }
979      if(strlen($this->AltBody) > 0 && count($this->attachment) > 0) {
980        $this->message_type = 'alt_attachments';
981      }
982    }
983  }
984
985  /* Returns a formatted header line.
986   * @access private
987   * @return string
988   */
989  function HeaderLine($name, $value) {
990    return $name . ': ' . $value . $this->LE;
991  }
992
993  /**
994   * Returns a formatted mail line.
995   * @access private
996   * @return string
997   */
998  function TextLine($value) {
999    return $value . $this->LE;
1000  }
1001
1002  /////////////////////////////////////////////////
1003  // CLASS METHODS, ATTACHMENTS
1004  /////////////////////////////////////////////////
1005
1006  /**
1007   * Adds an attachment from a path on the filesystem.
1008   * Returns false if the file could not be found
1009   * or accessed.
1010   * @param string $path Path to the attachment.
1011   * @param string $name Overrides the attachment name.
1012   * @param string $encoding File encoding (see $Encoding).
1013   * @param string $type File extension (MIME) type.
1014   * @return bool
1015   */
1016  function AddAttachment($path, $name = '', $encoding = 'base64', $type = 'application/octet-stream') {
1017    if(!@is_file($path)) {
1018      $this->SetError($this->Lang('file_access') . $path);
1019      return false;
1020    }
1021
1022    $filename = basename($path);
1023    if($name == '') {
1024      $name = $filename;
1025    }
1026
1027    $cur = count($this->attachment);
1028    $this->attachment[$cur][0] = $path;
1029    $this->attachment[$cur][1] = $filename;
1030    $this->attachment[$cur][2] = $name;
1031    $this->attachment[$cur][3] = $encoding;
1032    $this->attachment[$cur][4] = $type;
1033    $this->attachment[$cur][5] = false; // isStringAttachment
1034    $this->attachment[$cur][6] = 'attachment';
1035    $this->attachment[$cur][7] = 0;
1036
1037    return true;
1038  }
1039
1040  /**
1041   * Attaches all fs, string, and binary attachments to the message.
1042   * Returns an empty string on failure.
1043   * @access private
1044   * @return string
1045   */
1046  function AttachAll() {
1047    /* Return text of body */
1048    $mime = array();
1049
1050    /* Add all attachments */
1051    for($i = 0; $i < count($this->attachment); $i++) {
1052      /* Check for string attachment */
1053      $bString = $this->attachment[$i][5];
1054      if ($bString) {
1055        $string = $this->attachment[$i][0];
1056      } else {
1057        $path = $this->attachment[$i][0];
1058      }
1059
1060      $filename    = $this->attachment[$i][1];
1061      $name        = $this->attachment[$i][2];
1062      $encoding    = $this->attachment[$i][3];
1063      $type        = $this->attachment[$i][4];
1064      $disposition = $this->attachment[$i][6];
1065      $cid         = $this->attachment[$i][7];
1066
1067      $mime[] = sprintf("--%s%s", $this->boundary[1], $this->LE);
1068      $mime[] = sprintf("Content-Type: %s; name=\"%s\"%s", $type, $name, $this->LE);
1069      $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);
1070
1071      if($disposition == 'inline') {
1072        $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);
1073      }
1074
1075      $mime[] = sprintf("Content-Disposition: %s; filename=\"%s\"%s", $disposition, $name, $this->LE.$this->LE);
1076
1077      /* Encode as string attachment */
1078      if($bString) {
1079        $mime[] = $this->EncodeString($string, $encoding);
1080        if($this->IsError()) {
1081          return '';
1082        }
1083        $mime[] = $this->LE.$this->LE;
1084      } else {
1085        $mime[] = $this->EncodeFile($path, $encoding);
1086        if($this->IsError()) {
1087          return '';
1088        }
1089        $mime[] = $this->LE.$this->LE;
1090      }
1091    }
1092
1093    $mime[] = sprintf("--%s--%s", $this->boundary[1], $this->LE);
1094
1095    return join('', $mime);
1096  }
1097
1098  /**
1099   * Encodes attachment in requested format.  Returns an
1100   * empty string on failure.
1101   * @access private
1102   * @return string
1103   */
1104  function EncodeFile ($path, $encoding = 'base64') {
1105    if(!@$fd = fopen($path, 'rb')) {
1106      $this->SetError($this->Lang('file_open') . $path);
1107      return '';
1108    }
1109    $magic_quotes = get_magic_quotes_runtime();
1110    if($magic_quotes){
1111                ini_set('magic_quotes_runtime', 0);
1112        }
1113    $file_buffer = fread($fd, filesize($path));
1114    $file_buffer = $this->EncodeString($file_buffer, $encoding);
1115    fclose($fd);
1116    if($magic_quotes){
1117                ini_set('magic_quotes_runtime', 1);
1118        }
1119
1120    return $file_buffer;
1121  }
1122
1123  /**
1124   * Encodes string to requested format. Returns an
1125   * empty string on failure.
1126   * @access private
1127   * @return string
1128   */
1129  function EncodeString ($str, $encoding = 'base64') {
1130    $encoded = '';
1131    switch(strtolower($encoding)) {
1132      case 'base64':
1133        /* chunk_split is found in PHP >= 3.0.6 */
1134        $encoded = chunk_split(base64_encode($str), 76, $this->LE);
1135        break;
1136      case '7bit':
1137      case '8bit':
1138        $encoded = $this->FixEOL($str);
1139        if (substr($encoded, -(strlen($this->LE))) != $this->LE)
1140          $encoded .= $this->LE;
1141        break;
1142      case 'binary':
1143        $encoded = $str;
1144        break;
1145      case 'quoted-printable':
1146        $encoded = $this->EncodeQP($str);
1147        break;
1148      default:
1149        $this->SetError($this->Lang('encoding') . $encoding);
1150        break;
1151    }
1152    return $encoded;
1153  }
1154
1155  /**
1156   * Encode a header string to best of Q, B, quoted or none.
1157   * @access private
1158   * @return string
1159   */
1160  function EncodeHeader ($str, $position = 'text') {
1161    $x = 0;
1162
1163    switch (strtolower($position)) {
1164      case 'phrase':
1165        if (!preg_match('/[\200-\377]/', $str)) {
1166          /* Can't use addslashes as we don't know what value has magic_quotes_sybase. */
1167          $encoded = addcslashes($str, "\0..\37\177\\\"");
1168          if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str)) {
1169            return ($encoded);
1170          } else {
1171            return ("\"$encoded\"");
1172          }
1173        }
1174        $x = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
1175        break;
1176      case 'comment':
1177        $x = preg_match_all('/[()"]/', $str, $matches);
1178        /* Fall-through */
1179      case 'text':
1180      default:
1181        $x += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
1182        break;
1183    }
1184
1185    if ($x == 0) {
1186      return ($str);
1187    }
1188
1189    $maxlen = 75 - 7 - strlen($this->CharSet);
1190    /* Try to select the encoding which should produce the shortest output */
1191    if (strlen($str)/3 < $x) {
1192      $encoding = 'B';
1193      $encoded = base64_encode($str);
1194      $maxlen -= $maxlen % 4;
1195      $encoded = trim(chunk_split($encoded, $maxlen, "\n"));
1196    } else {
1197      $encoding = 'Q';
1198      $encoded = $this->EncodeQ($str, $position);
1199      $encoded = $this->WrapText($encoded, $maxlen, true);
1200      $encoded = str_replace('='.$this->LE, "\n", trim($encoded));
1201    }
1202
1203    $encoded = preg_replace('/^(.*)$/m', " =?".$this->CharSet."?$encoding?\\1?=", $encoded);
1204    $encoded = trim(str_replace("\n", $this->LE, $encoded));
1205
1206    return $encoded;
1207  }
1208
1209  /**
1210   * Encode string to quoted-printable.
1211   * @access private
1212   * @return string
1213   */
1214  function EncodeQP( $input = '', $line_max = 76, $space_conv = false ) {
1215    $hex = array('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');
1216    $lines = preg_split('/(?:\r\n|\r|\n)/', $input);
1217    $eol = "\r\n";
1218    $escape = '=';
1219    $output = '';
1220    while( list(, $line) = each($lines) ) {
1221      $linlen = strlen($line);
1222      $newline = '';
1223      for($i = 0; $i < $linlen; $i++) {
1224        $c = substr( $line, $i, 1 );
1225        $dec = ord( $c );
1226        if ( ( $i == 0 ) && ( $dec == 46 ) ) { // convert first point in the line into =2E
1227          $c = '=2E';
1228        }
1229        if ( $dec == 32 ) {
1230          if ( $i == ( $linlen - 1 ) ) { // convert space at eol only
1231            $c = '=20';
1232          } else if ( $space_conv ) {
1233            $c = '=20';
1234          }
1235        } elseif ( ($dec == 61) || ($dec < 32 ) || ($dec > 126) ) { // always encode "\t", which is *not* required
1236          $h2 = floor($dec/16);
1237          $h1 = floor($dec%16);
1238          $c = $escape.$hex[$h2].$hex[$h1];
1239        }
1240        if ( (strlen($newline) + strlen($c)) >= $line_max ) { // CRLF is not counted
1241          $output .= $newline.$escape.$eol; //  soft line break; " =\r\n" is okay
1242          $newline = '';
1243          // check if newline first character will be point or not
1244          if ( $dec == 46 ) {
1245            $c = '=2E';
1246          }
1247        }
1248        $newline .= $c;
1249      } // end of for
1250      $output .= $newline.$eol;
1251    } // end of while
1252    return trim($output);
1253  }
1254
1255  /**
1256   * Encode string to q encoding.
1257   * @access private
1258   * @return string
1259   */
1260  function EncodeQ ($str, $position = 'text') {
1261    /* There should not be any EOL in the string */
1262    $encoded = preg_replace("[\r\n]", '', $str);
1263
1264    switch (strtolower($position)) {
1265      case 'phrase':
1266        $encoded = preg_replace("/([^A-Za-z0-9!*+\/ -])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
1267        break;
1268      case 'comment':
1269        $encoded = preg_replace("/([\(\)\"])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
1270      case 'text':
1271      default:
1272        /* Replace every high ascii, control =, ? and _ characters */
1273        $encoded = preg_replace('/([\000-\011\013\014\016-\037\075\077\137\177-\377])/e',
1274              "'='.sprintf('%02X', ord('\\1'))", $encoded);
1275        break;
1276    }
1277
1278    /* Replace every spaces to _ (more readable than =20) */
1279    $encoded = str_replace(' ', '_', $encoded);
1280
1281    return $encoded;
1282  }
1283
1284  /**
1285   * Adds a string or binary attachment (non-filesystem) to the list.
1286   * This method can be used to attach ascii or binary data,
1287   * such as a BLOB record from a database.
1288   * @param string $string String attachment data.
1289   * @param string $filename Name of the attachment.
1290   * @param string $encoding File encoding (see $Encoding).
1291   * @param string $type File extension (MIME) type.
1292   * @return void
1293   */
1294  function AddStringAttachment($string, $filename, $encoding = 'base64', $type = 'application/octet-stream') {
1295    /* Append to $attachment array */
1296    $cur = count($this->attachment);
1297    $this->attachment[$cur][0] = $string;
1298    $this->attachment[$cur][1] = $filename;
1299    $this->attachment[$cur][2] = $filename;
1300    $this->attachment[$cur][3] = $encoding;
1301    $this->attachment[$cur][4] = $type;
1302    $this->attachment[$cur][5] = true; // isString
1303    $this->attachment[$cur][6] = 'attachment';
1304    $this->attachment[$cur][7] = 0;
1305  }
1306
1307  /**
1308   * Adds an embedded attachment.  This can include images, sounds, and
1309   * just about any other document.  Make sure to set the $type to an
1310   * image type.  For JPEG images use "image/jpeg" and for GIF images
1311   * use "image/gif".
1312   * @param string $path Path to the attachment.
1313   * @param string $cid Content ID of the attachment.  Use this to identify
1314   *        the Id for accessing the image in an HTML form.
1315   * @param string $name Overrides the attachment name.
1316   * @param string $encoding File encoding (see $Encoding).
1317   * @param string $type File extension (MIME) type.
1318   * @return bool
1319   */
1320  function AddEmbeddedImage($path, $cid, $name = '', $encoding = 'base64', $type = 'application/octet-stream') {
1321
1322    if(!@is_file($path)) {
1323      $this->SetError($this->Lang('file_access') . $path);
1324      return false;
1325    }
1326
1327    $filename = basename($path);
1328    if($name == '') {
1329      $name = $filename;
1330    }
1331
1332    /* Append to $attachment array */
1333    $cur = count($this->attachment);
1334    $this->attachment[$cur][0] = $path;
1335    $this->attachment[$cur][1] = $filename;
1336    $this->attachment[$cur][2] = $name;
1337    $this->attachment[$cur][3] = $encoding;
1338    $this->attachment[$cur][4] = $type;
1339    $this->attachment[$cur][5] = false;
1340    $this->attachment[$cur][6] = 'inline';
1341    $this->attachment[$cur][7] = $cid;
1342
1343    return true;
1344  }
1345
1346  /**
1347   * Returns true if an inline attachment is present.
1348   * @access private
1349   * @return bool
1350   */
1351  function InlineImageExists() {
1352    $result = false;
1353    for($i = 0; $i < count($this->attachment); $i++) {
1354      if($this->attachment[$i][6] == 'inline') {
1355        $result = true;
1356        break;
1357      }
1358    }
1359
1360    return $result;
1361  }
1362
1363  /////////////////////////////////////////////////
1364  // CLASS METHODS, MESSAGE RESET
1365  /////////////////////////////////////////////////
1366
1367  /**
1368   * Clears all recipients assigned in the TO array.  Returns void.
1369   * @return void
1370   */
1371  function ClearAddresses() {
1372    $this->to = array();
1373  }
1374
1375  /**
1376   * Clears all recipients assigned in the CC array.  Returns void.
1377   * @return void
1378   */
1379  function ClearCCs() {
1380    $this->cc = array();
1381  }
1382
1383  /**
1384   * Clears all recipients assigned in the BCC array.  Returns void.
1385   * @return void
1386   */
1387  function ClearBCCs() {
1388    $this->bcc = array();
1389  }
1390
1391  /**
1392   * Clears all recipients assigned in the ReplyTo array.  Returns void.
1393   * @return void
1394   */
1395  function ClearReplyTos() {
1396    $this->ReplyTo = array();
1397  }
1398
1399  /**
1400   * Clears all recipients assigned in the TO, CC and BCC
1401   * array.  Returns void.
1402   * @return void
1403   */
1404  function ClearAllRecipients() {
1405    $this->to = array();
1406    $this->cc = array();
1407    $this->bcc = array();
1408  }
1409
1410  /**
1411   * Clears all previously set filesystem, string, and binary
1412   * attachments.  Returns void.
1413   * @return void
1414   */
1415  function ClearAttachments() {
1416    $this->attachment = array();
1417  }
1418
1419  /**
1420   * Clears all custom headers.  Returns void.
1421   * @return void
1422   */
1423  function ClearCustomHeaders() {
1424    $this->CustomHeader = array();
1425  }
1426
1427  /////////////////////////////////////////////////
1428  // CLASS METHODS, MISCELLANEOUS
1429  /////////////////////////////////////////////////
1430
1431  /**
1432   * Adds the error message to the error container.
1433   * Returns void.
1434   * @access private
1435   * @return void
1436   */
1437  function SetError($msg) {
1438    $this->error_count++;
1439    $this->ErrorInfo = $msg;
1440  }
1441
1442  /**
1443   * Returns the proper RFC 822 formatted date.
1444   * @access private
1445   * @return string
1446   */
1447  function RFCDate() {
1448    $tz = date('Z');
1449    $tzs = ($tz < 0) ? '-' : '+';
1450    $tz = abs($tz);
1451    $tz = (int)($tz/3600)*100 + ($tz%3600)/60;
1452    $result = sprintf("%s %s%04d", date('D, j M Y H:i:s'), $tzs, $tz);
1453
1454    return $result;
1455  }
1456
1457  /**
1458   * Returns the appropriate server variable.  Should work with both
1459   * PHP 4.1.0+ as well as older versions.  Returns an empty string
1460   * if nothing is found.
1461   * @access private
1462   * @return mixed
1463   */
1464  function ServerVar($varName) {
1465    global $HTTP_SERVER_VARS;
1466    global $HTTP_ENV_VARS;
1467
1468    if(!isset($_SERVER)) {
1469      $_SERVER = $HTTP_SERVER_VARS;
1470      if(!isset($_SERVER['REMOTE_ADDR'])) {
1471        $_SERVER = $HTTP_ENV_VARS; // must be Apache
1472      }
1473    }
1474
1475    if(isset($_SERVER[$varName])) {
1476      return $_SERVER[$varName];
1477    } else {
1478      return '';
1479    }
1480  }
1481
1482  /**
1483   * Returns the server hostname or 'localhost.localdomain' if unknown.
1484   * @access private
1485   * @return string
1486   */
1487  function ServerHostname() {
1488    if ($this->Hostname != '') {
1489      $result = $this->Hostname;
1490    } elseif ($this->ServerVar('SERVER_NAME') != '') {
1491      $result = $this->ServerVar('SERVER_NAME');
1492    } else {
1493      $result = 'localhost.localdomain';
1494    }
1495
1496    return $result;
1497  }
1498
1499  /**
1500   * Returns a message in the appropriate language.
1501   * @access private
1502   * @return string
1503   */
1504  function Lang($key) {
1505    if(count($this->language) < 1) {
1506      $this->SetLanguage('en'); // set the default language
1507    }
1508
1509    if(isset($this->language[$key])) {
1510      return $this->language[$key];
1511    } else {
1512      return 'Language string failed to load: ' . $key;
1513    }
1514  }
1515
1516  /**
1517   * Returns true if an error occurred.
1518   * @return bool
1519   */
1520  function IsError() {
1521    return ($this->error_count > 0);
1522  }
1523
1524  /**
1525   * Changes every end of line from CR or LF to CRLF.
1526   * @access private
1527   * @return string
1528   */
1529  function FixEOL($str) {
1530    $str = str_replace("\r\n", "\n", $str);
1531    $str = str_replace("\r", "\n", $str);
1532    $str = str_replace("\n", $this->LE, $str);
1533    return $str;
1534  }
1535
1536  /**
1537   * Adds a custom header.
1538   * @return void
1539   */
1540  function AddCustomHeader($custom_header) {
1541    $this->CustomHeader[] = explode(':', $custom_header, 2);
1542  }
1543
1544  /**
1545   * Evaluates the message and returns modifications for inline images and backgrounds
1546   * @access public
1547   * @return $message
1548   */
1549  function MsgHTML($message) {
1550    preg_match_all("/(src|background)=\"(.*)\"/Ui", $message, $images);
1551    if(isset($images[2])) {
1552      foreach($images[2] as $i => $url) {
1553        $filename  = basename($url);
1554        $directory = dirname($url);
1555        $cid       = 'cid:' . md5($filename);
1556        $fileParts = explode(".", $filename);
1557        $ext       = $fileParts[1];
1558        $mimeType  = $this->_mime_types($ext);
1559        $message = preg_replace("/".$images[1][$i]."=\"".preg_quote($url, '/')."\"/Ui", $images[1][$i]."=\"".$cid."\"", $message);
1560        $this->AddEmbeddedImage($url, md5($filename), $filename, 'base64', $mimeType);
1561      }
1562    }
1563    $this->IsHTML(true);
1564    $this->Body = $message;
1565    $textMsg = trim(strip_tags($message));
1566    if ( !empty($textMsg) && empty($this->AltBody) ) {
1567      $this->AltBody = $textMsg;
1568    }
1569    if ( empty($this->AltBody) ) {
1570      $this->AltBody = 'To view this email message, open the email in with HTML compatibility!' . "\n\n";
1571    }
1572  }
1573
1574  /**
1575   * Gets the mime type of the embedded or inline image
1576   * @access private
1577   * @return mime type of ext
1578   */
1579  function _mime_types($ext = '') {
1580    $mimes = array(
1581      'hqx'  =>  'application/mac-binhex40',
1582      'cpt'   =>  'application/mac-compactpro',
1583      'doc'   =>  'application/msword',
1584      'bin'   =>  'application/macbinary',
1585      'dms'   =>  'application/octet-stream',
1586      'lha'   =>  'application/octet-stream',
1587      'lzh'   =>  'application/octet-stream',
1588      'exe'   =>  'application/octet-stream',
1589      'class' =>  'application/octet-stream',
1590      'psd'   =>  'application/octet-stream',
1591      'so'    =>  'application/octet-stream',
1592      'sea'   =>  'application/octet-stream',
1593      'dll'   =>  'application/octet-stream',
1594      'oda'   =>  'application/oda',
1595      'pdf'   =>  'application/pdf',
1596      'ai'    =>  'application/postscript',
1597      'eps'   =>  'application/postscript',
1598      'ps'    =>  'application/postscript',
1599      'smi'   =>  'application/smil',
1600      'smil'  =>  'application/smil',
1601      'mif'   =>  'application/vnd.mif',
1602      'xls'   =>  'application/vnd.ms-excel',
1603      'ppt'   =>  'application/vnd.ms-powerpoint',
1604      'wbxml' =>  'application/vnd.wap.wbxml',
1605      'wmlc'  =>  'application/vnd.wap.wmlc',
1606      'dcr'   =>  'application/x-director',
1607      'dir'   =>  'application/x-director',
1608      'dxr'   =>  'application/x-director',
1609      'dvi'   =>  'application/x-dvi',
1610      'gtar'  =>  'application/x-gtar',
1611      'php'   =>  'application/x-httpd-php',
1612      'php4'  =>  'application/x-httpd-php',
1613      'php3'  =>  'application/x-httpd-php',
1614      'phtml' =>  'application/x-httpd-php',
1615      'phps'  =>  'application/x-httpd-php-source',
1616      'js'    =>  'application/x-javascript',
1617      'swf'   =>  'application/x-shockwave-flash',
1618      'sit'   =>  'application/x-stuffit',
1619      'tar'   =>  'application/x-tar',
1620      'tgz'   =>  'application/x-tar',
1621      'xhtml' =>  'application/xhtml+xml',
1622      'xht'   =>  'application/xhtml+xml',
1623      'zip'   =>  'application/zip',
1624      'mid'   =>  'audio/midi',
1625      'midi'  =>  'audio/midi',
1626      'mpga'  =>  'audio/mpeg',
1627      'mp2'   =>  'audio/mpeg',
1628      'mp3'   =>  'audio/mpeg',
1629      'aif'   =>  'audio/x-aiff',
1630      'aiff'  =>  'audio/x-aiff',
1631      'aifc'  =>  'audio/x-aiff',
1632      'ram'   =>  'audio/x-pn-realaudio',
1633      'rm'    =>  'audio/x-pn-realaudio',
1634      'rpm'   =>  'audio/x-pn-realaudio-plugin',
1635      'ra'    =>  'audio/x-realaudio',
1636      'rv'    =>  'video/vnd.rn-realvideo',
1637      'wav'   =>  'audio/x-wav',
1638      'bmp'   =>  'image/bmp',
1639      'gif'   =>  'image/gif',
1640      'jpeg'  =>  'image/jpeg',
1641      'jpg'   =>  'image/jpeg',
1642      'jpe'   =>  'image/jpeg',
1643      'png'   =>  'image/png',
1644      'tiff'  =>  'image/tiff',
1645      'tif'   =>  'image/tiff',
1646      'css'   =>  'text/css',
1647      'html'  =>  'text/html',
1648      'htm'   =>  'text/html',
1649      'shtml' =>  'text/html',
1650      'txt'   =>  'text/plain',
1651      'text'  =>  'text/plain',
1652      'log'   =>  'text/plain',
1653      'rtx'   =>  'text/richtext',
1654      'rtf'   =>  'text/rtf',
1655      'xml'   =>  'text/xml',
1656      'xsl'   =>  'text/xml',
1657      'mpeg'  =>  'video/mpeg',
1658      'mpg'   =>  'video/mpeg',
1659      'mpe'   =>  'video/mpeg',
1660      'qt'    =>  'video/quicktime',
1661      'mov'   =>  'video/quicktime',
1662      'avi'   =>  'video/x-msvideo',
1663      'movie' =>  'video/x-sgi-movie',
1664      'doc'   =>  'application/msword',
1665      'word'  =>  'application/msword',
1666      'xl'    =>  'application/excel',
1667      'eml'   =>  'message/rfc822'
1668    );
1669    return ( ! isset($mimes[strtolower($ext)])) ? 'application/x-unknown-content-type' : $mimes[strtolower($ext)];
1670  }
1671
1672  /**
1673   * Set (or reset) Class Objects (variables)
1674   *
1675   * Usage Example:
1676   * $page->set('X-Priority', '3');
1677   *
1678   * @access public
1679   * @param string $name Parameter Name
1680   * @param mixed $value Parameter Value
1681   * NOTE: will not work with arrays, there are no arrays to set/reset
1682   */
1683  function set ( $name, $value = '' ) {
1684    if ( isset($this->$name) ) {
1685      $this->$name = $value;
1686    } else {
1687      $this->SetError('Cannot set or reset variable ' . $name);
1688      return false;
1689    }
1690  }
1691
1692  /**
1693   * Read a file from a supplied filename and return it.
1694   *
1695   * @access public
1696   * @param string $filename Parameter File Name
1697   */
1698  function getFile($filename) {
1699    $return = '';
1700    if ($fp = fopen($filename, 'rb')) {
1701      while (!feof($fp)) {
1702        $return .= fread($fp, 1024);
1703      }
1704      fclose($fp);
1705      return $return;
1706    } else {
1707      return false;
1708    }
1709  }
1710
1711  /**
1712   * Strips newlines to prevent header injection.
1713   * @access private
1714   * @param string $str String
1715   * @return string
1716   */
1717  function SecureHeader($str) {
1718    $str = trim($str);
1719    $str = str_replace("\r", "", $str);
1720    $str = str_replace("\n", "", $str);
1721    return $str;
1722  }
1723
1724}
1725
1726?>
Note: See TracBrowser for help on using the repository browser.