smtps.class.php

Go to the documentation of this file.

<?php
/*
 * Copyright (C)           Walter Torres        <walter@torres.ws> [with a *lot* of help!]
 * Copyright (C) 2005-2015 Laurent Destailleur  <eldy@users.sourceforge.net>
 * Copyright (C) 2006-2011 Regis Houssin
 * Copyright (C) 2016      Jonathan TISSEAU     <jonathan.tisseau@86dev.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
class SMTPs
{
  private $_smtpsHost = 'localhost';
 
  private $_smtpsPort = '25';
 
  private $_smtpsID = null;
 
  private $_smtpsPW = null;
 
  private $_smtpsToken = null;
 
  private $_msgFrom = null;
 
  private $_msgReplyTo = null;
 
  private $_msgRecipients = null;
 
  private $_msgSubject = null;
 
  private $_msgContent = array();
 
  private $_msgXheader = null;
 
  private $_smtpsCharSet = 'iso-8859-1';
 
  private $_msgSensitivity = 0;
 
  private $_arySensitivity = array(false,
                  'Personal',
                  'Private',
                  'Company Confidential');
 
  private $_msgPriority = 3;
 
  private $_aryPriority = array('Bulk',
                'Highest',
                'High',
                'Normal',
                'Low',
                'Lowest');
 
  private $_smtpsTransEncodeType = 0;
 
  private $_smtpsTransEncodeTypes = array('7bit', // Simple 7-bit ASCII
                     '8bit', // 8-bit coding with line termination characters
                     'base64', // 3 octets encoded into 4 sextets with offset
                     'binary', // Arbitrary binary stream
                     'mac-binhex40', // Macintosh binary to hex encoding
                     'quoted-printable', // Mostly 7-bit, with 8-bit characters encoded as "=HH"
                     'uuencode'); // UUENCODE encoding
 
  private $_smtpsTransEncode = '7bit';
 
  private $_smtpsBoundary = null;
 
  private $_smtpsRelatedBoundary = null;
 
  private $_smtpsAlternativeBoundary = null;
 
  private $_transportType = 0;
 
  private $_mailPath = '/usr/lib/sendmail';
 
  private $_smtpTimeout = 10;
 
  private $_smtpMD5 = false;
 
  private $_smtpsErrors = null;
 
  private $_log_level = 0;
 
  private $_debug = false;
 
 
  // @CHANGE LDR
  public $log = '';
  public $lastretval = '';
 
  public $socket;
 
  public $errno;
 
  public $errstr;
 
  private $_errorsTo = '';
  private $_deliveryReceipt = 0;
  private $_trackId = '';
  private $_moreinheader = '';
 
  private $_options = array();
 
  public function setOptions($_options = array())
  {
    $this->_options = $_options;
  }
 
  public function setDeliveryReceipt($_val = 0)
  {
    $this->_deliveryReceipt = $_val;
  }
 
  public function getDeliveryReceipt()
  {
    return $this->_deliveryReceipt;
  }
 
  public function setTrackId($_val = '')
  {
    $this->_trackId = $_val;
  }
 
  public function setMoreInHeader($_val = '')
  {
    $this->_moreinheader = $_val;
  }
 
  public function getTrackId()
  {
    return $this->_trackId;
  }
 
  public function getMoreInHeader()
  {
    return $this->_moreinheader;
  }
 
  public function setErrorsTo($_strErrorsTo)
  {
    if ($_strErrorsTo) {
      $this->_errorsTo = $this->_strip_email($_strErrorsTo);
    }
  }
 
  public function getErrorsTo($_part = true)
  {
    $_retValue = '';
 
    if ($_part === true) {
      $_retValue = $this->_errorsTo;
    } else {
      $_retValue = $this->_errorsTo[$_part];
    }
 
    return $_retValue;
  }
 
  public function setDebug($_vDebug = false)
  {
    $this->_debug = $_vDebug;
  }
 
  public function buildRCPTlist()
  {
    // Pull TO list
    $_aryToList = $this->getTO();
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  private function _server_connect()
  {
    // phpcs:enable
    // Default return value
    $_retVal = true;
 
    // We have to make sure the HOST given is valid
    // This is done here because '@fsockopen' will not give me this
    // information if it failes to connect because it can't find the HOST
    $host = $this->getHost();
    $usetls = preg_match('@tls://@i', $host);
 
    $host = preg_replace('@tcp://@i', '', $host); // Remove prefix
    $host = preg_replace('@ssl://@i', '', $host); // Remove prefix
    $host = preg_replace('@tls://@i', '', $host); // Remove prefix
 
    // @CHANGE LDR
    include_once DOL_DOCUMENT_ROOT.'/core/lib/functions2.lib.php';
 
    if ((!is_ip($host)) && ((gethostbyname($host)) == $host)) {
      $this->_setErr(99, $host.' is either offline or is an invalid host name.');
      $_retVal = false;
    } else {
      if (function_exists('stream_socket_client') && !empty($this->_options)) {
        $socket_context = stream_context_create($this->_options); // An array of options for stream_context_create()
        $this->socket = @stream_socket_client(
          preg_replace('@tls://@i', '', $this->getHost()).// Host to 'hit', IP or domain
          ':'.$this->getPort(), // which Port number to use
          $this->errno, // actual system level error
          $this->errstr, // and any text that goes with the error
          $this->_smtpTimeout, // timeout for reading/writing data over the socket
          STREAM_CLIENT_CONNECT,
          $socket_context                     // Options for connection
        );
      } else {
        $this->socket = @fsockopen(
          preg_replace('@tls://@i', '', $this->getHost()), // Host to 'hit', IP or domain
          $this->getPort(), // which Port number to use
          $this->errno, // actual system level error
          $this->errstr, // and any text that goes with the error
          $this->_smtpTimeout     // timeout for reading/writing data over the socket
        );
      }
 
      //See if we can connect to the SMTP server
      if (is_resource($this->socket)) {
        // Fix from PHP SMTP class by 'Chris Ryan'
        // Sometimes the SMTP server takes a little longer to respond
        // so we will give it a longer timeout for the first read
        // Windows still does not have support for this timeout function
        if (function_exists('stream_set_timeout')) {
          stream_set_timeout($this->socket, $this->_smtpTimeout, 0);
        }
 
        // Check response from Server
        if ($_retVal = $this->server_parse($this->socket, "220")) {
          $_retVal = $this->socket;
        }
      } else {
        // This connection attempt failed.
        // @CHANGE LDR
        if (empty($this->errstr)) {
          $this->errstr = 'Failed to connect with fsockopen host='.$this->getHost().' port='.$this->getPort();
        }
        $this->_setErr($this->errno, $this->errstr);
        $_retVal = false;
      }
    }
 
    return $_retVal;
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  private function _server_authenticate()
  {
    // phpcs:enable
    global $conf;
 
    require_once DOL_DOCUMENT_ROOT.'/core/lib/geturl.lib.php';
    // Send the RFC2554 specified EHLO.
    // This improvment as provided by 'SirSir' to
    // accomodate both SMTP AND ESMTP capable servers
    $host = $this->getHost();
    $usetls = preg_match('@tls://@i', $host);
 
    $host = preg_replace('@tcp://@i', '', $host); // Remove prefix
    $host = preg_replace('@ssl://@i', '', $host); // Remove prefix
    $host = preg_replace('@tls://@i', '', $host); // Remove prefix
 
    if ($usetls && getDolGlobalString('MAIN_SMTPS_ADD_TLS_TO_HOST_FOR_HELO')) {
      $host = 'tls://'.$host;
    }
 
    $hosth = $host; // so for example 'localhost' or 'smtp-relay.gmail.com'
 
    if (getDolGlobalString('MAIL_SMTP_USE_FROM_FOR_HELO')) {
      if (!is_numeric($conf->global->MAIL_SMTP_USE_FROM_FOR_HELO)) {
        // If value of MAIL_SMTP_USE_FROM_FOR_HELO is a string, we use it as domain name
        $hosth = $conf->global->MAIL_SMTP_USE_FROM_FOR_HELO;
      } elseif (getDolGlobalInt('MAIL_SMTP_USE_FROM_FOR_HELO') == 1) {
        // If value of MAIL_SMTP_USE_FROM_FOR_HELO is 1, we use the domain in the from.
        // So if the from to is 'aaa <bbb@ccc.com>', we will keep 'ccc.com'
        $hosth = $this->getFrom('addr');
        $hosth = preg_replace('/^.*</', '', $hosth);
        $hosth = preg_replace('/>.*$/', '', $hosth);
        $hosth = preg_replace('/.*@/', '', $hosth);
      } elseif (getDolGlobalInt('MAIL_SMTP_USE_FROM_FOR_HELO') == 2) {
        // If value of MAIL_SMTP_USE_FROM_FOR_HELO is 2, we use the domain in the $dolibarr_main_url_root.
        global $dolibarr_main_url_root;
        $hosth = getDomainFromURL($dolibarr_main_url_root, 1);
      }
    }
 
    if ($_retVal = $this->socket_send_str('EHLO '.$hosth, '250')) {
      if ($usetls) {
        /*
        The following dialog illustrates how a client and server can start a TLS STARTTLS session:
        S: <waits for connection on TCP port 25>
        C: <opens connection>
        S: 220 mail.imc.org SMTP service ready
        C: EHLO mail.ietf.org
        S: 250-mail.imc.org offers a warm hug of welcome
        S: 250 STARTTLS
        C: STARTTLS
        S: 220 Go ahead
        C: <starts TLS negotiation>
        C & S: <negotiate a TLS session>
        C & S: <check result of negotiation>
        // Second pass EHLO
        C: EHLO client-domain.com
        S: 250-server-domain.com
        S: 250 AUTH LOGIN
        C: <continues by sending an SMTP command
 
        Another example here:
        S: 220 smtp.server.com Simple Mail Transfer Service Ready
        C: EHLO client.example.com
        S: 250-smtp.server.com Hello client.example.com
        S: 250-SIZE 1000000
        S: 250-AUTH LOGIN PLAIN CRAM-MD5
        S: 250-STARTTLS
        S: 250 HELP
        C: STARTTLS
        S: 220 TLS go ahead
        C: EHLO client.example.com *
        S: 250-smtp.server.com Hello client.example.com
        S: 250-SIZE 1000000
        S: 250-AUTH LOGIN PLAIN CRAM-MD5
        S: 250 HELP
        C: AUTH LOGIN
        S: 334 VXNlcm5hbWU6
        C: adlxdkej
        S: 334 UGFzc3dvcmQ6
        C: lkujsefxlj
        S: 235 2.7.0 Authentication successful
        C: MAIL FROM:<mail@samlogic.com>
        S: 250 OK
        C: RCPT TO:<john@mail.com>
        S: 250 OK
        C: DATA
        S: 354 Send message, end with a "." on a line by itself
        C: <The message data (body text, subject, e-mail header, attachments etc) is sent>
        S .
        S: 250 OK, message accepted for delivery: queued as 12345
        C: QUIT
        S: 221 Bye
        */
        if (!$_retVal = $this->socket_send_str('STARTTLS', 220)) {
          $this->_setErr(131, 'STARTTLS connection is not supported.');
          return $_retVal;
        }
 
        // Before 5.6.7:
        // STREAM_CRYPTO_METHOD_SSLv23_CLIENT = STREAM_CRYPTO_METHOD_SSLv2_CLIENT|STREAM_CRYPTO_METHOD_SSLv3_CLIENT
        // STREAM_CRYPTO_METHOD_TLS_CLIENT = STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT|STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT|STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT
        // PHP >= 5.6.7:
        // STREAM_CRYPTO_METHOD_SSLv23_CLIENT = STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT|STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT|STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT
        // STREAM_CRYPTO_METHOD_TLS_CLIENT = STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT
 
        $crypto_method = STREAM_CRYPTO_METHOD_TLS_CLIENT;
        if (defined('STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT')) {
          $crypto_method |= STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT;
          $crypto_method |= STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT;
        }
 
        if (!stream_socket_enable_crypto($this->socket, true, $crypto_method)) {
          $this->_setErr(132, 'STARTTLS connection failed.');
          return $_retVal;
        }
        // Most servers expect a 2nd pass of EHLO after TLS is established to get another time
        // the answer with list of supported AUTH methods. They may differs between non STARTTLS and with STARTTLS.
        if (! $_retVal = $this->socket_send_str('EHLO '.$hosth, '250')) {
          $this->_setErr(126, '"'.$hosth.'" does not support authenticated connections or temporary error. Error after 2nd sending EHLO '.$hosth.' : '.$this->lastretval);
          return $_retVal;
        }
      }
 
      // Default authentication method is LOGIN
      if (!getDolGlobalString('MAIN_MAIL_SMTPS_AUTH_TYPE')) {
        $conf->global->MAIN_MAIL_SMTPS_AUTH_TYPE = 'LOGIN';
      }
 
      // Send Authentication to Server
      // Check for errors along the way
      switch ($conf->global->MAIN_MAIL_SMTPS_AUTH_TYPE) {
        case 'NONE':
          // Do not send the 'AUTH type' message. For test purpose, if you don't need authentication, it is better to not enter login/pass into setup.
          $_retVal = true;
          break;
        case 'PLAIN':
          $this->socket_send_str('AUTH PLAIN', '334');
          // The error here just means the ID/password combo doesn't work.
          $_retVal = $this->socket_send_str(base64_encode("\0".$this->_smtpsID."\0".$this->_smtpsPW), '235');
          break;
        case 'XOAUTH2':
          // "user=$email\1auth=Bearer $token\1\1"
          $user = $this->_smtpsID;
          $token = $this->_smtpsToken;
          $initRes = "user=".$user."\001auth=Bearer ".$token."\001\001";
          $_retVal = $this->socket_send_str('AUTH XOAUTH2 '.base64_encode($initRes), '235');
          if (!$_retVal) {
            $this->_setErr(130, 'Error when asking for AUTH XOAUTH2');
          }
          break;
        case 'LOGIN': // most common case
        default:
          $_retVal = $this->socket_send_str('AUTH LOGIN', '334');
          if (!$_retVal) {
            $this->_setErr(130, 'Error when asking for AUTH LOGIN');
          } else {
            // User name will not return any error, server will take anything we give it.
            $this->socket_send_str(base64_encode($this->_smtpsID), '334');
            // The error here just means the ID/password combo doesn't work.
            // There is no method to determine which is the problem, ID or password
            $_retVal = $this->socket_send_str(base64_encode($this->_smtpsPW), '235');
          }
          break;
      }
      if (!$_retVal) {
        $this->_setErr(130, 'Invalid Authentication Credentials.');
      }
    } else {
      $this->_setErr(126, '"'.$host.'" does not support authenticated connections or temporary error. Error after sending EHLO '.$hosth.' : '.$this->lastretval);
    }
 
    return $_retVal;
  }
 
  public function sendMsg()
  {
    global $conf;
 
    require_once DOL_DOCUMENT_ROOT.'/core/lib/geturl.lib.php';
 
    // Default return value
    $_retVal = false;
 
    // Connect to Server
    if ($this->socket = $this->_server_connect()) {
      // If a User ID *and* a password is given, assume Authentication is desired
      if (!empty($this->_smtpsID) && (!empty($this->_smtpsPW) || !empty($this->_smtpsToken))) {
        // Send the RFC2554 specified EHLO.
        $_retVal = $this->_server_authenticate();
      } else {
        // This is a "normal" SMTP Server "handshack"
        // Send the RFC821 specified HELO.
        $host = $this->getHost();
        $usetls = preg_match('@tls://@i', $host);
 
        $host = preg_replace('@tcp://@i', '', $host); // Remove prefix
        $host = preg_replace('@ssl://@i', '', $host); // Remove prefix
        $host = preg_replace('@tls://@i', '', $host); // Remove prefix
 
        if ($usetls && getDolGlobalString('MAIN_SMTPS_ADD_TLS_TO_HOST_FOR_HELO')) {
          $host = 'tls://'.$host;
        }
 
        $hosth = $host;
 
        if (getDolGlobalString('MAIL_SMTP_USE_FROM_FOR_HELO')) {
          if (!is_numeric($conf->global->MAIL_SMTP_USE_FROM_FOR_HELO)) {
            // If value of MAIL_SMTP_USE_FROM_FOR_HELO is a string, we use it as domain name
            $hosth = $conf->global->MAIL_SMTP_USE_FROM_FOR_HELO;
          } elseif (getDolGlobalInt('MAIL_SMTP_USE_FROM_FOR_HELO') == 1) {
            // If value of MAIL_SMTP_USE_FROM_FOR_HELO is 1, we use the domain in the from.
            // So if the from to is 'aaa <bbb@ccc.com>', we will keep 'ccc.com'
            $hosth = $this->getFrom('addr');
            $hosth = preg_replace('/^.*</', '', $hosth);
            $hosth = preg_replace('/>.*$/', '', $hosth);
            $hosth = preg_replace('/.*@/', '', $hosth);
          } elseif (getDolGlobalInt('MAIL_SMTP_USE_FROM_FOR_HELO') == 2) {
            // If value of MAIL_SMTP_USE_FROM_FOR_HELO is 2, we use the domain in the $dolibarr_main_url_root.
            global $dolibarr_main_url_root;
            $hosth = getDomainFromURL($dolibarr_main_url_root, 1);
          }
        }
 
        // Send the HELO message to the SMTP server
        $_retVal = $this->socket_send_str('HELO '.$hosth, '250');
      }
 
      // Well, did we get the server answer with correct code ?
      if ($_retVal) {
        // From this point onward most server response codes should be 250
        // Specify who the mail is from....
        // This has to be the raw email address, strip the "name" off
        $resultmailfrom = $this->socket_send_str('MAIL FROM: '.$this->getFrom('addr'), '250');
        if (!$resultmailfrom) {
          fclose($this->socket);
          return false;
        }
 
        // 'RCPT TO:' must be given a single address, so this has to loop
        // through the list of addresses, regardless of TO, CC or BCC
        // and send it out "single file"
        foreach ($this->get_RCPT_list() as $_address) {
          /* Note:
           * BCC email addresses must be listed in the RCPT TO command list,
           * but the BCC header should not be printed under the DATA command.
           * http://stackoverflow.com/questions/2750211/sending-bcc-emails-using-a-smtp-server
           */
 
          /*
           * TODO
           * After each 'RCPT TO:' is sent, we need to make sure it was kosher,
           * if not, the whole message will fail
           * If any email address fails, we will need to RESET the connection,
           * mark the last address as "bad" and start the address loop over again.
           * If any address fails, the entire message fails.
           */
          $this->socket_send_str('RCPT TO: <'.$_address.'>', '250');
        }
 
        // Tell the server we are ready to start sending data
        // with any custom headers...
        // This is the last response code we look for until the end of the message.
        $this->socket_send_str('DATA', '354');
 
        // Now we are ready for the message...
        // Ok, all the ingredients are mixed in let's cook this puppy...
        $this->socket_send_str($this->getHeader().$this->getBodyContent()."\r\n".'.', '250');
 
        // Now tell the server we are done and close the socket...
        fputs($this->socket, 'QUIT');
      } else {
        // We got error code into $this->lastretval
      }
 
      fclose($this->socket);
    }
 
    return $_retVal;
  }
 
  // =============================================================
  // ** Setter & Getter methods
 
  // ** Basic System configuration
 
  public function setConfig($_strConfigPath = null)
  {
    $_retVal = true;
 
    // if we have a path...
    if (!empty($_strConfigPath)) {
      // If the path is not valid, this will NOT generate an error,
      // it will simply return false.
      if (!@include $_strConfigPath) {
        $this->_setErr(110, '"'.$_strConfigPath.'" is not a valid path.');
        $_retVal = false;
      }
    } else {
      // Read the Systems php.ini file
      // Set these properties ONLY if they are set in the php.ini file.
      // Otherwise the default values will be used.
      if ($_host = ini_get('SMTPs')) {
        $this->setHost($_host);
      }
 
      if ($_port = ini_get('smtp_port')) {
        $this->setPort($_port);
      }
 
      if ($_from = ini_get('sendmail_from')) {
        $this->setFrom($_from);
      }
    }
 
    // Send back what we have
    return $_retVal;
  }
 
  public function setTransportType($_type = 0)
  {
    if ((is_numeric($_type)) && (($_type >= 0) && ($_type <= 3))) {
      $this->_transportType = $_type;
    }
  }
 
  public function getTransportType()
  {
    return $this->_transportType;
  }
 
  public function setMailPath($_path)
  {
    // This feature is not yet implemented
    return true;
 
    //if ( $_path ) $this->_mailPath = $_path;
  }
 
  public function setHost($_strHost)
  {
    if ($_strHost) {
      $this->_smtpsHost = $_strHost;
    }
  }
 
  public function getHost()
  {
    return $this->_smtpsHost;
  }
 
  public function setPort($_intPort)
  {
    if ((is_numeric($_intPort)) &&
    (($_intPort >= 1) && ($_intPort <= 65536))) {
      $this->_smtpsPort = $_intPort;
    }
  }
 
  public function getPort()
  {
    return $this->_smtpsPort;
  }
 
  public function setID($_strID)
  {
    $this->_smtpsID = $_strID;
  }
 
  public function getID()
  {
    return $this->_smtpsID;
  }
 
  public function setPW($_strPW)
  {
    $this->_smtpsPW = $_strPW;
  }
 
  public function getPW()
  {
    return $this->_smtpsPW;
  }
 
  public function setToken($_strToken)
  {
    $this->_smtpsToken = $_strToken;
  }
 
  public function getToken()
  {
    return $this->_smtpsToken;
  }
 
  public function setCharSet($_strCharSet)
  {
    if ($_strCharSet) {
      $this->_smtpsCharSet = $_strCharSet;
    }
  }
 
  public function getCharSet()
  {
    return $this->_smtpsCharSet;
  }
 
  public function setTransEncode($_strTransEncode)
  {
    if (array_search($_strTransEncode, $this->_smtpsTransEncodeTypes)) {
      $this->_smtpsTransEncode = $_strTransEncode;
    }
  }
 
  public function getTransEncode()
  {
    return $this->_smtpsTransEncode;
  }
 
  public function setTransEncodeType($_strTransEncodeType)
  {
    if (array_search($_strTransEncodeType, $this->_smtpsTransEncodeTypes)) {
      $this->_smtpsTransEncodeType = $_strTransEncodeType;
    }
  }
 
  public function getTransEncodeType()
  {
    return $this->_smtpsTransEncodeTypes[$this->_smtpsTransEncodeType];
  }
 
 
  // ** Message Construction
 
  public function setFrom($_strFrom)
  {
    if ($_strFrom) {
      $this->_msgFrom = $this->_strip_email($_strFrom);
    }
  }
 
  public function getFrom($_part = true)
  {
    $_retValue = '';
 
    if ($_part === true) {
      $_retValue = $this->_msgFrom;
    } else {
      $_retValue = $this->_msgFrom[$_part];
    }
 
    return $_retValue;
  }
 
  public function setReplyTo($_strReplyTo)
  {
    if ($_strReplyTo) {
      $this->_msgReplyTo = $this->_strip_email($_strReplyTo);
    }
  }
 
  public function getReplyTo($_part = true)
  {
    $_retValue = '';
 
    if ($_part === true) {
      $_retValue = $this->_msgReplyTo;
    } else {
      $_retValue = $this->_msgReplyTo[$_part];
    }
 
    return $_retValue;
  }
 
  private function _buildAddrList($_type, $_addrList)
  {
    // Pull existing list
    $aryHost = $this->_msgRecipients;
 
    // Only run this if we have something
    if (!empty($_addrList)) {
      // $_addrList can be a STRING or an array
      if (is_string($_addrList)) {
        // This could be a COMMA delimited string
        if (strstr($_addrList, ',')) {
          // "explode "list" into an array
          $_addrList = explode(',', $_addrList);
        } else {
          // Stick it in an array
          $_addrList = array($_addrList);
        }
      }
 
      // take the array of addresses and split them further
      foreach ($_addrList as $_strAddr) {
        // Strip off the end '>'
        $_strAddr = str_replace('>', '', $_strAddr);
 
        // Seperate "Real Name" from eMail address
        $_tmpaddr = null;
        $_tmpaddr = explode('<', $_strAddr);
 
        // We have a "Real Name" and eMail address
        if (count($_tmpaddr) == 2) {
          $_tmpHost = explode('@', $_tmpaddr[1]);
          $_tmpaddr[0] = trim($_tmpaddr[0], ' ">');
          $aryHost[$_tmpHost[1]][$_type][$_tmpHost[0]] = $_tmpaddr[0];
        } else {
          // We only have an eMail address
          // Strip off the beggining '<'
          $_strAddr = str_replace('<', '', $_strAddr);
 
          $_tmpHost = explode('@', $_strAddr);
          $_tmpHost[0] = trim($_tmpHost[0]);
          $_tmpHost[1] = trim($_tmpHost[1]);
 
          $aryHost[$_tmpHost[1]][$_type][$_tmpHost[0]] = '';
        }
      }
    }
    // replace list
    $this->_msgRecipients = $aryHost;
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  private function _strip_email($_strAddr)
  {
    // phpcs:enable
    // Keep the orginal
    $_aryEmail['org'] = $_strAddr;
 
    // Set entire string to Lower Case
    $_strAddr = strtolower($_strAddr);
 
    // Drop "stuff' off the end
    $_strAddr = trim($_strAddr, ' ">');
 
    // Seperate "Real Name" from eMail address, if we have one
    $_tmpAry = explode('<', $_strAddr);
 
    // Do we have a "Real name"
    if (count($_tmpAry) == 2) {
      // We may not really have a "Real Name"
      if ($_tmpAry[0]) {
        $_aryEmail['real'] = trim($_tmpAry[0], ' ">');
      }
 
      $_aryEmail['addr'] = $_tmpAry[1];
    } else {
      $_aryEmail['addr'] = $_tmpAry[0];
    }
 
    // Pull User Name and Host.tld apart
    $_tmpHost = explode('@', $_aryEmail['addr']);
    $_aryEmail['user'] = $_tmpHost[0];
    $_aryEmail['host'] = $_tmpHost[1];
 
    // Put the brackets back around the address
    $_aryEmail['addr'] = '<'.$_aryEmail['addr'].'>';
 
    return $_aryEmail;
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function get_RCPT_list()
  {
    // phpcs:enable
    $_RCPT_list = array();
 
    // walk down Recipients array and pull just email addresses
    foreach ($this->_msgRecipients as $_host => $_list) {
      foreach ($_list as $_subList) {
        foreach ($_subList as $_name => $_addr) {
          // build RCPT list
          $_RCPT_list[] = $_name.'@'.$_host;
        }
      }
    }
 
    return $_RCPT_list;
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function get_email_list($_which = null)
  {
    // phpcs:enable
    // We need to know which address segment to pull
    if ($_which) {
      // Make sure we have addresses to process
      if ($this->_msgRecipients) {
        $_RCPT_list = array();
        // walk down Recipients array and pull just email addresses
        foreach ($this->_msgRecipients as $_host => $_list) {
          if (!empty($this->_msgRecipients[$_host][$_which])) {
            foreach ($this->_msgRecipients[$_host][$_which] as $_addr => $_realName) {
              if ($_realName) { // @CHANGE LDR
                $_realName = '"'.$_realName.'"';
                $_RCPT_list[] = $_realName.' <'.$_addr.'@'.$_host.'>';
              } else {
                $_RCPT_list[] = $_addr.'@'.$_host;
              }
            }
          }
        }
 
        return implode(', ', $_RCPT_list);
      } else {
        $this->_setErr(101, 'No eMail Address for message to be sent to.');
        return false;
      }
    } else {
      $this->_setErr(102, 'eMail type not defined.');
      return false;
    }
  }
 
  public function setTO($_addrTo)
  {
    if ($_addrTo) {
      $this->_buildAddrList('to', $_addrTo);
    }
  }
 
  public function getTo()
  {
    return $this->get_email_list('to');
  }
 
  public function setCC($_strCC)
  {
    if ($_strCC) {
      $this->_buildAddrList('cc', $_strCC);
    }
  }
 
  public function getCC()
  {
    return $this->get_email_list('cc');
  }
 
  public function setBCC($_strBCC)
  {
    if ($_strBCC) {
      $this->_buildAddrList('bcc', $_strBCC);
    }
  }
 
  public function getBCC()
  {
    return $this->get_email_list('bcc');
  }
 
  public function setSubject($_strSubject = '')
  {
    if ($_strSubject) {
      $this->_msgSubject = $_strSubject;
    }
  }
 
  public function getSubject()
  {
    return $this->_msgSubject;
  }
 
  public function getHeader()
  {
    global $conf;
 
    $_header = 'From: '.$this->getFrom('org')."\r\n"
    . 'To: '.$this->getTO()."\r\n";
 
    if ($this->getCC()) {
      $_header .= 'Cc: '.$this->getCC()."\r\n";
    }
 
    /* Note:
     * BCC email addresses must be listed in the RCPT TO command list,
     * but the BCC header should not be printed under the DATA command.
     * So it is included into the function sendMsg() but not here.
     * http://stackoverflow.com/questions/2750211/sending-bcc-emails-using-a-smtp-server
     */
    /*
    if ( $this->getBCC() )
    $_header .= 'Bcc: ' . $this->getBCC()  . "\r\n";
    */
 
    $host = dol_getprefix('email');
 
    //NOTE: Message-ID should probably contain the username of the user who sent the msg
    $_header .= 'Subject: '.$this->getSubject()."\r\n";
    $_header .= 'Date: '.date("r")."\r\n";
 
    $trackid = $this->getTrackId();
    if ($trackid) {
      $_header .= 'Message-ID: <'.time().'.SMTPs-dolibarr-'.$trackid.'@'.$host.">\r\n";
      $_header .= 'X-Dolibarr-TRACKID: '.$trackid.'@'.$host."\r\n";
      // References and In-Reply-To: will be set by caller
      //$_header .= 'References: <'.time().'.SMTPs-dolibarr-'.$trackid.'@'.$host.">\r\n";
    } else {
      $_header .= 'Message-ID: <'.time().'.SMTPs@'.$host.">\r\n";
    }
    if (!empty($_SERVER['REMOTE_ADDR'])) {
      $_header .= "X-RemoteAddr: ".$_SERVER['REMOTE_ADDR']."\r\n";
    }
    if ($this->getMoreInHeader()) {
      $_header .= $this->getMoreInHeader(); // Value must include the "\r\n";
    }
 
    if ($this->getSensitivity()) {
      $_header .= 'Sensitivity: '.$this->getSensitivity()."\r\n";
    }
 
    if ($this->_msgPriority != 3) {
      $_header .= $this->getPriority();
    }
 
 
    // @CHANGE LDR
    if ($this->getDeliveryReceipt()) {
      $_header .= 'Disposition-Notification-To: '.$this->getFrom('addr')."\r\n";
    }
    if ($this->getErrorsTo()) {
      $_header .= 'Errors-To: '.$this->getErrorsTo('addr')."\r\n";
    }
    if ($this->getReplyTo()) {
      $_header .= "Reply-To: ".$this->getReplyTo('addr')."\r\n";
    }
 
    $_header .= 'X-Mailer: Dolibarr version '.DOL_VERSION.' (using SMTPs Mailer)'."\r\n";
    $_header .= 'X-Dolibarr-Option: '.($conf->global->MAIN_MAIL_USE_MULTI_PART ? 'MAIN_MAIL_USE_MULTI_PART' : 'No MAIN_MAIL_USE_MULTI_PART')."\r\n";
    $_header .= 'Mime-Version: 1.0'."\r\n";
 
    // TODO Add also $this->references and In-Reply-To
 
    return $_header;
  }
 
  public function setBodyContent($strContent, $strType = 'plain')
  {
    //if ( $strContent )
    //{
    if ($strType == 'html') {
      $strMimeType = 'text/html';
    } else {
      $strMimeType = 'text/plain';
    }
 
    // Make RFC821 Compliant, replace bare linefeeds
    $strContent = preg_replace("/(?<!\r)\n/si", "\r\n", $strContent);
 
    $strContentAltText = '';
    if ($strType == 'html') {
      // Similar code to forge a text from html is also in CMailFile.class.php
      $strContentAltText = preg_replace('/<head><title>.*<\/style><\/head>/', '', $strContent);
      $strContentAltText = preg_replace("/<br\s*[^>]*>/", " ", $strContentAltText);
      $strContentAltText = html_entity_decode(strip_tags($strContentAltText));
      $strContentAltText = trim(wordwrap($strContentAltText, 75, "\r\n"));
    }
 
    // Make RFC2045 Compliant
    //$strContent = rtrim(chunk_split($strContent));    // Function chunck_split seems ko if not used on a base64 content
    $strContent = rtrim(wordwrap($strContent, 75, "\r\n")); // TODO Using this method creates unexpected line break on text/plain content.
 
    $this->_msgContent[$strType] = array();
 
    $this->_msgContent[$strType]['mimeType'] = $strMimeType;
    $this->_msgContent[$strType]['data']     = $strContent;
    $this->_msgContent[$strType]['dataText'] = $strContentAltText;
 
    if ($this->getMD5flag()) {
      $this->_msgContent[$strType]['md5'] = dol_hash($strContent, 3);
    }
    //}
  }
 
  public function getBodyContent()
  {
    global $conf;
 
    // Generate a new Boundary string
    $this->_setBoundary();
 
    // What type[s] of content do we have
    $_types = array_keys($this->_msgContent);
 
    // How many content types do we have
    $keyCount = count($_types);
 
    // If we have ZERO, we have a problem
    if ($keyCount === 0) {
      die("Sorry, no content");
    } elseif ($keyCount === 1 && !getDolGlobalString('MAIN_MAIL_USE_MULTI_PART')) {
      // If we have ONE, we can use the simple format
      $_msgData = $this->_msgContent;
      $_msgData = $_msgData[$_types[0]];
 
      $content = 'Content-Type: '.$_msgData['mimeType'].'; charset="'.$this->getCharSet().'"'."\r\n"
      . 'Content-Transfer-Encoding: '.$this->getTransEncodeType()."\r\n"
      . 'Content-Disposition: inline'."\r\n"
      . 'Content-Description: Message'."\r\n";
 
      if ($this->getMD5flag()) {
        $content .= 'Content-MD5: '.$_msgData['md5']."\r\n";
      }
 
      $content .= "\r\n"
      .  $_msgData['data']."\r\n";
    } elseif ($keyCount >= 1 || getDolGlobalString('MAIN_MAIL_USE_MULTI_PART')) {
      // If we have more than ONE, we use the multi-part format
      // Since this is an actual multi-part message
      // We need to define a content message Boundary
      // NOTE: This was 'multipart/alternative', but Windows based mail servers have issues with this.
 
      //$content = 'Content-Type: multipart/related; boundary="' . $this->_getBoundary() . '"'   . "\r\n";
      $content = 'Content-Type: multipart/mixed; boundary="'.$this->_getBoundary('mixed').'"'."\r\n";
 
      //                     . "\r\n"
      //                     . 'This is a multi-part message in MIME format.' . "\r\n";
      $content .= "Content-Transfer-Encoding: 8bit\r\n";
      $content .= "\r\n";
 
      $content .= "--".$this->_getBoundary('mixed')."\r\n";
 
      if (key_exists('image', $this->_msgContent)) {     // If inline image found
        $content .= 'Content-Type: multipart/alternative; boundary="'.$this->_getBoundary('alternative').'"'."\r\n";
        $content .= "\r\n";
        $content .= "--".$this->_getBoundary('alternative')."\r\n";
      }
 
 
      // $this->_msgContent must be sorted with key 'text' or 'html' first then 'image' then 'attachment'
 
 
      // Loop through message content array
      foreach ($this->_msgContent as $type => $_content) {
        if ($type == 'attachment') {
          // loop through all attachments
          foreach ($_content as $_file => $_data) {
            $content .= "--".$this->_getBoundary('mixed')."\r\n"
            . 'Content-Disposition: attachment; filename="'.$_data['fileName'].'"'."\r\n"
            . 'Content-Type: '.$_data['mimeType'].'; name="'.$_data['fileName'].'"'."\r\n"
            . 'Content-Transfer-Encoding: base64'."\r\n"
            . 'Content-Description: '.$_data['fileName']."\r\n";
            if (!empty($_data['cid'])) {
              $content .= "X-Attachment-Id: ".$_data['cid']."\r\n";
              $content .= "Content-ID: <".$_data['cid'].">\r\n";
            }
            if ($this->getMD5flag()) {
              $content .= 'Content-MD5: '.$_data['md5']."\r\n";
            }
 
            $content .= "\r\n".$_data['data']."\r\n\r\n";
          }
        } elseif ($type == 'image') {
          // @CHANGE LDR
          // loop through all images
          foreach ($_content as $_image => $_data) {
            $content .= "--".$this->_getBoundary('related')."\r\n"; // always related for an inline image
 
            $content .= 'Content-Type: '.$_data['mimeType'].'; name="'.$_data['imageName'].'"'."\r\n"
            . 'Content-Transfer-Encoding: base64'."\r\n"
            . 'Content-Disposition: inline; filename="'.$_data['imageName'].'"'."\r\n"
            . 'Content-ID: <'.$_data['cid'].'> '."\r\n";
 
            if ($this->getMD5flag()) {
              $content .= 'Content-MD5: '.$_data['md5']."\r\n";
            }
 
            $content .= "\r\n"
            . $_data['data']."\r\n";
          }
 
          // always end related and end alternative after inline images
          $content .= "--".$this->_getBoundary('related')."--\r\n";
          $content .= "\r\n--".$this->_getBoundary('alternative')."--\r\n";
          $content .= "\r\n";
        } else {
          if (key_exists('image', $this->_msgContent)) {
            $content .= "Content-Type: text/plain; charset=".$this->getCharSet()."\r\n";
            $content .= "\r\n".($_content['dataText'] ? $_content['dataText'] : strip_tags($_content['data']))."\r\n"; // Add plain text message
            $content .= "--".$this->_getBoundary('alternative')."\r\n";
            $content .= 'Content-Type: multipart/related; boundary="'.$this->_getBoundary('related').'"'."\r\n";
            $content .= "\r\n";
            $content .= "--".$this->_getBoundary('related')."\r\n";
          }
 
          if (!key_exists('image', $this->_msgContent) && $_content['dataText'] && getDolGlobalString('MAIN_MAIL_USE_MULTI_PART')) {
            // Add plain text message part before html part
            $content .= 'Content-Type: multipart/alternative; boundary="'.$this->_getBoundary('alternative').'"'."\r\n";
            $content .= "\r\n";
            $content .= "--".$this->_getBoundary('alternative')."\r\n";
 
            $content .= "Content-Type: text/plain; charset=".$this->getCharSet()."\r\n";
            $content .= "\r\n".$_content['dataText']."\r\n";
            $content .= "--".$this->_getBoundary('alternative')."\r\n";
          }
 
          $content .= 'Content-Type: '.$_content['mimeType'].'; charset='.$this->getCharSet();
 
          $content .= "\r\n";
 
          if ($this->getMD5flag()) {
            $content .= 'Content-MD5: '.$_content['md5']."\r\n";
          }
 
          $content .= "\r\n".$_content['data']."\r\n";
 
          if (!key_exists('image', $this->_msgContent) && $_content['dataText'] && getDolGlobalString('MAIN_MAIL_USE_MULTI_PART')) {
            // Add plain text message part after html part
            $content .= "--".$this->_getBoundary('alternative')."--\r\n";
          }
 
          $content .= "\r\n";
        }
      }
 
      $content .= "--".$this->_getBoundary('mixed').'--'."\r\n";
    }
 
    return $content;
  }
 
  public function setAttachment($strContent, $strFileName = 'unknown', $strMimeType = 'unknown', $strCid = '')
  {
    if ($strContent) {
      $strContent = rtrim(chunk_split(base64_encode($strContent), 76, "\r\n")); // 76 max is defined into http://tools.ietf.org/html/rfc2047
 
      $this->_msgContent['attachment'][$strFileName]['mimeType'] = $strMimeType;
      $this->_msgContent['attachment'][$strFileName]['fileName'] = $strFileName;
      $this->_msgContent['attachment'][$strFileName]['data']     = $strContent;
      $this->_msgContent['attachment'][$strFileName]['cid']      = $strCid;   // If defined, it means this attachment must be shown inline
 
      if ($this->getMD5flag()) {
        $this->_msgContent['attachment'][$strFileName]['md5'] = dol_hash($strContent, 3);
      }
    }
  }
 
 
  // @CHANGE LDR
 
  public function setImageInline($strContent, $strImageName = 'unknown', $strMimeType = 'unknown', $strImageCid = 'unknown')
  {
    if ($strContent) {
      $this->_msgContent['image'][$strImageName]['mimeType'] = $strMimeType;
      $this->_msgContent['image'][$strImageName]['imageName'] = $strImageName;
      $this->_msgContent['image'][$strImageName]['cid']      = $strImageCid;
      $this->_msgContent['image'][$strImageName]['data']     = $strContent;
 
      if ($this->getMD5flag()) {
        $this->_msgContent['image'][$strImageName]['md5'] = dol_hash($strContent, 3);
      }
    }
  }
  // END @CHANGE LDR
 
 
  public function setSensitivity($_value = 0)
  {
    if ((is_numeric($_value)) &&
    (($_value >= 0) && ($_value <= 3))) {
      $this->_msgSensitivity = $_value;
    }
  }
 
  public function getSensitivity()
  {
    return $this->_arySensitivity[$this->_msgSensitivity];
  }
 
  public function setPriority($_value = 3)
  {
    if ((is_numeric($_value)) &&
    (($_value >= 0) && ($_value <= 5))) {
      $this->_msgPriority = $_value;
    }
  }
 
  public function getPriority()
  {
    return 'Importance: '.$this->_aryPriority[$this->_msgPriority]."\r\n"
    . 'Priority: '.$this->_aryPriority[$this->_msgPriority]."\r\n"
    . 'X-Priority: '.$this->_msgPriority.' ('.$this->_aryPriority[$this->_msgPriority].')'."\r\n";
  }
 
  public function setMD5flag($_flag = false)
  {
    $this->_smtpMD5 = $_flag;
  }
 
  public function getMD5flag()
  {
    return $this->_smtpMD5;
  }
 
  public function setXheader($strXdata)
  {
    if ($strXdata) {
      $this->_msgXheader[] = $strXdata;
    }
  }
 
  public function getXheader()
  {
    return $this->_msgXheader;
  }
 
  private function _setBoundary()
  {
    $this->_smtpsBoundary = "multipart_x.".time().".x_boundary";
    $this->_smtpsRelatedBoundary = 'mul_'.dol_hash(uniqid("dolibarr2"), 3);
    $this->_smtpsAlternativeBoundary = 'mul_'.dol_hash(uniqid("dolibarr3"), 3);
  }
 
  private function _getBoundary($type = 'mixed')
  {
    if ($type == 'mixed') {
      return $this->_smtpsBoundary;
    } elseif ($type == 'related') {
      return $this->_smtpsRelatedBoundary;
    } elseif ($type == 'alternative') {
      return $this->_smtpsAlternativeBoundary;
    }
    return '';
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function server_parse($socket, $response)
  {
    // phpcs:enable
    $_retVal = true;
 
    $server_response = '';
 
    // avoid infinite loop
    $limit = 0;
 
    while (substr($server_response, 3, 1) != ' ' && $limit < 100) {
      if (!($server_response = fgets($socket, 256))) {
        $this->_setErr(121, "Couldn't get mail server response codes");
        $_retVal = false;
        break;
      }
      $this->log .= $server_response;
      $limit++;
    }
 
    $this->lastretval = substr($server_response, 0, 3);
 
    if (!(substr($server_response, 0, 3) == $response)) {
      $this->_setErr(120, "Ran into problems sending Mail.\r\nResponse: ".$server_response);
      $_retVal = false;
    }
 
    return $_retVal;
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function socket_send_str($_strSend, $_returnCode = null, $CRLF = "\r\n")
  {
    // phpcs:enable
    if ($this->_debug) {
      $this->log .= $_strSend; // @CHANGE LDR for log
    }
    fputs($this->socket, $_strSend.$CRLF);
    if ($this->_debug) {
      $this->log .= ' ('.$_returnCode.')'.$CRLF;
    }
 
    if ($_returnCode) {
      return $this->server_parse($this->socket, $_returnCode);
    }
 
    return null;
  }
 
  // =============================================================
  // ** Error handling methods
 
  private function _setErr($_errNum, $_errMsg)
  {
    $this->_smtpsErrors[] = array(
      'num' => $_errNum,
      'msg' => $_errMsg,
    );
  }
 
  public function getErrors()
  {
    $_errMsg = array();
 
    if (is_array($this->_smtpsErrors)) {
      foreach ($this->_smtpsErrors as $_err => $_info) {
        $_errMsg[] = 'Error ['.$_info['num'].']: '.$_info['msg'];
      }
    }
 
    return implode("\n", $_errMsg);
  }
}
 
 
// =============================================================
// ** CSV Version Control Info