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