PHPMailer\PHPMailer

PHPMailer::smtpConnect │ public │ WP 1.0

Initiate a connection to an SMTP server. Returns false if the operation failed.

Method of the class: PHPMailer{}

No Hooks.

Returns

true|false.

Usage

$PHPMailer = new PHPMailer();
$PHPMailer->smtpConnect( $options );

$options(array)

An array of options compatible with stream_context_create().
Default: null

PHPMailer::smtpConnect() PHPMailer::smtpConnect code ^{WP 7.0}

public function smtpConnect($options = null)
{
    if (null === $this->smtp) {
        $this->smtp = $this->getSMTPInstance();
    }

    //If no options are provided, use whatever is set in the instance
    if (null === $options) {
        $options = $this->SMTPOptions;
    }

    //Already connected?
    if ($this->smtp->connected()) {
        return true;
    }

    $this->smtp->setTimeout($this->Timeout);
    $this->smtp->setDebugLevel($this->SMTPDebug);
    $this->smtp->setDebugOutput($this->Debugoutput);
    $this->smtp->setVerp($this->do_verp);
    $this->smtp->setSMTPUTF8($this->UseSMTPUTF8);
    if ($this->Host === null) {
        $this->Host = 'localhost';
    }
    $hosts = explode(';', $this->Host);
    $lastexception = null;

    foreach ($hosts as $hostentry) {
        $hostinfo = [];
        if (
            !preg_match(
                '/^(?:(ssl|tls):\/\/)?(.+?)(?::(\d+))?$/',
                trim($hostentry),
                $hostinfo
            )
        ) {
            $this->edebug(self::lang('invalid_hostentry') . ' ' . trim($hostentry));
            //Not a valid host entry
            continue;
        }
        //$hostinfo[1]: optional ssl or tls prefix
        //$hostinfo[2]: the hostname
        //$hostinfo[3]: optional port number
        //The host string prefix can temporarily override the current setting for SMTPSecure
        //If it's not specified, the default value is used

        //Check the host name is a valid name or IP address before trying to use it
        if (!static::isValidHost($hostinfo[2])) {
            $this->edebug(self::lang('invalid_host') . ' ' . $hostinfo[2]);
            continue;
        }
        $prefix = '';
        $secure = $this->SMTPSecure;
        $tls = (static::ENCRYPTION_STARTTLS === $this->SMTPSecure);
        if ('ssl' === $hostinfo[1] || ('' === $hostinfo[1] && static::ENCRYPTION_SMTPS === $this->SMTPSecure)) {
            $prefix = 'ssl://';
            $tls = false; //Can't have SSL and TLS at the same time
            $secure = static::ENCRYPTION_SMTPS;
        } elseif ('tls' === $hostinfo[1]) {
            $tls = true;
            //TLS doesn't use a prefix
            $secure = static::ENCRYPTION_STARTTLS;
        }
        //Do we need the OpenSSL extension?
        $sslext = defined('OPENSSL_ALGO_SHA256');
        if (static::ENCRYPTION_STARTTLS === $secure || static::ENCRYPTION_SMTPS === $secure) {
            //Check for an OpenSSL constant rather than using extension_loaded, which is sometimes disabled
            if (!$sslext) {
                throw new Exception(self::lang('extension_missing') . 'openssl', self::STOP_CRITICAL);
            }
        }
        $host = $hostinfo[2];
        $port = $this->Port;
        if (
            array_key_exists(3, $hostinfo) &&
            is_numeric($hostinfo[3]) &&
            $hostinfo[3] > 0 &&
            $hostinfo[3] < 65536
        ) {
            $port = (int) $hostinfo[3];
        }
        if ($this->smtp->connect($prefix . $host, $port, $this->Timeout, $options)) {
            try {
                if ($this->Helo) {
                    $hello = $this->Helo;
                } else {
                    $hello = $this->serverHostname();
                }
                $this->smtp->hello($hello);
                //Automatically enable TLS encryption if:
                //* it's not disabled
                //* we are not connecting to localhost
                //* we have openssl extension
                //* we are not already using SSL
                //* the server offers STARTTLS
                if (
                    $this->SMTPAutoTLS &&
                    $this->Host !== 'localhost' &&
                    $sslext &&
                    $secure !== 'ssl' &&
                    $this->smtp->getServerExt('STARTTLS')
                ) {
                    $tls = true;
                }
                if ($tls) {
                    if (!$this->smtp->startTLS()) {
                        $message = $this->getSmtpErrorMessage('connect_host');
                        throw new Exception($message);
                    }
                    //We must resend EHLO after TLS negotiation
                    $this->smtp->hello($hello);
                }
                if (
                    $this->SMTPAuth && !$this->smtp->authenticate(
                        $this->Username,
                        $this->Password,
                        $this->AuthType,
                        $this->oauth
                    )
                ) {
                    throw new Exception(self::lang('authenticate'));
                }

                return true;
            } catch (Exception $exc) {
                $lastexception = $exc;
                $this->edebug($exc->getMessage());
                //We must have connected, but then failed TLS or Auth, so close connection nicely
                $this->smtp->quit();
            }
        }
    }
    //If we get here, all connection attempts have failed, so close connection hard
    $this->smtp->close();
    //As we've caught all exceptions, just report whatever the last one was
    if ($this->exceptions && null !== $lastexception) {
        throw $lastexception;
    }
    if ($this->exceptions) {
        // no exception was thrown, likely $this->smtp->connect() failed
        $message = $this->getSmtpErrorMessage('connect_host');
        throw new Exception($message);
    }

    return false;
}