Kostenloses Webkatalog Script - Link Script

kostenloses Webkatalog Script - Datei: phpmailer/class.phpmailer.php

  
  Download Webkatalog Script   Demo Webkatalog   Demo Adminbereich   Bücher PHP & Mysql   Forum  
 
Home » phpmailer/class.phpmailer.php

Linkaufbau & Link Building Steigerung der Relevanz, des PageRanks und der Besucherzahlen sind die Ziele von Link Building. Die [ Wekatalog Skript Erweiterung ] bietet eine einfache Möglichkeit der Steigerung der Besucherzahlen als auch Relevanz einer Website bei den etablierten Suchdienste Google, Yahoo, MSN oder ASK.

Einbindungsbeispiel Surftipps & Linkpartner
Webkatalog und Partner Seiten

<?
/* Beispiel zum Einbinden */
define('CG_LINK', true);
@include ('url-anmelden-link-eintragen
/cg_config.php');
/*
Varibale $linkswebkat in *.php einbinden
<? echo $linkswebkat; ?>
Erzeugte Ausgabe:
Surftipps & Linkpartner
Webkatalog und Partner Seiten
*/
?>

Dateiname phpmailer/class.phpmailer.php (Größe 44.2 kB) (last upate 11.01.2007)
  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           = "iso-8859-1";
  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               = "root@localhost";
  62.  
  63.     /**
  64.      * Sets the From name of the message.
  65.      * @var string
  66.      */
  67.     var $FromName           = "Root User";
  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 (!is_dir($lang_path)) {
  598.           $lang_path = basename(__FILE__) . "/".$lang_path;
  599.         }
  600.         if(file_exists($lang_path.'phpmailer.lang-'.$lang_type.'.php'))
  601.             include($lang_path.'phpmailer.lang-'.$lang_type.'.php');
  602.         else if(file_exists($lang_path.'phpmailer.lang-en.php'))
  603.             include($lang_path.'phpmailer.lang-en.php');
  604.         else
  605.         {
  606.             $this->SetError("Could not load language file");
  607.             return false;
  608.         }
  609.         $this->language = $PHPMAILER_LANG;
  610.  
  611.         return true;
  612.     }
  613.  
  614.     /////////////////////////////////////////////////
  615.     // MESSAGE CREATION METHODS
  616.     /////////////////////////////////////////////////
  617.  
  618.     /**
  619.      * Creates recipient headers.
  620.      * @access private
  621.      * @return string
  622.      */
  623.     function AddrAppend($type, $addr) {
  624.         $addr_str = $type . ": ";
  625.         $addr_str .= $this->AddrFormat($addr[0]);
  626.         if(count($addr) > 1)
  627.         {
  628.             for($i = 1; $i < count($addr); $i++)
  629.                 $addr_str .= ", " . $this->AddrFormat($addr[$i]);
  630.         }
  631.         $addr_str .= $this->LE;
  632.  
  633.         return $addr_str;
  634.     }
  635.  
  636.     /**
  637.      * Formats an address correctly.
  638.      * @access private
  639.      * @return string
  640.      */
  641.     function AddrFormat($addr) {
  642.         if(empty($addr[1]))
  643.             $formatted = $addr[0];
  644.         else
  645.         {
  646.             $formatted = $this->EncodeHeader($addr[1], 'phrase') . " <" .
  647.                          $addr[0] . ">";
  648.         }
  649.  
  650.         return $formatted;
  651.     }
  652.  
  653.     /**
  654.      * Wraps message for use with mailers that do not
  655.      * automatically perform wrapping and for quoted-printable.
  656.      * Original written by philippe.
  657.      * @access private
  658.      * @return string
  659.      */
  660.     function WrapText($message, $length, $qp_mode = false) {
  661.         $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
  662.  
  663.         $message = $this->FixEOL($message);
  664.         if (substr($message, -1) == $this->LE)
  665.             $message = substr($message, 0, -1);
  666.  
  667.         $line = explode($this->LE, $message);
  668.         $message = "";
  669.         for ($i=0 ;$i < count($line); $i++)
  670.         {
  671.           $line_part = explode(" ", $line[$i]);
  672.           $buf = "";
  673.           for ($e = 0; $e<count($line_part); $e++)
  674.           {
  675.               $word = $line_part[$e];
  676.               if ($qp_mode and (strlen($word) > $length))
  677.               {
  678.                 $space_left = $length - strlen($buf) - 1;
  679.                 if ($e != 0)
  680.                 {
  681.                     if ($space_left > 20)
  682.                     {
  683.                         $len = $space_left;
  684.                         if (substr($word, $len - 1, 1) == "=")
  685.                           $len--;
  686.                         elseif (substr($word, $len - 2, 1) == "=")
  687.                           $len -= 2;
  688.                         $part = substr($word, 0, $len);
  689.                         $word = substr($word, $len);
  690.                         $buf .= " " . $part;
  691.                         $message .= $buf . sprintf("=%s", $this->LE);
  692.                     }
  693.                     else
  694.                     {
  695.                         $message .= $buf . $soft_break;
  696.                     }
  697.                     $buf = "";
  698.                 }
  699.                 while (strlen($word) > 0)
  700.                 {
  701.                     $len = $length;
  702.                     if (substr($word, $len - 1, 1) == "=")
  703.                         $len--;
  704.                     elseif (substr($word, $len - 2, 1) == "=")
  705.                         $len -= 2;
  706.                     $part = substr($word, 0, $len);
  707.                     $word = substr($word, $len);
  708.  
  709.                     if (strlen($word) > 0)
  710.                         $message .= $part . sprintf("=%s", $this->LE);
  711.                     else
  712.                         $buf = $part;
  713.                 }
  714.               }
  715.               else
  716.               {
  717.                 $buf_o = $buf;
  718.                 $buf .= ($e == 0) ? $word : (" " . $word);
  719.  
  720.                 if (strlen($buf) > $length and $buf_o != "")
  721.                 {
  722.                     $message .= $buf_o . $soft_break;
  723.                     $buf = $word;
  724.                 }
  725.               }
  726.           }
  727.           $message .= $buf . $this->LE;
  728.         }
  729.  
  730.         return $message;
  731.     }
  732.  
  733.     /**
  734.      * Set the body wrapping.
  735.      * @access private
  736.      * @return void
  737.      */
  738.     function SetWordWrap() {
  739.         if($this->WordWrap < 1)
  740.             return;
  741.  
  742.         switch($this->message_type)
  743.         {
  744.            case "alt":
  745.               // fall through
  746.            case "alt_attachments":
  747.               $this->AltBody = $this->WrapText($this->AltBody, $this->WordWrap);
  748.               break;
  749.            default:
  750.               $this->Body = $this->WrapText($this->Body, $this->WordWrap);
  751.               break;
  752.         }
  753.     }
  754.  
  755.     /**
  756.      * Assembles message header.
  757.      * @access private
  758.      * @return string
  759.      */
  760.     function CreateHeader() {
  761.         $result = "";
  762.  
  763.         // Set the boundaries
  764.         $uniq_id = md5(uniqid(time()));
  765.         $this->boundary[1] = "b1_" . $uniq_id;
  766.         $this->boundary[2] = "b2_" . $uniq_id;
  767.  
  768.         $result .= $this->HeaderLine("Date", $this->RFCDate());
  769.         if($this->Sender == "")
  770.             $result .= $this->HeaderLine("Return-Path", trim($this->From));
  771.         else
  772.             $result .= $this->HeaderLine("Return-Path", trim($this->Sender));
  773.  
  774.         // To be created automatically by mail()
  775.         if($this->Mailer != "mail")
  776.         {
  777.             if(count($this->to) > 0)
  778.                 $result .= $this->AddrAppend("To", $this->to);
  779.             else if (count($this->cc) == 0)
  780.                 $result .= $this->HeaderLine("To", "undisclosed-recipients:;");
  781.             if(count($this->cc) > 0)
  782.                 $result .= $this->AddrAppend("Cc", $this->cc);
  783.         }
  784.  
  785.         $from = array();
  786.         $from[0][0] = trim($this->From);
  787.         $from[0][1] = $this->FromName;
  788.         $result .= $this->AddrAppend("From", $from);
  789.  
  790.         // sendmail and mail() extract Bcc from the header before sending
  791.         if((($this->Mailer == "sendmail") || ($this->Mailer == "mail")) && (count($this->bcc) > 0))
  792.             $result .= $this->AddrAppend("Bcc", $this->bcc);
  793.  
  794.         if(count($this->ReplyTo) > 0)
  795.             $result .= $this->AddrAppend("Reply-to", $this->ReplyTo);
  796.  
  797.         // mail() sets the subject itself
  798.         if($this->Mailer != "mail")
  799.             $result .= $this->HeaderLine("Subject", $this->EncodeHeader(trim($this->Subject)));
  800.  
  801.         $result .= sprintf("Message-ID: <%s@%s>%s", $uniq_id, $this->ServerHostname(), $this->LE);
  802.         $result .= $this->HeaderLine("X-Priority", $this->Priority);
  803.         $result .= $this->HeaderLine("X-Mailer", "PHPMailer [version " . $this->Version . "]");
  804.  
  805.         if($this->ConfirmReadingTo != "")
  806.         {
  807.             $result .= $this->HeaderLine("Disposition-Notification-To",
  808.                        "<" . trim($this->ConfirmReadingTo) . ">");
  809.         }
  810.  
  811.         // Add custom headers
  812.         for($index = 0; $index < count($this->CustomHeader); $index++)
  813.         {
  814.             $result .= $this->HeaderLine(trim($this->CustomHeader[$index][0]),
  815.                        $this->EncodeHeader(trim($this->CustomHeader[$index][1])));
  816.         }
  817.         $result .= $this->HeaderLine("MIME-Version", "1.0");
  818.  
  819.         switch($this->message_type)
  820.         {
  821.             case "plain":
  822.                 $result .= $this->HeaderLine("Content-Transfer-Encoding", $this->Encoding);
  823.                 $result .= sprintf("Content-Type: %s; charset=\"%s\"",
  824.                                     $this->ContentType, $this->CharSet);
  825.                 break;
  826.             case "attachments":
  827.                 // fall through
  828.             case "alt_attachments":
  829.                 if($this->InlineImageExists())
  830.                 {
  831.                     $result .= sprintf("Content-Type: %s;%s\ttype=\"text/html\";%s\tboundary=\"%s\"%s",
  832.                                     "multipart/related", $this->LE, $this->LE,
  833.                                     $this->boundary[1], $this->LE);
  834.                 }
  835.                 else
  836.                 {
  837.                     $result .= $this->HeaderLine("Content-Type", "multipart/mixed;");
  838.                     $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
  839.                 }
  840.                 break;
  841.             case "alt":
  842.                 $result .= $this->HeaderLine("Content-Type", "multipart/alternative;");
  843.                 $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
  844.                 break;
  845.         }
  846.  
  847.         if($this->Mailer != "mail")
  848.             $result .= $this->LE.$this->LE;
  849.  
  850.         return $result;
  851.     }
  852.  
  853.     /**
  854.      * Assembles the message body.  Returns an empty string on failure.
  855.      * @access private
  856.      * @return string
  857.      */
  858.     function CreateBody() {
  859.         $result = "";
  860.  
  861.         $this->SetWordWrap();
  862.  
  863.         switch($this->message_type)
  864.         {
  865.             case "alt":
  866.                 $result .= $this->GetBoundary($this->boundary[1], "",
  867.                                               "text/plain", "");
  868.                 $result .= $this->EncodeString($this->AltBody, $this->Encoding);
  869.                 $result .= $this->LE.$this->LE;
  870.                 $result .= $this->GetBoundary($this->boundary[1], "",
  871.                                               "text/html", "");
  872.  
  873.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  874.                 $result .= $this->LE.$this->LE;
  875.  
  876.                 $result .= $this->EndBoundary($this->boundary[1]);
  877.                 break;
  878.             case "plain":
  879.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  880.                 break;
  881.             case "attachments":
  882.                 $result .= $this->GetBoundary($this->boundary[1], "", "", "");
  883.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  884.                 $result .= $this->LE;
  885.  
  886.                 $result .= $this->AttachAll();
  887.                 break;
  888.             case "alt_attachments":
  889.                 $result .= sprintf("--%s%s", $this->boundary[1], $this->LE);
  890.                 $result .= sprintf("Content-Type: %s;%s" .
  891.                                    "\tboundary=\"%s\"%s",
  892.                                    "multipart/alternative", $this->LE,
  893.                                    $this->boundary[2], $this->LE.$this->LE);
  894.  
  895.                 // Create text body
  896.                 $result .= $this->GetBoundary($this->boundary[2], "",
  897.                                               "text/plain", "") . $this->LE;
  898.  
  899.                 $result .= $this->EncodeString($this->AltBody, $this->Encoding);
  900.                 $result .= $this->LE.$this->LE;
  901.  
  902.                 // Create the HTML body
  903.                 $result .= $this->GetBoundary($this->boundary[2], "",
  904.                                               "text/html", "") . $this->LE;
  905.  
  906.                 $result .= $this->EncodeString($this->Body, $this->Encoding);
  907.                 $result .= $this->LE.$this->LE;
  908.  
  909.                 $result .= $this->EndBoundary($this->boundary[2]);
  910.  
  911.                 $result .= $this->AttachAll();
  912.                 break;
  913.         }
  914.         if($this->IsError())
  915.             $result = "";
  916.  
  917.         return $result;
  918.     }
  919.  
  920.     /**
  921.      * Returns the start of a message boundary.
  922.      * @access private
  923.      */
  924.     function GetBoundary($boundary, $charSet, $contentType, $encoding) {
  925.         $result = "";
  926.         if($charSet == "") { $charSet = $this->CharSet; }
  927.         if($contentType == "") { $contentType = $this->ContentType; }
  928.         if($encoding == "") { $encoding = $this->Encoding; }
  929.  
  930.         $result .= $this->TextLine("--" . $boundary);
  931.         $result .= sprintf("Content-Type: %s; charset = \"%s\"",
  932.                             $contentType, $charSet);
  933.         $result .= $this->LE;
  934.         $result .= $this->HeaderLine("Content-Transfer-Encoding", $encoding);
  935.         $result .= $this->LE;
  936.  
  937.         return $result;
  938.     }
  939.  
  940.     /**
  941.      * Returns the end of a message boundary.
  942.      * @access private
  943.      */
  944.     function EndBoundary($boundary) {
  945.         return $this->LE . "--" . $boundary . "--" . $this->LE;
  946.     }
  947.  
  948.     /**
  949.      * Sets the message type.
  950.      * @access private
  951.      * @return void
  952.      */
  953.     function SetMessageType() {
  954.         if(count($this->attachment) < 1 && strlen($this->AltBody) < 1)
  955.             $this->message_type = "plain";
  956.         else
  957.         {
  958.             if(count($this->attachment) > 0)
  959.                 $this->message_type = "attachments";
  960.             if(strlen($this->AltBody) > 0 && count($this->attachment) < 1)
  961.                 $this->message_type = "alt";
  962.             if(strlen($this->AltBody) > 0 && count($this->attachment) > 0)
  963.                 $this->message_type = "alt_attachments";
  964.         }
  965.     }
  966.  
  967.     /**
  968.      * Returns a formatted header line.
  969.      * @access private
  970.      * @return string
  971.      */
  972.     function HeaderLine($name, $value) {
  973.         return $name . ": " . $value . $this->LE;
  974.     }
  975.  
  976.     /**
  977.      * Returns a formatted mail line.
  978.      * @access private
  979.      * @return string
  980.      */
  981.     function TextLine($value) {
  982.         return $value . $this->LE;
  983.     }
  984.  
  985.     /////////////////////////////////////////////////
  986.     // ATTACHMENT METHODS
  987.     /////////////////////////////////////////////////
  988.  
  989.     /**
  990.      * Adds an attachment from a path on the filesystem.
  991.      * Returns false if the file could not be found
  992.      * or accessed.
  993.      * @param string $path Path to the attachment.
  994.      * @param string $name Overrides the attachment name.
  995.      * @param string $encoding File encoding (see $Encoding).
  996.      * @param string $type File extension (MIME) type.
  997.      * @return bool
  998.      */
  999.     function AddAttachment($path, $name = "", $encoding = "base64",
  1000.                            $type = "application/octet-stream") {
  1001.         if(!@is_file($path))
  1002.         {
  1003.             $this->SetError($this->Lang("file_access") . $path);
  1004.             return false;
  1005.         }
  1006.  
  1007.         $filename = basename($path);
  1008.         if($name == "")
  1009.             $name = $filename;
  1010.  
  1011.         $cur = count($this->attachment);
  1012.         $this->attachment[$cur][0] = $path;
  1013.         $this->attachment[$cur][1] = $filename;
  1014.         $this->attachment[$cur][2] = $name;
  1015.         $this->attachment[$cur][3] = $encoding;
  1016.         $this->attachment[$cur][4] = $type;
  1017.         $this->attachment[$cur][5] = false; // isStringAttachment
  1018.         $this->attachment[$cur][6] = "attachment";
  1019.         $this->attachment[$cur][7] = 0;
  1020.  
  1021.         return true;
  1022.     }
  1023.  
  1024.     /**
  1025.      * Attaches all fs, string, and binary attachments to the message.
  1026.      * Returns an empty string on failure.
  1027.      * @access private
  1028.      * @return string
  1029.      */
  1030.     function AttachAll() {
  1031.         // Return text of body
  1032.         $mime = array();
  1033.  
  1034.         // Add all attachments
  1035.         for($i = 0; $i < count($this->attachment); $i++)
  1036.         {
  1037.             // Check for string attachment
  1038.             $bString = $this->attachment[$i][5];
  1039.             if ($bString)
  1040.                 $string = $this->attachment[$i][0];
  1041.             else
  1042.                 $path = $this->attachment[$i][0];
  1043.  
  1044.             $filename    = $this->attachment[$i][1];
  1045.             $name        = $this->attachment[$i][2];
  1046.             $encoding    = $this->attachment[$i][3];
  1047.             $type        = $this->attachment[$i][4];
  1048.             $disposition = $this->attachment[$i][6];
  1049.             $cid         = $this->attachment[$i][7];
  1050.  
  1051.             $mime[] = sprintf("--%s%s", $this->boundary[1], $this->LE);
  1052.             $mime[] = sprintf("Content-Type: %s; name=\"%s\"%s", $type, $name, $this->LE);
  1053.             $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);
  1054.  
  1055.             if($disposition == "inline")
  1056.                 $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);
  1057.  
  1058.             $mime[] = sprintf("Content-Disposition: %s; filename=\"%s\"%s",
  1059.                               $disposition, $name, $this->LE.$this->LE);
  1060.  
  1061.             // Encode as string attachment
  1062.             if($bString)
  1063.             {
  1064.                 $mime[] = $this->EncodeString($string, $encoding);
  1065.                 if($this->IsError()) { return ""; }
  1066.                 $mime[] = $this->LE.$this->LE;
  1067.             }
  1068.             else
  1069.             {
  1070.                 $mime[] = $this->EncodeFile($path, $encoding);
  1071.                 if($this->IsError()) { return ""; }
  1072.                 $mime[] = $this->LE.$this->LE;
  1073.             }
  1074.         }
  1075.  
  1076.         $mime[] = sprintf("--%s--%s", $this->boundary[1], $this->LE);
  1077.  
  1078.         return join("", $mime);
  1079.     }
  1080.  
  1081.     /**
  1082.      * Encodes attachment in requested format.  Returns an
  1083.      * empty string on failure.
  1084.      * @access private
  1085.      * @return string
  1086.      */
  1087.     function EncodeFile ($path, $encoding = "base64") {
  1088.         if(!@$fd = fopen($path, "rb"))
  1089.         {
  1090.             $this->SetError($this->Lang("file_open") . $path);
  1091.             return "";
  1092.         }
  1093.         $magic_quotes = get_magic_quotes_runtime();
  1094.         set_magic_quotes_runtime(0);
  1095.         $file_buffer = fread($fd, filesize($path));
  1096.         $file_buffer = $this->EncodeString($file_buffer, $encoding);
  1097.         fclose($fd);
  1098.         set_magic_quotes_runtime($magic_quotes);
  1099.  
  1100.         return $file_buffer;
  1101.     }
  1102.  
  1103.     /**
  1104.      * Encodes string to requested format. Returns an
  1105.      * empty string on failure.
  1106.      * @access private
  1107.      * @return string
  1108.      */
  1109.     function EncodeString ($str, $encoding = "base64") {
  1110.         $encoded = "";
  1111.         switch(strtolower($encoding)) {
  1112.           case "base64":
  1113.               // chunk_split is found in PHP >= 3.0.6
  1114.               $encoded = chunk_split(base64_encode($str), 76, $this->LE);
  1115.               break;
  1116.           case "7bit":
  1117.           case "8bit":
  1118.               $encoded = $this->FixEOL($str);
  1119.               if (substr($encoded, -(strlen($this->LE))) != $this->LE)
  1120.                 $encoded .= $this->LE;
  1121.               break;
  1122.           case "binary":
  1123.               $encoded = $str;
  1124.               break;
  1125.           case "quoted-printable":
  1126.               $encoded = $this->EncodeQP($str);
  1127.               break;
  1128.           default:
  1129.               $this->SetError($this->Lang("encoding") . $encoding);
  1130.               break;
  1131.         }
  1132.         return $encoded;
  1133.     }
  1134.  
  1135.     /**
  1136.      * Encode a header string to best of Q, B, quoted or none.
  1137.      * @access private
  1138.      * @return string
  1139.      */
  1140.     function EncodeHeader ($str, $position = 'text') {
  1141.       $x = 0;
  1142.  
  1143.       switch (strtolower($position)) {
  1144.         case 'phrase':
  1145.           if (!preg_match('/[\200-\377]/', $str)) {
  1146.             // Can't use addslashes as we don't know what value has magic_quotes_sybase.
  1147.             $encoded = addcslashes($str, "\0..\37\177\\\"");
  1148.  
  1149.             if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str))
  1150.               return ($encoded);
  1151.             else
  1152.               return ("\"$encoded\"");
  1153.           }
  1154.           $x = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
  1155.           break;
  1156.         case 'comment':
  1157.           $x = preg_match_all('/[()"]/', $str, $matches);
  1158.           // Fall-through
  1159.         case 'text':
  1160.         default:
  1161.           $x += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
  1162.           break;
  1163.       }
  1164.  
  1165.       if ($x == 0)
  1166.         return ($str);
  1167.  
  1168.       $maxlen = 75 - 7 - strlen($this->CharSet);
  1169.       // Try to select the encoding which should produce the shortest output
  1170.       if (strlen($str)/3 < $x) {
  1171.         $encoding = 'B';
  1172.         $encoded = base64_encode($str);
  1173.         $maxlen -= $maxlen % 4;
  1174.         $encoded = trim(chunk_split($encoded, $maxlen, "\n"));
  1175.       } else {
  1176.         $encoding = 'Q';
  1177.         $encoded = $this->EncodeQ($str, $position);
  1178.         $encoded = $this->WrapText($encoded, $maxlen, true);
  1179.         $encoded = str_replace("=".$this->LE, "\n", trim($encoded));
  1180.       }
  1181.  
  1182.       $encoded = preg_replace('/^(.*)$/m', " =?".$this->CharSet."?$encoding?\\1?=", $encoded);
  1183.       $encoded = trim(str_replace("\n", $this->LE, $encoded));
  1184.  
  1185.       return $encoded;
  1186.     }
  1187.  
  1188.     /**
  1189.      * Encode string to quoted-printable.
  1190.      * @access private
  1191.      * @return string
  1192.      */
  1193.     function EncodeQP ($str) {
  1194.         $encoded = $this->FixEOL($str);
  1195.         if (substr($encoded, -(strlen($this->LE))) != $this->LE)
  1196.             $encoded .= $this->LE;
  1197.  
  1198.         // Replace every high ascii, control and = characters
  1199.         $encoded = preg_replace('/([\000-\010\013\014\016-\037\075\177-\377])/e',
  1200.                   "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1201.         // Replace every spaces and tabs when it's the last character on a line
  1202.         $encoded = preg_replace("/([\011\040])".$this->LE."/e",
  1203.                   "'='.sprintf('%02X', ord('\\1')).'".$this->LE."'", $encoded);
  1204.  
  1205.         // Maximum line length of 76 characters before CRLF (74 + space + '=')
  1206.         $encoded = $this->WrapText($encoded, 74, true);
  1207.  
  1208.         return $encoded;
  1209.     }
  1210.  
  1211.     /**
  1212.      * Encode string to q encoding.
  1213.      * @access private
  1214.      * @return string
  1215.      */
  1216.     function EncodeQ ($str, $position = "text") {
  1217.         // There should not be any EOL in the string
  1218.         $encoded = preg_replace("[\r\n]", "", $str);
  1219.  
  1220.         switch (strtolower($position)) {
  1221.           case "phrase":
  1222.             $encoded = preg_replace("/([^A-Za-z0-9!*+\/ -])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1223.             break;
  1224.           case "comment":
  1225.             $encoded = preg_replace("/([\(\)\"])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1226.           case "text":
  1227.           default:
  1228.             // Replace every high ascii, control =, ? and _ characters
  1229.             $encoded = preg_replace('/([\000-\011\013\014\016-\037\075\077\137\177-\377])/e',
  1230.                   "'='.sprintf('%02X', ord('\\1'))", $encoded);
  1231.             break;
  1232.         }
  1233.  
  1234.         // Replace every spaces to _ (more readable than =20)
  1235.         $encoded = str_replace(" ", "_", $encoded);
  1236.  
  1237.         return $encoded;
  1238.     }
  1239.  
  1240.     /**
  1241.      * Adds a string or binary attachment (non-filesystem) to the list.
  1242.      * This method can be used to attach ascii or binary data,
  1243.      * such as a BLOB record from a database.
  1244.      * @param string $string String attachment data.
  1245.      * @param string $filename Name of the attachment.
  1246.      * @param string $encoding File encoding (see $Encoding).
  1247.      * @param string $type File extension (MIME) type.
  1248.      * @return void
  1249.      */
  1250.     function AddStringAttachment($string, $filename, $encoding = "base64",
  1251.                                  $type = "application/octet-stream") {
  1252.         // Append to $attachment array
  1253.         $cur = count($this->attachment);
  1254.         $this->attachment[$cur][0] = $string;
  1255.         $this->attachment[$cur][1] = $filename;
  1256.         $this->attachment[$cur][2] = $filename;
  1257.         $this->attachment[$cur][3] = $encoding;
  1258.         $this->attachment[$cur][4] = $type;
  1259.         $this->attachment[$cur][5] = true; // isString
  1260.         $this->attachment[$cur][6] = "attachment";
  1261.         $this->attachment[$cur][7] = 0;
  1262.     }
  1263.  
  1264.     /**
  1265.      * Adds an embedded attachment.  This can include images, sounds, and
  1266.      * just about any other document.  Make sure to set the $type to an
  1267.      * image type.  For JPEG images use "image/jpeg" and for GIF images
  1268.      * use "image/gif".
  1269.      * @param string $path Path to the attachment.
  1270.      * @param string $cid Content ID of the attachment.  Use this to identify
  1271.      *        the Id for accessing the image in an HTML form.
  1272.      * @param string $name Overrides the attachment name.
  1273.      * @param string $encoding File encoding (see $Encoding).
  1274.      * @param string $type File extension (MIME) type.
  1275.      * @return bool
  1276.      */
  1277.     function AddEmbeddedImage($path, $cid, $name = "", $encoding = "base64",
  1278.                               $type = "application/octet-stream") {
  1279.  
  1280.         if(!@is_file($path))
  1281.         {
  1282.             $this->SetError($this->Lang("file_access") . $path);
  1283.             return false;
  1284.         }
  1285.  
  1286.         $filename = basename($path);
  1287.         if($name == "")
  1288.             $name = $filename;
  1289.  
  1290.         // Append to $attachment array
  1291.         $cur = count($this->attachment);
  1292.         $this->attachment[$cur][0] = $path;
  1293.         $this->attachment[$cur][1] = $filename;
  1294.         $this->attachment[$cur][2] = $name;
  1295.         $this->attachment[$cur][3] = $encoding;
  1296.         $this->attachment[$cur][4] = $type;
  1297.         $this->attachment[$cur][5] = false; // isStringAttachment
  1298.         $this->attachment[$cur][6] = "inline";
  1299.         $this->attachment[$cur][7] = $cid;
  1300.  
  1301.         return true;
  1302.     }
  1303.  
  1304.     /**
  1305.      * Returns true if an inline attachment is present.
  1306.      * @access private
  1307.      * @return bool
  1308.      */
  1309.     function InlineImageExists() {
  1310.         $result = false;
  1311.         for($i = 0; $i < count($this->attachment); $i++)
  1312.         {
  1313.             if($this->attachment[$i][6] == "inline")
  1314.             {
  1315.                 $result = true;
  1316.                 break;
  1317.             }
  1318.         }
  1319.  
  1320.         return $result;
  1321.     }
  1322.  
  1323.     /////////////////////////////////////////////////
  1324.     // MESSAGE RESET METHODS
  1325.     /////////////////////////////////////////////////
  1326.  
  1327.     /**
  1328.      * Clears all recipients assigned in the TO array.  Returns void.
  1329.      * @return void
  1330.      */
  1331.     function ClearAddresses() {
  1332.         $this->to = array();
  1333.     }
  1334.  
  1335.     /**
  1336.      * Clears all recipients assigned in the CC array.  Returns void.
  1337.      * @return void
  1338.      */
  1339.     function ClearCCs() {
  1340.         $this->cc = array();
  1341.     }
  1342.  
  1343.     /**
  1344.      * Clears all recipients assigned in the BCC array.  Returns void.
  1345.      * @return void
  1346.      */
  1347.     function ClearBCCs() {
  1348.         $this->bcc = array();
  1349.     }
  1350.  
  1351.     /**
  1352.      * Clears all recipients assigned in the ReplyTo array.  Returns void.
  1353.      * @return void
  1354.      */
  1355.     function ClearReplyTos() {
  1356.         $this->ReplyTo = array();
  1357.     }
  1358.  
  1359.     /**
  1360.      * Clears all recipients assigned in the TO, CC and BCC
  1361.      * array.  Returns void.
  1362.      * @return void
  1363.      */
  1364.     function ClearAllRecipients() {
  1365.         $this->to = array();
  1366.         $this->cc = array();
  1367.         $this->bcc = array();
  1368.     }
  1369.  
  1370.     /**
  1371.      * Clears all previously set filesystem, string, and binary
  1372.      * attachments.  Returns void.
  1373.      * @return void
  1374.      */
  1375.     function ClearAttachments() {
  1376.         $this->attachment = array();
  1377.     }
  1378.  
  1379.     /**
  1380.      * Clears all custom headers.  Returns void.
  1381.      * @return void
  1382.      */
  1383.     function ClearCustomHeaders() {
  1384.         $this->CustomHeader = array();
  1385.     }
  1386.  
  1387.  
  1388.     /////////////////////////////////////////////////
  1389.     // MISCELLANEOUS METHODS
  1390.     /////////////////////////////////////////////////
  1391.  
  1392.     /**
  1393.      * Adds the error message to the error container.
  1394.      * Returns void.
  1395.      * @access private
  1396.      * @return void
  1397.      */
  1398.     function SetError($msg) {
  1399.         $this->error_count++;
  1400.         $this->ErrorInfo = $msg;
  1401.     }
  1402.  
  1403.     /**
  1404.      * Returns the proper RFC 822 formatted date.
  1405.      * @access private
  1406.      * @return string
  1407.      */
  1408.     function RFCDate() {
  1409.         $tz = date("Z");
  1410.         $tzs = ($tz < 0) ? "-" : "+";
  1411.         $tz = abs($tz);
  1412.         $tz = ($tz/3600)*100 + ($tz%3600)/60;
  1413.         $result = sprintf("%s %s%04d", date("D, j M Y H:i:s"), $tzs, $tz);
  1414.  
  1415.         return $result;
  1416.     }
  1417.  
  1418.     /**
  1419.      * Returns the appropriate server variable.  Should work with both
  1420.      * PHP 4.1.0+ as well as older versions.  Returns an empty string
  1421.      * if nothing is found.
  1422.      * @access private
  1423.      * @return mixed
  1424.      */
  1425.     function ServerVar($varName) {
  1426.         global $HTTP_SERVER_VARS;
  1427.         global $HTTP_ENV_VARS;
  1428.  
  1429.         if(!isset($_SERVER))
  1430.         {
  1431.             $_SERVER = $HTTP_SERVER_VARS;
  1432.             if(!isset($_SERVER["REMOTE_ADDR"]))
  1433.                 $_SERVER = $HTTP_ENV_VARS; // must be Apache
  1434.         }
  1435.  
  1436.         if(isset($_SERVER[$varName]))
  1437.             return $_SERVER[$varName];
  1438.         else
  1439.             return "";
  1440.     }
  1441.  
  1442.     /**
  1443.      * Returns the server hostname or 'localhost.localdomain' if unknown.
  1444.      * @access private
  1445.      * @return string
  1446.      */
  1447.     function ServerHostname() {
  1448.         if ($this->Hostname != "")
  1449.             $result = $this->Hostname;
  1450.         elseif ($this->ServerVar('SERVER_NAME') != "")
  1451.             $result = $this->ServerVar('SERVER_NAME');
  1452.         else
  1453.             $result = "localhost.localdomain";
  1454.  
  1455.         return $result;
  1456.     }
  1457.  
  1458.     /**
  1459.      * Returns a message in the appropriate language.
  1460.      * @access private
  1461.      * @return string
  1462.      */
  1463.     function Lang($key) {
  1464.         if(count($this->language) < 1)
  1465.             $this->SetLanguage("en"); // set the default language
  1466.  
  1467.         if(isset($this->language[$key]))
  1468.             return $this->language[$key];
  1469.         else
  1470.             return "Language string failed to load: " . $key;
  1471.     }
  1472.  
  1473.     /**
  1474.      * Returns true if an error occurred.
  1475.      * @return bool
  1476.      */
  1477.     function IsError() {
  1478.         return ($this->error_count > 0);
  1479.     }
  1480.  
  1481.     /**
  1482.      * Changes every end of line from CR or LF to CRLF.
  1483.      * @access private
  1484.      * @return string
  1485.      */
  1486.     function FixEOL($str) {
  1487.         $str = str_replace("\r\n", "\n", $str);
  1488.         $str = str_replace("\r", "\n", $str);
  1489.         $str = str_replace("\n", $this->LE, $str);
  1490.         return $str;
  1491.     }
  1492.  
  1493.     /**
  1494.      * Adds a custom header.
  1495.      * @return void
  1496.      */
  1497.     function AddCustomHeader($custom_header) {
  1498.         $this->CustomHeader[] = explode(":", $custom_header, 2);
  1499.     }
  1500. }
  1501.  
  1502. ?>
Webkat - Script
 kostenlos
 zuverlässig
 vielseitig
 anpassbar
 ohne Datenb.
 SEO freundlich
 Html Mail
 Template

Webkatalog Skript
Das Programm dient zur Online-Verwaltung von Linkpartner auf Ihrer Homepage.
Das Skript es ist klein, leicht zu installieren und benötigt keine Datenbank !

Linkpartner können einfach online verwaltet werden.
Ein editieren der Linkpartner kann bequem über den Adminbereich durchgeführt werden ( edit.php ).
Aussehen und Beschreibungen der Linkeinträge können selber erstellt werden. ( Etwas Html Kenntnisse sollten vorhanden sein. ) Die Einrichtung neuer Linkpartner ist NUR in einer Datei notwendig ! ( linki.php )

Bei Linknachfragen erhalten Linkpartner als auch der Admin eine Anfrage Mail.

This site is HTML 4.01 compatible.
 
hoch