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