";
            $vNL = "echo \"\n\"; flush();";
            // verbose Flush Only
            $vFlush = "flush();";
            // output for debugging
            eval("echo \"Internal: $version - running as ".AddSlashes($sapi_type)."\"; $vNL");
        }
    }
        
    // How we'll identify ourselves in SMTP HELO/EHLO argument
    if ( $serverName == "" ) $serverName = "$SERVER_NAME";
    if ( $serverName == "" ) $serverName = "localhost";
    
    // Initialize return values with default
    $return[0] = false;
    $return[1] = "Invalid email address (bad domain name)";
    $return[2] = false;
    $return[3] = "";
    
    // make sure that we're dealing with a valid email address format
    $isValid = true; // just in case validateEmailFormat is not available
    if ( function_exists('validateEmailFormat') ) $isValid = validateEmailFormat ( $email );
    
    // abort if necessary
    if ( !$isValid ) {
        if ( $verbose ) eval("echo \"Internal: $email format is invalid! Quitting ...\"; $vNL");
        return $return;
        
    } else {
        if ( $verbose ) eval("echo \"Internal: $email is a valid RFC 822 formatted address\"; $vNL");
    
        // assign our user part and domain parts respectively to seperate
        // variables
        list ( $user, $domain ) = explode ( "@", $email );
        if ( $verbose ) {
            eval("echo \"Internal: user ..... $user\"; $vNL");
            eval("echo \"Internal: domain ... $domain\"; $vNL");
        }
        
        // split up the domain into sub-parts
        $arr = explode ( ".", $domain );
        
        // figure out how many parts there are in the host/domain name portion
        $count = count ( $arr );
        
        // flag to indicate success
        $bSuccess = false;
        
        // we try this for each qualification step of domain name
        // (from full qualified to TopLevel)
        for ( $i = 0; $i < $count - 1 && !$bSuccess; $i = $i + 1 ) {
        
            // create the domain name
            $domain = "";
            for ( $j = $i; $j < $count; $j = $j + 1 ) {
                $domain = $domain . $arr[$j];
                if ( $j < $count - 1 )
                    // tack on the last dot
                    $domain = $domain . ".";
            }
            if ( $verbose ) eval("echo \"Internal: checking DNS for $domain ... \"; $vNL");
            
		// Strict Mail Check
		if($mail_check == "strict") {
            // check that an MX record exists for Top-Level domain
            // If it exists, start our email address checking
	    if (function_exists('checkdnsrr')) { 
            if ( checkdnsrr ( $domain, "MX" ) ) {
                
                // Okay -- we've got a valid DNS reverse record.
                if ( $verbose ) eval("echo \"Internal: ... Check DNS RR OK!\"; $vNL");
                // Test that MX record for host exists,
                // then fill 'mxhosts' and 'weight' arrays with correct info
                if ( getmxrr ( $domain, $mxhosts, $weight ) ) {
                    
                    // Now we've got MX records
                    if ( $verbose ) {
                        eval("echo \"Internal: MX LOOKUP RESULTS:\"; $vNL");
                        for ( $i = 0; $i < count ( $mxhosts ); $i++) {
                            eval("echo \"     $mxhosts[$i]\"; $vNL");
                        }
                    }
                    // sift through the 'mxhosts', connecting to each one
                    // ONLY until we get a good match
                    $mxcount = count( $mxhosts );
                    // determine our MX host cutoff
                    $mxstop = ($mxcount > $mxcutoff) ? $mxcutoff : $mxcount;
                    for ( $i = 0; $i < $mxstop ; $i++ ) {
                    
                        // open socket on port 25 to mxhost, setting
                        // returned socket pointer to $sp
                        if( $verbose ) eval("echo \"Internal: attempting to open $mxhosts[$i] ...\"; $vNL");
                        $sp = fsockopen ( $mxhosts[$i], 25, $errno, $errstr, $socketTimeout);
                        
                        // Greeting Code default
                        // Sets default greeting code to 421, just in case we
                        // don't ever hear ANYTHING from this host.
                        // If we hear nothing, we'll want to skip it.
                        $greetCode = "421";
                        
                        // if $sp connection is good, let's rock on
                        if ( $sp ) {
                            if ( $verbose ) {
                                eval("echo \"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\"; $vNL");
                                eval("echo \"Internal: socket open to $mxhosts[$i]\"; $vNL");
                            }
                            // work variables
                            $waitMarker = 0;
                            $msec = 0; // milisec count
                            $tsec = 0; // tensec count
                            $out = "";
                            
                            // set our created socket for $sp to
                            // non-blocking mode so that our fgets()
                            // calls will return with a quickness
                            set_socket_blocking ( $sp, false );
                            
                            // as long as our 'out' variable does not begin
                            // with a valid SMTP greeting (220 or 421),
                            // keep looping (do) until we get something
                            do {
                            
                                // prepare for clean debug output if necessary
                                // (puts a line break after the waitMarkers)
                                if ( $verbose && $msec > 0 ) {
                                    $elapsed = $tsec + ($msec/4);
                                    $clean = "echo \"($elapsed seconds)\"; $vNL";
                                }
                                // output of the stream assigned to
                                // 'out' variable
                                $out = fgets ( $sp, 2500 );
                                
                                // Check for multi-line output (###-)
                                if ( preg_match ( "/^2..-/", $out ) ) {
                                    $end = false;
                                    while ( !$end ) {
                                        // keep listening
                                        $line = fgets ( $sp, 2500 );
                                        $out .= $line;
                                        if ( preg_match ( "/^2.. /", $line ) ) {
                                            // the last line of output shouldn't
                                            // have a dash after the response code
                                            $end = true;
                                        }
                                    }
                                }
                                
                                if ( $verbose && $out != "" ) eval("$clean echo \"Server: ".AddSlashes($out)."\"; $vNL");
                                
                                // if we get a "220" code (service ready),
                                // we're ready to rock on
                                if ( substr ( $out, 0, 3 ) == "220" ) {
                                    if ( $verbose ) eval("echo \"Internal: service ready on $mxhosts[$i] ... moving on\"; $vNL");
                                    $return[2] = true;
                                    $return[3] = "$mxhosts[$i]";
                                    // determine if we should speak in terms of HELO or EHLO
                                    if ( preg_match ( "/ESMTP/", $out ) ) {
                                        $send = "HELO";
                                    } else {
                                        $send = "HELO";
                                    }
                                    
                                    // Set Greeting Code
                                    $greetCode = "220";
                                    
                                }
                                
                                // else if ...
                                // Perhaps we've gotten a 421 Temporarily Refused error
                                else if ( substr ( $out, 0, 3 ) == "421" ) {
                                
                                    //if ( $verbose ) echo " ... moving on\n";
                                    if ( $verbose ) eval("echo \"Internal: $mxhosts[$i] temporarily rejected connection. (421 response)\"; $vNL");
                                    $return[2] = false;
                                    // Set Greeting Code
                                    $greetCode = "421";
                                    break; // get out of this loop
                                    
                                }
                                
                                // increase our waitTimeout counters
                                // if we still haven't heard anything ...
                                // Note that the time looping isn't an exact science
                                // with usleep or the Windows hack ... but
                                // it's in the ballpark. Close enough.
                                if ( $out == "" && $msec < $waitTimeout ) {

                                    // wait for a quarter of a second
                                    if ( $verbose ) {
                                        if ( $msec == 0 ) {
                                            eval("echo \"Internal: Waiting: one '.' ~ 0.25 seconds of waiting\"; $vNL");
                                        }
                                        eval("echo \".\"; $vFlush");
                                        $waitMarker++;
                                        if ( $waitMarker == 40 ) {
                                            // ten seconds
                                            $tsec += 10;
                                            eval("echo \" ($tsec seconds)\"; $vNL");
                                            $waitMarker = 0;
                                        }
                                    }
                                    $msec = $msec + 0.25;
                                    usleep(250000);
                                    
                                } elseif ( $msec == $waitTimeout ) {
                                    
                                    // let's get out of here. Toooo sloooooww ...
                                    if ( $verbose ) eval("$clean echo \"Internal: !! we've waited $waitTimeout seconds !!\nbreaking ...\"; $vNL");
                                    break;

                                }
                                
                                                            
                                // end of 'do' loop
                            } while ( substr ( $out, 0, 3 ) != "220" );
                            
                            // Make sure we got a "220" greetCode
                            // before we start shoveling requests
                            // at this server.
                            if ( $greetCode == "220" ) {
                            
                                // reset our file pointer to blocking mode,
                                // so we can wait for communication to finish
                                // before moving on ...
                                set_socket_blocking ( $sp, true );
                                
                                // talk to the MX mail server, attempt to validate
                                // ourself. Use "HELO" or "EHLO", as determined above
                                fputs ( $sp, "$send $serverName"."$CRLF" );
                                if ( $verbose ) eval("echo \"Client: $send $serverName\"; $vNL");
                                
                                // get the mail server's reply, check it
                                //
                                $originalOutput = fgets ( $sp, 2500 );
                                // Check for multi-line positive output
                                if ( preg_match ( "/^...-/", $originalOutput ) ) {
                                    $end = false;
                                    while ( !$end ) {
                                        // keep listening
                                        $line = fgets ( $sp, 2500 );
                                        $originalOutput .= $line;
                                        if ( preg_match ( "/^... /", $line ) ) {
                                            // the last line of output shouldn't
                                            // have a dash after the response code
                                            $end = true;
                                        }
                                    }
                                }
                                if ( $verbose ) eval("echo \"Server: ".AddSlashes($originalOutput)."\"; $vNL");
                                
                                
                                // if there's a HELP option, let's see it
                                if ( $verbose ) {
                                    if( preg_match( "/250.HELP/m", $originalOutput ) && $verbose == true ) {
                                        
                                        eval("echo \"Internal: VERBOSE-MODE ONLY: Getting the HELP output\"; $vNL");
                                        // Get the output of the HELP command
                                        fputs ( $sp, "HELP"."$CRLF" );
                                        if ( $verbose ) eval("echo \"Client: HELP\"; $vNL");
                                        // Get output again
                                        $output = fgets ( $sp, 2500 );
                                        // Check for multi-line positive output
                                        if ( preg_match ( "/^...-/", $output ) ) {
                                            $end = false;
                                            while ( !$end ) {
                                                // keep listening
                                                $line = fgets ( $sp, 2500 );
                                                $output .= $line;
                                                if ( preg_match ( "/^... /", $line ) ) {
                                                    // the last line of output shouldn't
                                                    // have a dash after the response code
                                                    $end = true;
                                                }
                                            }
                                        }
                                        if ( $verbose ) eval("echo \"Server: ".AddSlashes($output)."\"; $vNL");
                                                            
                                    }
                                }
                                
                                // Give the MAIL FROM: header to the server
                                fputs ( $sp, "MAIL FROM: <$from" . "@" . "$serverName" . ">"."$CRLF");
                                if ( $verbose ) eval("echo \"Client: MAIL FROM: $leftCarrot"."$from" . "@" . "$serverName" . "$rightCarrot\"; $vNL");
                                
                                // Get output again
                                $output = fgets ( $sp, 2500 );
                                // Check for multi-line positive output
                                if ( preg_match ( "/^...-/", $output ) ) {
                                    $end = false;
                                    while ( !$end ) {
                                        // keep listening
                                        $line = fgets ( $sp, 2500 );
                                        $output .= $line;
                                        if ( preg_match ( "/^... /", $line ) ) {
                                            // the last line of output shouldn't
                                            // have a dash after the response code
                                            $end = true;
                                        }
                                    }
                                }
                                if ( $verbose ) eval("echo \"Server: ".AddSlashes($output)."\"; $vNL");
                                
                                // Give the RCPT TO: header for the email address we're testing
                                fputs ( $sp, "RCPT TO: <$email>"."$CRLF" );
                                if ( $verbose ) eval("echo \"Client: RCPT TO: $leftCarrot"."$email"."$rightCarrot\"; $vNL");
                                
                                // Get output again
                                // This will be the one we check for validity
                                $output = fgets ( $sp, 2500 );
                                // Check for multi-line positive output
                                if ( preg_match ( "/^...-/", $output ) ) {
                                    $end = false;
                                    while ( !$end ) {
                                        // keep listening
                                        $line = fgets ( $sp, 2500 );
                                        $output .= $line;
                                        if ( preg_match ( "/^... /", $line ) ) {
                                            // the last line of output shouldn't
                                            // have a dash after the response code
                                            $end = true;
                                        }
                                    }
                                }
                                if ( $verbose ) eval("echo \"Server: ".AddSlashes($output)."\"; $vNL");
                                
                                // test the last reply code from the mail server
                                // for the 250 (okay) response
                                if ( substr ( $output, 0, 3 ) == "250" ) {
                                    
                                    // set our true/false(ness)
                                    // array item for testing
                                    $return[0] = true;
                                    $return[1] = $output;
                                    if ( $verbose ) eval("echo \"Internal: Check for 250 ... Recipient OK\"; $vNL");
                                    
                                } else {
                                
                                    // we didn't get a 250
                                    // may be a bogus address
                                    if ( $verbose ) eval("echo \"Internal: Check for 250 ... Response did not begin with 250!\"; $vNL");
                                    // fill in 2nd array item with mail server's
                                    // reply for user to test if they want
                                    $return[0] = false;
                                    $return[1] = $output;
                                    
                                }
                                
                                // tell the mail server we're done
                                fputs ( $sp, "QUIT"."$CRLF" );
                                if ( $verbose ) {
                                    eval("echo \"Client: QUIT\"; $vNL");
                                    eval("echo \"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\"; $vNL $vNL");                            
                                }
                                
                                // close the socket/file pointer
                                fclose ( $sp );
                                
                                // If we got a good response back on RCPT TO,
                                // break here
                                // Otherwise, keep trying MX servers until we
                                // get a good response or run out of MX servers
                                // to try.
                                if ( $return[0] == true ) {
                                    if ( $verbose ) {
                                        eval("echo \"Internal: Recipient is OK - thanks, $mxhosts[$i]!\"; $vNL");
                                        eval("echo \"Internal: Stop checking MX hosts ...\"; $vNL");                                        
                                    }
                                    $bSuccess = true;
                                    break;
                                }
                            
                            } else {
                                
                                // greetCode wasn't "220"
                                // we better skip this one and move on
                                if ( $verbose ) eval("echo \"Internal: SKIPPING $mxhosts[$i] -- never got 220 welcome\"; $vNL");
                                // close out this connection
                                fclose ( $sp );
                                
                            } // end of greetCode check
                        
                        } else {
                            // $sp socket pointer was false -- couldn't open it
                            if ( $verbose ) {
                                eval("echo \"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\"; $vNL");                            
                                eval("echo \"Internal: could not open socket to $mxhosts[$i]!\"; $vNL");
                                eval("echo \"fsockopen error $errno: $errstr\"; $vNL");
                                eval("echo \"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\"; $vNL $vNL");                            
                            }
                            $return[0] = false;
                            $return[1] = "fsockopen error $errno: $errstr";
                        } // end of $sp check
                    
                    } // end for $mxhosts
                    
                } //  getmxrr test
                  else {
                    // getmxrr failed
                    if ( $verbose ) eval("echo \"Internal: No MX reverse records found for $domain\"; $vNL");
                    $return[0] = false;
                    $return[1] = "554 No MX records found for $domain";
                } // end getmxrr test
            
            } // continue checkdnsrr test
                else {
                if ( $verbose ) eval("echo \"Internal: No DNS Reverse Record available!\"; $vNL");
                $return[0] = false;
                $return[1] = "554 No DNS reverse record found for $domain";
            } // end checkdnsrr test

	} // if function doesn't exist
    } elseif ($mail_check == "easy") { // easy email address check
		$pattern = "/^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$/";
		if(preg_match($pattern, $email)) {
			$return[0] = true;
			$return[1] = "OK";
		} else {
			$return[0] = false;
			$return[1] = "NG";
		}
	} else { // Nothing to do
		$return[0] = true;
		$return[1] = "No Check";
	}

        } // end walking through each domain possibility
    
    } // end isValid
    
    // output elapsed time if Verbose
    if ( $verbose ) {
        list ( $msecStop, $secStop ) = explode ( " ", microtime() );
        $elapsedTime = (double)($secStop + $msecStop) - ($secStart + $msecStart);
        $elapsedTime = number_format($elapsedTime,3);
        eval("echo \"Internal: VERBOSE-MODE execution time: $elapsedTime seconds (silent mode somewhat faster)\"; $vNL");
        if ( $sapi_type != "cgi" ) echo "