loading

How to Verify Email Address and Check if Email is Real using PHP

How to Verify Email Address and Check if Email is Real using PHP

How to Verify Email Address and Check if Email is Real using PHP

0 Sales

Free

Verifying an email address is a difficult but necessary operation in the digital world. A genuine email address might assist you in making your campaign more successful. However, an incorrect email raises your marking costs and has a negative impact on the email client's reputation. Similarly, email validation is a typical and important feature of a web application. Before dealing with an email address, it must be validated and reviewed to see whether it is legitimate.

To validate an email in PHP, use the filter var() method with the FILTER VALIDATE EMAIL filter. It will check to see if the format of the provided email address is correct. However, this filter alone is insufficient to determine if an email address exists. In this lesson, we'll teach you how to use PHP to determine whether an email address is valid and existing.

We will confirm an email address in the PHP email verification script by inspecting the MX DNS Record and domain. This script may be used to validate a user's email address before sending an email or inserting data into a database. You may distinguish between legitimate and invalid email addresses and accept only valid email addresses from users.

PHP Email Verification Library

In PHP, the VerifyEmail class is used to determine whether an email address is legitimate and real by utilising the SMTP protocol. To validate an email address in PHP, you must use one of the functions of the VerifyEmail class.

check()

- Validate the email address format.
- Obtain the MX records for the email address's domain.
- Using the MX records, connect to the SMTP server.

- According to the response code:
     - Check to see if the recipient's email address is correct.
     - Check to see if the email user's domain exists.
     - Examine the message's delivery.

<?php 
/** 
 * Class to validate the email address 
 * 
 * @author CodexWorld.com <[email protected]> 
 * @copyright Copyright (c) 2018, CodexWorld.com
 * @url https://www.codexworld.com
 */ 
class VerifyEmail { 

    protected $stream false; 

    /** 
     * SMTP port number 
     * @var int 
     */ 
    protected $port 25; 

    /** 
     * Email address for request 
     * @var string 
     */ 
    protected $from '[email protected]'; 

    /** 
     * The connection timeout, in seconds. 
     * @var int 
     */ 
    protected $max_connection_timeout 30; 

    /** 
     * Timeout value on stream, in seconds. 
     * @var int 
     */ 
    protected $stream_timeout 5; 

    /** 
     * Wait timeout on stream, in seconds. 
     * * 0 - not wait 
     * @var int 
     */ 
    protected $stream_timeout_wait 0; 

    /** 
     * Whether to throw exceptions for errors. 
     * @type boolean 
     * @access protected 
     */ 
    protected $exceptions false; 

    /** 
     * The number of errors encountered. 
     * @type integer 
     * @access protected 
     */ 
    protected $error_count 0; 

    /** 
     * class debug output mode. 
     * @type boolean 
     */ 
    public $Debug false; 

    /** 
     * How to handle debug output. 
     * Options: 
     * * `echo` Output plain-text as-is, appropriate for CLI 
     * * `html` Output escaped, line breaks converted to `<br>`, appropriate for browser output 
     * * `log` Output to error log as configured in php.ini 
     * @type string 
     */ 
    public $Debugoutput 'echo'; 

    /** 
     * SMTP RFC standard line ending. 
     */ 
    const CRLF "\r\n"; 

    /** 
     * Holds the most recent error message. 
     * @type string 
     */ 
    public $ErrorInfo ''; 

    /** 
     * Constructor. 
     * @param boolean $exceptions Should we throw external exceptions? 
     */ 
    public function __construct($exceptions false) { 
        $this->exceptions = (boolean) $exceptions; 
    } 

    /** 
     * Set email address for SMTP request 
     * @param string $email Email address 
     */ 
    public function setEmailFrom($email) { 
        if (!self::validate($email)) { 
            $this->set_error('Invalid address : ' $email); 
            $this->edebug($this->ErrorInfo); 
            if ($this->exceptions) { 
                throw new verifyEmailException($this->ErrorInfo); 
            } 
        } 
        $this->from $email; 
    } 

    /** 
     * Set connection timeout, in seconds. 
     * @param int $seconds 
     */ 
    public function setConnectionTimeout($seconds) { 
        if ($seconds 0) { 
            $this->max_connection_timeout = (int) $seconds; 
        } 
    } 

    /** 
     * Sets the timeout value on stream, expressed in the seconds 
     * @param int $seconds 
     */ 
    public function setStreamTimeout($seconds) { 
        if ($seconds 0) { 
            $this->stream_timeout = (int) $seconds; 
        } 
    } 

    public function setStreamTimeoutWait($seconds) { 
        if ($seconds >= 0) { 
            $this->stream_timeout_wait = (int) $seconds; 
        } 
    } 

    /** 
     * Validate email address. 
     * @param string $email 
     * @return boolean True if valid. 
     */ 
    public static function validate($email) { 
        return (boolean) filter_var($emailFILTER_VALIDATE_EMAIL); 
    } 

    /** 
     * Get array of MX records for host. Sort by weight information. 
     * @param string $hostname The Internet host name. 
     * @return array Array of the MX records found. 
     */ 
    public function getMXrecords($hostname) { 
        $mxhosts = array(); 
        $mxweights = array(); 
        if (getmxrr($hostname$mxhosts$mxweights) === FALSE) { 
            $this->set_error('MX records not found or an error occurred'); 
            $this->edebug($this->ErrorInfo); 
        } else { 
            array_multisort($mxweights$mxhosts); 
        } 
        /** 
         * Add A-record as last chance (e.g. if no MX record is there). 
         * Thanks Nicht Lieb. 
         * @link http://www.faqs.org/rfcs/rfc2821.html RFC 2821 - Simple Mail Transfer Protocol 
         */ 
        if (empty($mxhosts)) { 
            $mxhosts[] = $hostname; 
        } 
        return $mxhosts; 
    } 

    /** 
     * Parses input string to array(0=>user, 1=>domain) 
     * @param string $email 
     * @param boolean $only_domain 
     * @return string|array 
     * @access private 
     */ 
    public static function parse_email($email$only_domain TRUE) { 
        sscanf($email"%[^@]@%s"$user$domain); 
        return ($only_domain) ? $domain : array($user$domain); 
    } 

    /** 
     * Add an error message to the error container. 
     * @access protected 
     * @param string $msg 
     * @return void 
     */ 
    protected function set_error($msg) { 
        $this->error_count++; 
        $this->ErrorInfo $msg; 
    } 

    /** 
     * Check if an error occurred. 
     * @access public 
     * @return boolean True if an error did occur. 
     */ 
    public function isError() { 
        return ($this->error_count 0); 
    } 

    /** 
     * Output debugging info 
     * Only generates output if debug output is enabled 
     * @see verifyEmail::$Debugoutput 
     * @see verifyEmail::$Debug 
     * @param string $str 
     */ 
    protected function edebug($str) { 
        if (!$this->Debug) { 
            return; 
        } 
        switch ($this->Debugoutput) { 
            case 'log': 
                //Don't output, just log 
                error_log($str); 
                break; 
            case 'html': 
                //Cleans up output a bit for a better looking, HTML-safe output 
                echo htmlentities( 
                        preg_replace('/[\r\n]+/'''$str), ENT_QUOTES'UTF-8' 
                ) 
                . "<br>\n"; 
                break; 
            case 'echo': 
            default: 
                //Normalize line breaks 
                $str preg_replace('/(\r\n|\r|\n)/ms'"\n"$str); 
                echo gmdate('Y-m-d H:i:s') . "\t" str_replace( 
                        "\n""\n \t "trim($str) 
                ) . "\n"; 
        } 
    } 

    /** 
     * Validate email
     * @param string $email Email address 
     * @return boolean True if the valid email also exist 
     */ 
    public function check($email) { 
        $result FALSE; 

        if (!self::validate($email)) { 
            $this->set_error("{$email} incorrect e-mail"); 
            $this->edebug($this->ErrorInfo); 
            if ($this->exceptions) { 
                throw new verifyEmailException($this->ErrorInfo); 
            } 
            return FALSE; 
        } 
        $this->error_count 0// Reset errors 
        $this->stream FALSE; 

        $mxs $this->getMXrecords(self::parse_email($email)); 
        $timeout ceil($this->max_connection_timeout count($mxs)); 
        foreach ($mxs as $host) { 
            /** 
             * suppress error output from stream socket client... 
             * Thanks Michael. 
             */ 
            $this->stream = @stream_socket_client("tcp://" $host ":" $this->port$errno$errstr$timeout); 
            if ($this->stream === FALSE) { 
                if ($errno == 0) { 
                    $this->set_error("Problem initializing the socket"); 
                    $this->edebug($this->ErrorInfo); 
                    if ($this->exceptions) { 
                        throw new verifyEmailException($this->ErrorInfo); 
                    } 
                    return FALSE; 
                } else { 
                    $this->edebug($host ":" $errstr); 
                } 
            } else { 
                stream_set_timeout($this->stream$this->stream_timeout); 
                stream_set_blocking($this->stream1); 

                if ($this->_streamCode($this->_streamResponse()) == '220') { 
                    $this->edebug("Connection success {$host}"); 
                    break; 
                } else { 
                    fclose($this->stream); 
                    $this->stream FALSE; 
                } 
            } 
        } 

        if ($this->stream === FALSE) { 
            $this->set_error("All connection fails"); 
            $this->edebug($this->ErrorInfo); 
            if ($this->exceptions) { 
                throw new verifyEmailException($this->ErrorInfo); 
            } 
            return FALSE; 
        } 

        $this->_streamQuery("HELO " self::parse_email($this->from)); 
        $this->_streamResponse(); 
        $this->_streamQuery("MAIL FROM: <{$this->from}>"); 
        $this->_streamResponse(); 
        $this->_streamQuery("RCPT TO: <{$email}>"); 
        $code $this->_streamCode($this->_streamResponse()); 
        $this->_streamResponse(); 
        $this->_streamQuery("RSET"); 
        $this->_streamResponse();
        $code2 $this->_streamCode($this->_streamResponse()); 
        $this->_streamQuery("QUIT"); 
        fclose($this->stream); 
        
        $code = !empty($code2)?$code2:$code;
        switch ($code) { 
            case '250': 
            /** 
             * http://www.ietf.org/rfc/rfc0821.txt 
             * 250 Requested mail action okay, completed 
             * email address was accepted 
             */ 
            case '450': 
            case '451': 
            case '452': 
                /** 
                 * http://www.ietf.org/rfc/rfc0821.txt 
                 * 450 Requested action not taken: the remote mail server 
                 * does not want to accept mail from your server for 
                 * some reason (IP address, blacklisting, etc..) 
                 * Thanks Nicht Lieb. 
                 * 451 Requested action aborted: local error in processing 
                 * 452 Requested action not taken: insufficient system storage 
                 * email address was greylisted (or some temporary error occured on the MTA) 
                 * i believe that e-mail exists 
                 */ 
                return TRUE;
            case '550':
                return FALSE; 
            default : 
                return FALSE; 
        } 
    } 

    /** 
     * writes the contents of string to the file stream pointed to by handle 
     * If an error occurs, returns FALSE. 
     * @access protected 
     * @param string $string The string that is to be written 
     * @return string Returns a result code, as an integer. 
     */ 
    protected function _streamQuery($query) { 
        $this->edebug($query); 
        return stream_socket_sendto($this->stream$query self::CRLF); 
    } 

    /** 
     * Reads all the line long the answer and analyze it. 
     * If an error occurs, returns FALSE 
     * @access protected 
     * @return string Response 
     */ 
    protected function _streamResponse($timed 0) { 
        $reply stream_get_line($this->stream1); 
        $status stream_get_meta_data($this->stream); 

        if (!empty($status['timed_out'])) { 
            $this->edebug("Timed out while waiting for data! (timeout {$this->stream_timeout} seconds)"); 
        } 

        if ($reply === FALSE && $status['timed_out'] && $timed $this->stream_timeout_wait) { 
            return $this->_streamResponse($timed $this->stream_timeout); 
        } 


        if ($reply !== FALSE && $status['unread_bytes'] > 0) { 
            $reply .= stream_get_line($this->stream$status['unread_bytes'], self::CRLF); 
        } 
        $this->edebug($reply); 
        return $reply; 
    } 

    /** 
     * Get Response code from Response 
     * @param string $str 
     * @return string 
     */ 
    protected function _streamCode($str) { 
        preg_match('/^(?<code>[0-9]{3})(\s|-)(.*)$/ims'$str$matches); 
        $code = isset($matches['code']) ? $matches['code'] : false; 
        return $code; 
    } 

} 

/** 
 * verifyEmail exception handler 
 */ 
class verifyEmailException extends Exception { 

    /** 
     * Prettify error message output 
     * @return string 
     */ 
    public function errorMessage() {
        $errorMsg $this->getMessage(); 
        return $errorMsg; 
    } 

} 

?>

Usage

The VerifyEmail library is simple to use for verifying email addresses in PHP.

 - VerifyEmail is used to initialise the library class ().
 - Configure the timeout, debugging, and sender email address.
 - Call the check() method and pass the email address to be validated.
      - If the supplied email address is genuine and real, it returns TRUE. It also indicates that the domain of this email exists and that the user is legitimate.
      - If the specified email address is incorrect or does not exist, the function returns FALSE.
 - Whether the check() method returns FALSE, you may test the email to see if the email format is legitimate but the user does not exist on the domain.

<?php

// Include library file
require_once 'VerifyEmail.class.php'// Initialize library class
$mail = new VerifyEmail();

// Set the timeout value on stream
$mail->setStreamTimeoutWait(20);

// Set debug output mode
$mail->DebugTRUE$mail->Debugoutput'html'// Set email address for SMTP request
$mail->setEmailFrom('[email protected]');

// Email to check
$email '[email protected]'// Check if email is valid and exist
if($mail->check($email)){ 
    echo 'Email &lt;'.$email.'&gt; is exist!'; 
}elseif(verifyEmail::validate($email)){ 
    echo 'Email &lt;'.$email.'&gt; is valid, but not exist!'; 
}else{ 
    echo 'Email &lt;'.$email.'&gt; is not valid and not exist!'; 
} 

?>

LICENSE OF USE

You can use it for personal or commercial projects. You can't resell it partially or in this form.

PRODUCT INFO

Create Date : Feb 17, 2022

Updated Date : Feb 17, 2022

Ratings

Comments : 0

Downloads : 0