Volver al Tutoriales de PHP

TUTORIAL: Envío de correo electrónico a través de SMTP

  • Bogey
  • Bogey
  • Genius
  • Avatar de Usuario
  • Registrado: Jul 14, 2005
  • Mensajes: 8211
  • Loc: USA
  • Status: Offline

Nota Septiembre 27th, 2010, 11:45 pm

1.0 Introducción


Hay muchos casos en que usted (como administrador del sitio web / dueño del sitio) desea enviar un correo electrónico a sus usuarios, o permitir a los usuarios enviar un correo electrónico a otros usuarios. Obviamente, usted desea codificar algunos permisos en eso y permiten a los usuarios desactivar otros usuarios para enviar correos electrónicos a los mismos, de lo contrario podría llegar a ser muy feo.

El principal objetivo de este tutorial es para romper el código existente en pedacitos y explicar lo que cada línea tiene, por lo que cuando se utiliza el código, que sería capaz de usar y de comprender bien lo que lo haga.

1.1 Derechos de Autor


Esta clase no es mi original, así que no son propietarios de esta clase. Lo tengo como una simple página PHP y lo convirtió en una clase y se ha editado un poco...pero yo no la creó a partir de cero.

2.0 Los servidores SMTP


La mayoría de los ejércitos como servidor SMTP (y el servidor POP) que está disponible para que usted utilice para este fin. En la mayoría de los casos, el enlace con el servidor SMTP sería algo como: smtp.myhost.com .

En la mayoría de los casos, un puerto SMTP normal sería 25, mientras que un puerto seguro para SMTP sería 465. Si no es de esos puertos a continuación, el anfitrión debe decirle que los puertos son los puertos SMTP. (Ellos le dirán los puertos, incluso si son los puertos).

2.1 Alternativas SMTP


Si, por alguna razón su anfitrión no le proporciona con un servidor SMTP para que usted pueda utilizar, hay pocas alternativas por ahí que puede utilizar. El primero que me viene a la mente es gmail.

Gmail le permite utilizar su servidor SMTP para enviar mensajes de correo electrónico de forma gratuita y sin ningún tipo de molestia. Con esto quiero decir que no tiene que ir a Gmail y habilitar SMTP ni nada de eso...su siempre ahí para todo lo que necesita hacer es llenar la información en el guión y el trabajo lo haría. A continuación se presentan la información que le permite utilizar su servidor SMTP:

Servidor SMTP : Smtp.gmail.com
Puerto : 587
Nombre de usuario : (Tu correo gmail (e. i: myname@gmail.com ))
Contraseña : (Tu contraseña a su correo electrónico)

Hay otros, además de gmail que le proporcionan un servidor SMTP. Uno, por ejemplo, es SMTP.com , Pero como usted puede ver, que es un poco más caro que alternativas se gmail.com.

3. 0 La clase de iniciación


He querido una clase simple que me permitirá que los usuarios envían a los usuarios, me envía a los usuarios y usuarios que envíen a mí...He encontrado una función que limita el servicio de correo electrónico que me envía a los usuarios y eso es todo. Obviamente tiene que haber algo que yo tenía que hacer, para aumentar las capacidades de esa función.

La forma en que quería utilizar esta función es:

PHP Código: [ Select ]
new mail($to, $subject, $message)


Una sola línea, en mi opinión, es una muy grande, más cuando se trata de este...un trazador de líneas que devuelve cierto si el mensaje fue enviado o falsos si el mensaje no se enviará.

Esto me permite abrigo que un trazador de líneas con un si () declaración y devolver al usuario con el estado de su mensaje.

3.1 La declaración de variables


Hay unas pocas variables declaradas en la clase para hacer esta clase útil:
PHP Código: [ Select ]
class mail {
    private $smtpServer = 'smtp.gmail.com';
    private $port = '587';
    private $timeout = 30;
    private $username = 'myname@gmail.com';
    private $password = 'mypassword';
    private $username_email = 'myreceivingemail@gmail.com';
    private $newline = "\r\n";
    private $localdomain = 'http://www.mysite.com';
    private $charset = 'windows-1251';
    private $contentTransferEncoding = false;
 
    // Do not change anything below
    private $smtpConnect = false;
    private $to = false;
    private $subject = false;
    private $message = false;
    private $headers = false;
    private $logArray = array(); // Array response message for debug
    private $Error = '';
    private $from = false;
}
  1. class mail {
  2.     private $smtpServer = 'smtp.gmail.com';
  3.     private $port = '587';
  4.     private $timeout = 30;
  5.     private $username = 'myname@gmail.com';
  6.     private $password = 'mypassword';
  7.     private $username_email = 'myreceivingemail@gmail.com';
  8.     private $newline = "\r\n";
  9.     private $localdomain = 'http://www.mysite.com';
  10.     private $charset = 'windows-1251';
  11.     private $contentTransferEncoding = false;
  12.  
  13.     // Do not change anything below
  14.     private $smtpConnect = false;
  15.     private $to = false;
  16.     private $subject = false;
  17.     private $message = false;
  18.     private $headers = false;
  19.     private $logArray = array(); // Array response message for debug
  20.     private $Error = '';
  21.     private $from = false;
  22. }

Aquí están las variables desglosadas.

  • smtpServer
    • El servidor SMTP que sería la conexión y utilizando para enviar mensajes
  • puerto
    • El puerto que se utiliza para conectar con el servidor SMTP
  • tiempo de espera
    • período de tiempo (en segundos) que la secuencia de comandos se intenta conectar antes de decidir que no se conecta
  • nombre de usuario
    • Las direcciones de correo gmail (es decir: minombre @ gmail. com ) Para que el servidor SMTP está ligada a
  • contraseña
    • La clave para que el correo electrónico para permitir el uso del servidor SMTP
  • username_email
    • Este es el correo electrónico que recibirá los mensajes del usuario...no tiene que ser de Gmail.
  • nueva línea
    • Así es como la secuencia de comandos hará saltos de línea en los mensajes de error y depuración.
  • localdomain
    • Este es un enlace a su sitio.
  • charset
    • El conjunto de caracteres (codificación creo) que se utiliza en el mensaje
  • contentTransferEncoding
    • Si se establece en true, se pondría en el encabezado que el contenido está codificado (creo...no creo que realmente sería codificar el contenido
      • PHP Código: [ Select ]
      function __construct($to, $subject, $message, $to_admin) {

      La construcción de declaración de la función. Establece las variables dinámicas que se utilizan en toda la clase.
      PHP Código: [ Select ]
          $this->to = (($to_admin === true) ? $this->username_email : $to );

      Esta es la línea que determina el destinatario del mensaje de correo electrónico. Si $ To_admin Es cierto que entonces su administración, de lo contrario su no a la administración.
      PHP Código: [ Select ]
          $this->subject = &$subject;

      Bueno, este es el asunto del mensaje.
      PHP Código: [ Select ]
          $this->message = &$message;

      Y esto aquí es el mensaje del mensaje.
      PHP Código: [ Select ]
          // Connect to server
          if(!$this->Connect2Server()) {
      1.     // Connect to server
      2.     if(!$this->Connect2Server()) {

      Aquí es donde comprobamos el resultado del intento de conexión. Comprobación específicamente para el fracaso. Si es un éxito que no es necesario (no debe) echo nada.
      PHP Código: [ Select ]
              // Display error message
              echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
              print_r($this->logArray);
              echo $this->newline.'-->'.$this->newline;
              return false;
          }
      1.         // Display error message
      2.         echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
      3.         print_r($this->logArray);
      4.         echo $this->newline.'-->'.$this->newline;
      5.         return false;
      6.     }

      Aquí es donde los errores de impresión de la pantalla y la depuración en el código fuente...también devolverá false para que pueda imprimir un mensaje al usuario diciéndole que el envío de ese mensaje no funcionó.
      PHP Código: [ Select ]
          return true;
      }
      1.     return true;
      2. }

      Si la conexión funcionó, y la sentencia if que comprueba el fracaso no provocó, entonces devolver true para que pueda imprimir un mensaje a los usuarios diciéndoles que el mensaje ha sido enviado con éxito.

      A continuación se muestra la función en su totalidad.
      PHP Código: [ Select ]
      public function __construct($to, $subject, $message, $to_admin) {
          $this->to_admin = $to_admin;
          $this->to = (($this->to_admin === false) ? $this->username_email : $to );
          $this->from = (($this->to_admin === false) ? $to : $this->username_email );
          $this->subject = &$subject;
          $this->message = &$message;
       
          // Connect to server
          if(!$this->Connect2Server()) {
              // Display error message
              echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
              print_r($this->logArray);
              echo $this->newline.'-->'.$this->newline;
              return false;
          }
          return true;
      }
      1. public function __construct($to, $subject, $message, $to_admin) {
      2.     $this->to_admin = $to_admin;
      3.     $this->to = (($this->to_admin === false) ? $this->username_email : $to );
      4.     $this->from = (($this->to_admin === false) ? $to : $this->username_email );
      5.     $this->subject = &$subject;
      6.     $this->message = &$message;
      7.  
      8.     // Connect to server
      9.     if(!$this->Connect2Server()) {
      10.         // Display error message
      11.         echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
      12.         print_r($this->logArray);
      13.         echo $this->newline.'-->'.$this->newline;
      14.         return false;
      15.     }
      16.     return true;
      17. }


      3.3 Conexión con el servidor SMTP


      Ahora lo que tenemos que hacer es conectar con el servidor.
      PHP Código: [ Select ]
      private function Connect2Server() {

      Aquí iniciar la función. Hacemos esta función privada, ya que sólo esta clase que se supone que tienen acceso a la función.
      PHP Código: [ Select ]
          // Connect to server
          $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);
      1.     // Connect to server
      2.     $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);


      Aquí realmente conectarse al servidor SMTP utilizando la información proporcionada en las variables declaradas.
      PHP Código: [ Select ]
          $this->logArray['CONNECT_RESPONSE'] = $this->readResponse();

      Aquí tenemos registro de la respuesta / el resultado del intento de conexión SMTP.
      PHP Código: [ Select ]
          if (!is_resource($this->smtpConnect)) {
              return false;
          }
      1.     if (!is_resource($this->smtpConnect)) {
      2.         return false;
      3.     }

      Si la conexión falla, se vuelve falsa. Volviendo algo en este punto se detiene la función de continuar y termina la secuencia de comandos.
      PHP Código: [ Select ]
          $this->logArray['connection'] = "Connection accepted";

      Si llegamos a este punto, significa que el servidor SMTP se conecta con éxito a...registro que permite para propósitos de depuración.
      PHP Código: [ Select ]
          // Hi, server!
          $this->sendCommand("HELLO {$this->localdomain}");
          $this->logArray['HELLO'] = $this->readResponse();
      1.     // Hi, server!
      2.     $this->sendCommand("HELLO {$this->localdomain}");
      3.     $this->logArray['HELLO'] = $this->readResponse();

      Aquí es donde presentamos nuestra página al servidor SMTP y almacenar la respuesta del servidor SMTP para propósitos de depuración.
      PHP Código: [ Select ]
          // Let's know each other
          $this->sendCommand('AUTH LOGIN');
          $this->logArray['AUTH_REQUEST'] = $this->readResponse();
      1.     // Let's know each other
      2.     $this->sendCommand('AUTH LOGIN');
      3.     $this->logArray['AUTH_REQUEST'] = $this->readResponse();

      Aquí es donde el guión está pidiendo permiso e iniciar el nombre de usuario / contraseña fase del proceso de conexión. Somos tienda de la respuesta para propósitos de depuración.
      PHP Código: [ Select ]
          // My password..
          $this->sendCommand(base64_encode($this->password));
          $this->logArray['REQUEST_PASSWD'] = $this->readResponse();
      1.     // My password..
      2.     $this->sendCommand(base64_encode($this->password));
      3.     $this->logArray['REQUEST_PASSWD'] = $this->readResponse();

      En esta fase, estamos enviando la contraseña y, a continuación, guardar la respuesta para propósitos de depuración.
      PHP Código: [ Select ]
          // If error in response auth...
          if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
              $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
              return false;
          }
      1.     // If error in response auth...
      2.     if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
      3.         $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
      4.         return false;
      5.     }

      Aquí es donde comprobamos el resultado del proceso de inicio de sesión. Nosotros guardamos el error en la variable de error y volver falsos, detener la secuencia de comandos.
      PHP Código: [ Select ]
          // "From" mail...
          $this->sendCommand("MAIL FROM: {$this->from}");
          $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();
      1.     // "From" mail...
      2.     $this->sendCommand("MAIL FROM: {$this->from}");
      3.     $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();

      Aquí le decimos al servidor SMTP que el mensaje se envía desde y almacenar la respuesta para propósitos de depuración.
      PHP Código: [ Select ]
          if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
              $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
              return false;
          }
      1.     if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
      2.         $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
      3.         return false;
      4.     }

      Comprobación del resultado de la validación de la dirección "De". Si la respuesta no es correcta, el error que almacenamos en la variable de error y devolver false, detener la secuencia de comandos.
      PHP Código: [ Select ]
          // "To" address
          $this->sendCommand("RCPT TO: {$this->to}");
          $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();
      1.     // "To" address
      2.     $this->sendCommand("RCPT TO: {$this->to}");
      3.     $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();

      Aquí le decimos al servidor SMTP la dirección a la que el mensaje fue escrito. A continuación, almacenamos la respuesta para propósitos de depuración.
      PHP Código: [ Select ]
          if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
          {
              $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
              return false;
          }
      1.     if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
      2.     {
      3.         $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
      4.         return false;
      5.     }

      Aquí estamos comprobando el resultado de la validación de la dirección de correo electrónico destinatarios. Almacenar el error y volver falsos, detener la secuencia de comandos.
      PHP Código: [ Select ]
          // Send data to server
          $this->sendCommand('DATA');
          $this->logArray['DATA_RESPONSE'] = $this->readResponse();
      1.     // Send data to server
      2.     $this->sendCommand('DATA');
      3.     $this->logArray['DATA_RESPONSE'] = $this->readResponse();

      Aquí le enviamos los datos y el almacenamiento de la respuesta para propósitos de depuración.
      PHP Código: [ Select ]
          // Send mail message
          if (!$this->sendMail()) return false;
      1.     // Send mail message
      2.     if (!$this->sendMail()) return false;

      Aquí le enviamos el mensaje de correo...comprobamos específicamente para el fracaso, y si no, devolver false, lo que le permite escribir el mensaje propio fracaso.
      PHP Código: [ Select ]
          // Good bye server! =)
          $this->sendCommand('QUIT');
          $this->logArray['QUIT_RESPONSE'] = $this->readResponse();
      1.     // Good bye server! =)
      2.     $this->sendCommand('QUIT');
      3.     $this->logArray['QUIT_RESPONSE'] = $this->readResponse();

      Aquí nos estamos preparando para desconectarse del servidor SMTP. Almacenamiento de la respuesta para propósitos de depuración.
      PHP Código: [ Select ]
          // Close smtp connect
          fclose($this->smtpConnect);
          return true;
      }
      1.     // Close smtp connect
      2.     fclose($this->smtpConnect);
      3.     return true;
      4. }

      Aquí estamos realmente desconectar del servidor SMTP. Desde que llegamos a este punto, el correo fue enviado, y todo funcionó correctamente, por lo que se devuelve true para el éxito.

      La razón de que tienen el "dejar de fumar" y después de la desconexión, en lugar de desconectar, es la misma razón por la que pulse Apagar para apagar el ordenador, en vez de tirar del enchufe. (Al menos eso es como lo veo yo).

      Ahora, aquí es que la función en su totalidad.
      PHP Código: [ Select ]
      private function Connect2Server() {
          // Connect to server
          $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);
          $this->logArray['CONNECT_RESPONSE'] = $this->readResponse();
       
          if (!is_resource($this->smtpConnect)) {
              return false;
          }
          $this->logArray['connection'] = "Connection accepted";
          // Hi, server!
          $this->sendCommand("HELLO {$this->localdomain}");
          $this->logArray['HELLO'] = $this->readResponse();
          // Let's know each other
          $this->sendCommand('AUTH LOGIN');
          $this->logArray['AUTH_REQUEST'] = $this->readResponse();
          // My name...
          $this->sendCommand(base64_encode($this->username));
          $this->logArray['REQUEST_USER'] = $this->readResponse();
          // My password..
          $this->sendCommand(base64_encode($this->password));
          $this->logArray['REQUEST_PASSWD'] = $this->readResponse();
          // If error in response auth...
          if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
              $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
              return false;
          }
          // "From" mail...
          $this->sendCommand("MAIL FROM: {$this->from}");
          $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();
          if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
              $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
              return false;
          }
          // "To" address
          $this->sendCommand("RCPT TO: {$this->to}");
          $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();
          if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
          {
              $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
          }
          // Send data to server
          $this->sendCommand('DATA');
          $this->logArray['DATA_RESPONSE'] = $this->readResponse();
          // Send mail message
          if (!$this->sendMail()) return false;
          // Good bye server! =)
          $this->sendCommand('QUIT');
          $this->logArray['QUIT_RESPONSE'] = $this->readResponse();
          // Close smtp connect
          fclose($this->smtpConnect);
          return true;
      }
      1. private function Connect2Server() {
      2.     // Connect to server
      3.     $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);
      4.     $this->logArray['CONNECT_RESPONSE'] = $this->readResponse();
      5.  
      6.     if (!is_resource($this->smtpConnect)) {
      7.         return false;
      8.     }
      9.     $this->logArray['connection'] = "Connection accepted";
      10.     // Hi, server!
      11.     $this->sendCommand("HELLO {$this->localdomain}");
      12.     $this->logArray['HELLO'] = $this->readResponse();
      13.     // Let's know each other
      14.     $this->sendCommand('AUTH LOGIN');
      15.     $this->logArray['AUTH_REQUEST'] = $this->readResponse();
      16.     // My name...
      17.     $this->sendCommand(base64_encode($this->username));
      18.     $this->logArray['REQUEST_USER'] = $this->readResponse();
      19.     // My password..
      20.     $this->sendCommand(base64_encode($this->password));
      21.     $this->logArray['REQUEST_PASSWD'] = $this->readResponse();
      22.     // If error in response auth...
      23.     if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
      24.         $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
      25.         return false;
      26.     }
      27.     // "From" mail...
      28.     $this->sendCommand("MAIL FROM: {$this->from}");
      29.     $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();
      30.     if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
      31.         $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
      32.         return false;
      33.     }
      34.     // "To" address
      35.     $this->sendCommand("RCPT TO: {$this->to}");
      36.     $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();
      37.     if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
      38.     {
      39.         $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
      40.     }
      41.     // Send data to server
      42.     $this->sendCommand('DATA');
      43.     $this->logArray['DATA_RESPONSE'] = $this->readResponse();
      44.     // Send mail message
      45.     if (!$this->sendMail()) return false;
      46.     // Good bye server! =)
      47.     $this->sendCommand('QUIT');
      48.     $this->logArray['QUIT_RESPONSE'] = $this->readResponse();
      49.     // Close smtp connect
      50.     fclose($this->smtpConnect);
      51.     return true;
      52. }

      3.4 La función que envía


      Esta es la función que realiza el envío efectivo del mensaje de correo electrónico.
      PHP Código: [ Select ]
      private function sendMail() {

      Una vez que creamos esta función como privado.
      PHP Código: [ Select ]
          $this->sendHeaders();

      Aquí es donde iniciamos la función que crea y envía las cabeceras del mensaje de correo
      PHP Código: [ Select ]
          $this->sendCommand($this->message);
          $this->sendCommand('.');
          $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();
      1.     $this->sendCommand($this->message);
      2.     $this->sendCommand('.');
      3.     $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();

      Aquí estamos enviando los datos y el almacenamiento de la respuesta para propósitos de depuración.
      PHP Código: [ Select ]
          if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
              $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
              return false;
          }
      1.     if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
      2.         $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
      3.         return false;
      4.     }

      Aquí estamos revisando el proceso de envío para el fracaso. Si no queremos guardar el error en la variable y el retorno falsas, detener la secuencia de comandos.
      PHP Código: [ Select ]
          return true;
      }
      1.     return true;
      2. }

      Desde que llegamos a este punto, el mensaje ha sido enviado con éxito, por lo que se devuelve true para el éxito

      Aquí es que funcionan en su totalidad.
      PHP Código: [ Select ]
      private function sendMail() {
          $this->sendHeaders();
          $this->sendCommand($this->message);
          $this->sendCommand('.');
          $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();
          if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
              $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
              return false;
          }
          return true;
      }
      1. private function sendMail() {
      2.     $this->sendHeaders();
      3.     $this->sendCommand($this->message);
      4.     $this->sendCommand('.');
      5.     $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();
      6.     if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
      7.         $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
      8.         return false;
      9.     }
      10.     return true;
      11. }


      3.5 Lectura de las respuestas


      Ahora tenemos que crear una función que lee las respuestas que nos envió el servidor SMTP.
      PHP Código: [ Select ]
      // Function read response
      private function readResponse() {
      1. // Function read response
      2. private function readResponse() {

      Una vez más...función privada
      PHP Código: [ Select ]
          $data="";

      Iniciamos la variable...No se puede agregar a una variable sin que sea primera serie
      PHP Código: [ Select ]
          while($str = fgets($this->smtpConnect,4096))
          {
              $data .= $str;
              if(substr($str,3,1) == " ") { break; }
          }
      1.     while($str = fgets($this->smtpConnect,4096))
      2.     {
      3.         $data .= $str;
      4.         if(substr($str,3,1) == " ") { break; }
      5.     }

      Estamos recorriendo la respuesta y la recuperación de las respuestas
      PHP Código: [ Select ]
          return $data;
      }
      1.     return $data;
      2. }

      Estamos volviendo todas las respuestas que hemos recibido desde el servidor SMTP.

      Aquí está la función en su totalidad.
      PHP Código: [ Select ]
      // Function read response
      private function readResponse() {
          $data="";
          while($str = fgets($this->smtpConnect,4096))
          {
              $data .= $str;
              if(substr($str,3,1) == " ") { break; }
          }
          return $data;
      }
      1. // Function read response
      2. private function readResponse() {
      3.     $data="";
      4.     while($str = fgets($this->smtpConnect,4096))
      5.     {
      6.         $data .= $str;
      7.         if(substr($str,3,1) == " ") { break; }
      8.     }
      9.     return $data;
      10. }


      3.6 El envío de nuestros comandos Aquí es cuando nos mandona. Necesitamos una función para enviar a nuestros comandos en el servidor SMTP.
      PHP Código: [ Select ]
      // function send command to server
      private function sendCommand($string) {
          fputs($this->smtpConnect,$string.$this->newline);
          return ;
      }
      1. // function send command to server
      2. private function sendCommand($string) {
      3.     fputs($this->smtpConnect,$string.$this->newline);
      4.     return ;
      5. }

      Creamos una función privada, y luego enviar a nuestros comandos. Volviendo nada, ya que no hay nada para volver.

      [tuthead] 3.7 Creación de los encabezados


      Ahora tenemos que crear las cabeceras que se utilizará en ese mensaje que has enviado.
      PHP Código: [ Select ]
      private function sendHeaders() {
          $this->sendCommand("Date: ".date("D, j M Y G:i:s")." +0700");
          $this->sendCommand("From: <{$this->from}>");
          $this->sendCommand("Reply-To: <{$this->from}>");
          $this->sendCommand("To: <{$this->to}>");
          $this->sendCommand("Subject: {$this->subject}");
          $this->sendCommand("MIME-Version: 1.0");
          $this->sendCommand("Content-Type: text/html; charset={$this->charset}");
          if ($this->contentTransferEncoding) $this->sendCommand("Content-Transfer-Encoding: {$this->contentTransferEncoding}");
          return ;
      }
      1. private function sendHeaders() {
      2.     $this->sendCommand("Date: ".date("D, j M Y G:i:s")." +0700");
      3.     $this->sendCommand("From: <{$this->from}>");
      4.     $this->sendCommand("Reply-To: <{$this->from}>");
      5.     $this->sendCommand("To: <{$this->to}>");
      6.     $this->sendCommand("Subject: {$this->subject}");
      7.     $this->sendCommand("MIME-Version: 1.0");
      8.     $this->sendCommand("Content-Type: text/html; charset={$this->charset}");
      9.     if ($this->contentTransferEncoding) $this->sendCommand("Content-Transfer-Encoding: {$this->contentTransferEncoding}");
      10.     return ;
      11. }

      Aquí es que la función privada que crea los encabezados. Y no devuelve nada ya que no hay nada para volver.

      3.8 destruyendo la clase


      Ahora lo que tenemos que hacer es destruir la clase.
      PHP Código: [ Select ]
      function __destruct() {
          if (is_resource($this->smtpConnect)) fclose($this->smtpConnect);
      }
      1. function __destruct() {
      2.     if (is_resource($this->smtpConnect)) fclose($this->smtpConnect);
      3. }

      El propósito de esta función es que si en cualquier caso que la clase está parado antes de desconectar del servidor SMTP, que lo desconecte aquí.

      3. 9 La clase en él y #39; totalidad s


      Aquí está esta clase en su totalidad (Im no lo instale, ya que este foro se esta avanzada bloque contracción del código PHP).

      Vamos a guardar esta página como smtp_mail.php
      PHP Código: [ Select ]
      <?php
      class smtp_mail {
          private $smtpServer = 'smtp.gmail.com';
          private $port = '587';
          private $timeout = 30;
          private $username = 'myname@gmail.com';
          private $password = 'mypassword';
          private $username_email = 'myreceivingemail@gmail.com';
          private $newline = "\r\n";
          private $localdomain = 'http://www.mysite.com';
          private $charset = 'windows-1251';
          private $contentTransferEncoding = false;
       
          // Do not change anything below
          private $smtpConnect = false;
          private $to = false;
          private $to_admin = false;
          private $subject = false;
          private $message = false;
          private $headers = false;
          private $logArray = array(); // Array response message for debug
          private $Error = '';
          private $from = false;
       
          public function __construct($to, $subject, $message, $to_admin) {
              $this->to_admin = $to_admin;
              $this->to = (($this->to_admin === false) ? $this->username_email : $to );
              $this->from = (($this->to_admin === false) ? $to : $this->username_email );
              $this->subject = &$subject;
              $this->message = &$message;
       
              // Connect to server
              if(!$this->Connect2Server()) {
                  // Display error message
                  echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
                  print_r($this->logArray);
                  echo $this->newline.'-->'.$this->newline;
                  return false;
              }
              return true;
          }
         
          private function Connect2Server() {
              // Connect to server
              $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);
              $this->logArray['CONNECT_RESPONSE'] = $this->readResponse();
       
              if (!is_resource($this->smtpConnect)) {
                  return false;
              }
              $this->logArray['connection'] = "Connection accepted";
              // Hi, server!
              $this->sendCommand("HELLO {$this->localdomain}");
              $this->logArray['HELLO'] = $this->readResponse();
              // Let's know each other
              $this->sendCommand('AUTH LOGIN');
              $this->logArray['AUTH_REQUEST'] = $this->readResponse();
              // My name...
              $this->sendCommand(base64_encode($this->username));
              $this->logArray['REQUEST_USER'] = $this->readResponse();
              // My password..
              $this->sendCommand(base64_encode($this->password));
              $this->logArray['REQUEST_PASSWD'] = $this->readResponse();
              // If error in response auth...
              if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
                  $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
                  return false;
              }
              // "From" mail...
              $this->sendCommand("MAIL FROM: {$this->from}");
              $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();
              if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
                  $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
                  return false;
              }
              // "To" address
              $this->sendCommand("RCPT TO: {$this->to}");
              $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();
              if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
              {
                  $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
              }
              // Send data to server
              $this->sendCommand('DATA');
              $this->logArray['DATA_RESPONSE'] = $this->readResponse();
              // Send mail message
              if (!$this->sendMail()) return false;
              // Good bye server! =)
              $this->sendCommand('QUIT');
              $this->logArray['QUIT_RESPONSE'] = $this->readResponse();
              // Close smtp connect
              fclose($this->smtpConnect);
              return true;
          }
         
          private function sendMail() {
              $this->sendHeaders();
              $this->sendCommand($this->message);
              $this->sendCommand('.');
              $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();
              if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
                  $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
                  return false;
              }
              return true;
          }
         
          // Function read response
          private function readResponse() {
              $data="";
              while($str = fgets($this->smtpConnect,4096))
              {
                  $data .= $str;
                  if(substr($str,3,1) == " ") { break; }
              }
              return $data;
          }
         
          // function send command to server
          private function sendCommand($string) {
              fputs($this->smtpConnect,$string.$this->newline);
              return ;
          }
         
          // function send headers
          private function sendHeaders() {
              $this->sendCommand("Date: ".date("D, j M Y G:i:s")." +0700");
              $this->sendCommand("From: <{$this->from}>");
              $this->sendCommand("Reply-To: <{$this->from}>");
              $this->sendCommand("To: <{$this->to}>");
              $this->sendCommand("Subject: {$this->subject}");
              $this->sendCommand("MIME-Version: 1.0");
              $this->sendCommand("Content-Type: text/html; charset={$this->charset}");
              if ($this->contentTransferEncoding) $this->sendCommand("Content-Transfer-Encoding: {$this->contentTransferEncoding}");
              return ;
          }
         
          function __destruct() {
              if (is_resource($this->smtpConnect)) fclose($this->smtpConnect);
          }
      }
      ?>
      1. <?php
      2. class smtp_mail {
      3.     private $smtpServer = 'smtp.gmail.com';
      4.     private $port = '587';
      5.     private $timeout = 30;
      6.     private $username = 'myname@gmail.com';
      7.     private $password = 'mypassword';
      8.     private $username_email = 'myreceivingemail@gmail.com';
      9.     private $newline = "\r\n";
      10.     private $localdomain = 'http://www.mysite.com';
      11.     private $charset = 'windows-1251';
      12.     private $contentTransferEncoding = false;
      13.  
      14.     // Do not change anything below
      15.     private $smtpConnect = false;
      16.     private $to = false;
      17.     private $to_admin = false;
      18.     private $subject = false;
      19.     private $message = false;
      20.     private $headers = false;
      21.     private $logArray = array(); // Array response message for debug
      22.     private $Error = '';
      23.     private $from = false;
      24.  
      25.     public function __construct($to, $subject, $message, $to_admin) {
      26.         $this->to_admin = $to_admin;
      27.         $this->to = (($this->to_admin === false) ? $this->username_email : $to );
      28.         $this->from = (($this->to_admin === false) ? $to : $this->username_email );
      29.         $this->subject = &$subject;
      30.         $this->message = &$message;
      31.  
      32.         // Connect to server
      33.         if(!$this->Connect2Server()) {
      34.             // Display error message
      35.             echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
      36.             print_r($this->logArray);
      37.             echo $this->newline.'-->'.$this->newline;
      38.             return false;
      39.         }
      40.         return true;
      41.     }
      42.    
      43.     private function Connect2Server() {
      44.         // Connect to server
      45.         $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);
      46.         $this->logArray['CONNECT_RESPONSE'] = $this->readResponse();
      47.  
      48.         if (!is_resource($this->smtpConnect)) {
      49.             return false;
      50.         }
      51.         $this->logArray['connection'] = "Connection accepted";
      52.         // Hi, server!
      53.         $this->sendCommand("HELLO {$this->localdomain}");
      54.         $this->logArray['HELLO'] = $this->readResponse();
      55.         // Let's know each other
      56.         $this->sendCommand('AUTH LOGIN');
      57.         $this->logArray['AUTH_REQUEST'] = $this->readResponse();
      58.         // My name...
      59.         $this->sendCommand(base64_encode($this->username));
      60.         $this->logArray['REQUEST_USER'] = $this->readResponse();
      61.         // My password..
      62.         $this->sendCommand(base64_encode($this->password));
      63.         $this->logArray['REQUEST_PASSWD'] = $this->readResponse();
      64.         // If error in response auth...
      65.         if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
      66.             $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
      67.             return false;
      68.         }
      69.         // "From" mail...
      70.         $this->sendCommand("MAIL FROM: {$this->from}");
      71.         $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();
      72.         if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
      73.             $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
      74.             return false;
      75.         }
      76.         // "To" address
      77.         $this->sendCommand("RCPT TO: {$this->to}");
      78.         $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();
      79.         if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
      80.         {
      81.             $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
      82.         }
      83.         // Send data to server
      84.         $this->sendCommand('DATA');
      85.         $this->logArray['DATA_RESPONSE'] = $this->readResponse();
      86.         // Send mail message
      87.         if (!$this->sendMail()) return false;
      88.         // Good bye server! =)
      89.         $this->sendCommand('QUIT');
      90.         $this->logArray['QUIT_RESPONSE'] = $this->readResponse();
      91.         // Close smtp connect
      92.         fclose($this->smtpConnect);
      93.         return true;
      94.     }
      95.    
      96.     private function sendMail() {
      97.         $this->sendHeaders();
      98.         $this->sendCommand($this->message);
      99.         $this->sendCommand('.');
      100.         $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();
      101.         if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
      102.             $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
      103.             return false;
      104.         }
      105.         return true;
      106.     }
      107.    
      108.     // Function read response
      109.     private function readResponse() {
      110.         $data="";
      111.         while($str = fgets($this->smtpConnect,4096))
      112.         {
      113.             $data .= $str;
      114.             if(substr($str,3,1) == " ") { break; }
      115.         }
      116.         return $data;
      117.     }
      118.    
      119.     // function send command to server
      120.     private function sendCommand($string) {
      121.         fputs($this->smtpConnect,$string.$this->newline);
      122.         return ;
      123.     }
      124.    
      125.     // function send headers
      126.     private function sendHeaders() {
      127.         $this->sendCommand("Date: ".date("D, j M Y G:i:s")." +0700");
      128.         $this->sendCommand("From: <{$this->from}>");
      129.         $this->sendCommand("Reply-To: <{$this->from}>");
      130.         $this->sendCommand("To: <{$this->to}>");
      131.         $this->sendCommand("Subject: {$this->subject}");
      132.         $this->sendCommand("MIME-Version: 1.0");
      133.         $this->sendCommand("Content-Type: text/html; charset={$this->charset}");
      134.         if ($this->contentTransferEncoding) $this->sendCommand("Content-Transfer-Encoding: {$this->contentTransferEncoding}");
      135.         return ;
      136.     }
      137.    
      138.     function __destruct() {
      139.         if (is_resource($this->smtpConnect)) fclose($this->smtpConnect);
      140.     }
      141. }
      142. ?>


      4.0 Uso de la clase


      Ahora queremos una manera sencilla de utilizar esa clase SMTP.
      PHP Código: [ Select ]
      if(new smtp_mail($to, $subject, $message, true))
      {
          echo 'Your message has being sent successfully.';
      }
      else
      {
          echo 'There was a problem sending the message';
          // Possibly log this for your reference
      }
      1. if(new smtp_mail($to, $subject, $message, true))
      2. {
      3.     echo 'Your message has being sent successfully.';
      4. }
      5. else
      6. {
      7.     echo 'There was a problem sending the message';
      8.     // Possibly log this for your reference
      9. }

      Simple, ¿verdad?

      5. 0 La Forma


      Ahora tenemos la forma de uso que la gente va a utilizar para llenar para enviar su mensaje.

      Vamos a guardar esta página como contacto.html
      HTML Código: [ Select ]
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
      <html>
          <head>
              <title>Contact Form</title>
              <style type="text/css">
                  #contact_form {
                      width: 100%;
                  }
                 
                  .form_col {
                      float: left;
                      margin-left: 10px;
                  }
              </style>
          </head>
          <body>
              <div id="contact_form">
                  <form action="contact.php" method="post">
                      <div class="form_col">
                          <p>Name:<br>
                          Email Address:<br>
                          To:<br>
                          Subject:<br>
                          Message:</p>
                      </div>
                      <div class="form_col">
                          <p><input type="text" name="name" size="30"> Required<br>
                          <input type="text" name="email" size="30"> Required<br>
                          <input type="text" name="to" size="30"> To Administrator <input type="checkbox" name="to2"><br>
                          <input type="text" name="subject" size="30"> Required<br>
                          <textarea name="message" cols="50" rows="10"></textarea><br>
                          <input type="submit" name="submit" value="Submit"> <input type="reset" value="Reset"> The Message is Required</p>
                      </div>
                  </form>
              </div>
              <p style="clear: both;"></p>
          </body>
      </html>
      1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
      2. <html>
      3.     <head>
      4.         <title>Contact Form</title>
      5.         <style type="text/css">
      6.             #contact_form {
      7.                 width: 100%;
      8.             }
      9.            
      10.             .form_col {
      11.                 float: left;
      12.                 margin-left: 10px;
      13.             }
      14.         </style>
      15.     </head>
      16.     <body>
      17.         <div id="contact_form">
      18.             <form action="contact.php" method="post">
      19.                 <div class="form_col">
      20.                     <p>Name:<br>
      21.                     Email Address:<br>
      22.                     To:<br>
      23.                     Subject:<br>
      24.                     Message:</p>
      25.                 </div>
      26.                 <div class="form_col">
      27.                     <p><input type="text" name="name" size="30"> Required<br>
      28.                     <input type="text" name="email" size="30"> Required<br>
      29.                     <input type="text" name="to" size="30"> To Administrator <input type="checkbox" name="to2"><br>
      30.                     <input type="text" name="subject" size="30"> Required<br>
      31.                     <textarea name="message" cols="50" rows="10"></textarea><br>
      32.                     <input type="submit" name="submit" value="Submit"> <input type="reset" value="Reset"> The Message is Required</p>
      33.                 </div>
      34.             </form>
      35.         </div>
      36.         <p style="clear: both;"></p>
      37.     </body>
      38. </html>

      Eso es sólo una forma agradable de estilo para su uso con esta clase.

      5.1 El Formulario de procesador


      Ahora vamos a crear una página PHP que procesa el formulario de arriba.

      Vamos a guardar esta página como contact.php
      PHP Código: [ Select ]
      <?php
      // Checking if the form was really submitted
      if(isset($_POST['submit']))
      {
          // We need to initiate the error array
          $error = array();
         
          // Here we are checking if their name was filled in.
          if(empty($_POST['name']))
          {
              // The name field was left empty
              $error[] = "You need to enter a valid name.";
          }
         
          // Checking if a valid email address was filled in.
          if(!preg_match("/(?:[a-zA-Z0-9_\'\^\&\/\+\-])+(?:\.(?:[a-zA-Z0-9_\'\^\&\/\+\-])+)*@(?:(?:\[?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))\.){3}(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\]?)|(?:[a-zA-Z0-9-]+\.)+(?:[a-zA-Z]){2,}\.?)/", $_POST['email']))
          {
              // An invalid email address was filled in.
              $error[] = "You need to enter a valid email address.";
          }
         
          // We need to determine the recipient of the message
          if(isset($_POST['to_admin']))
          {
              // Even if the to field was given a different email address, this would over-ride that address and be sent to admin.
              $to_admin = true;
              $to = false;
          }
          elseif(preg_match("/(?:[a-zA-Z0-9_\'\^\&\/\+\-])+(?:\.(?:[a-zA-Z0-9_\'\^\&\/\+\-])+)*@(?:(?:\[?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))\.){3}(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\]?)|(?:[a-zA-Z0-9-]+\.)+(?:[a-zA-Z]){2,}\.?)/", $_POST['to']))
          {
              // If the process reaches here, then the message would be sent to the address put in the to field
              $to_admin = false;
              $to = $_POST['to'];
          }
          else
          {
              // There was an error... it's not sent to the admin OR to anyone...
              $error[] = "You need a valid recipient's (to) email address.";
          }
         
          // Now we need to validate the subject of the message
          if(strlen($_POST['subject']) < 5)
          {
              // The message is under 5 characters.
              $error[] = "The subject needs to be greater then 5 characters";
          }
         
          // Validating the actuall message
          if(strlen($_POST['message']) < 5)
          {
              $error[] = "The message needs to be greater then 5 characters";
          }
         
          // Counting the number of errors there was in the form submittion
          if(count($error) > 0)
          {
              // There were errors... we can't send a message with errors in the form submittion.
             
              // Looping through each error and providing a good list of errors for the user.
              $errors = "<ol>";
              foreach($error as $er)
              {
                  $errors .= "<li>{$er}</li>\n";
              }
              $errors .= "</ol>";
             
              echo $errors;
          }
          else
          {
              // There were no errors, lets submit the actual message
              if(new smtp_mail($to, $_POST['subject'], $_POST['message'], $to_admin))
              {
                  echo "The mail was sent successfully.";
              }
              else
              {
                  echo "There was a problem sending the message.";
              }
          }
      }
      ?>
      1. <?php
      2. // Checking if the form was really submitted
      3. if(isset($_POST['submit']))
      4. {
      5.     // We need to initiate the error array
      6.     $error = array();
      7.    
      8.     // Here we are checking if their name was filled in.
      9.     if(empty($_POST['name']))
      10.     {
      11.         // The name field was left empty
      12.         $error[] = "You need to enter a valid name.";
      13.     }
      14.    
      15.     // Checking if a valid email address was filled in.
      16.     if(!preg_match("/(?:[a-zA-Z0-9_\'\^\&\/\+\-])+(?:\.(?:[a-zA-Z0-9_\'\^\&\/\+\-])+)*@(?:(?:\[?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))\.){3}(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\]?)|(?:[a-zA-Z0-9-]+\.)+(?:[a-zA-Z]){2,}\.?)/", $_POST['email']))
      17.     {
      18.         // An invalid email address was filled in.
      19.         $error[] = "You need to enter a valid email address.";
      20.     }
      21.    
      22.     // We need to determine the recipient of the message
      23.     if(isset($_POST['to_admin']))
      24.     {
      25.         // Even if the to field was given a different email address, this would over-ride that address and be sent to admin.
      26.         $to_admin = true;
      27.         $to = false;
      28.     }
      29.     elseif(preg_match("/(?:[a-zA-Z0-9_\'\^\&\/\+\-])+(?:\.(?:[a-zA-Z0-9_\'\^\&\/\+\-])+)*@(?:(?:\[?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))\.){3}(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\]?)|(?:[a-zA-Z0-9-]+\.)+(?:[a-zA-Z]){2,}\.?)/", $_POST['to']))
      30.     {
      31.         // If the process reaches here, then the message would be sent to the address put in the to field
      32.         $to_admin = false;
      33.         $to = $_POST['to'];
      34.     }
      35.     else
      36.     {
      37.         // There was an error... it's not sent to the admin OR to anyone...
      38.         $error[] = "You need a valid recipient's (to) email address.";
      39.     }
      40.    
      41.     // Now we need to validate the subject of the message
      42.     if(strlen($_POST['subject']) < 5)
      43.     {
      44.         // The message is under 5 characters.
      45.         $error[] = "The subject needs to be greater then 5 characters";
      46.     }
      47.    
      48.     // Validating the actuall message
      49.     if(strlen($_POST['message']) < 5)
      50.     {
      51.         $error[] = "The message needs to be greater then 5 characters";
      52.     }
      53.    
      54.     // Counting the number of errors there was in the form submittion
      55.     if(count($error) > 0)
      56.     {
      57.         // There were errors... we can't send a message with errors in the form submittion.
      58.        
      59.         // Looping through each error and providing a good list of errors for the user.
      60.         $errors = "<ol>";
      61.         foreach($error as $er)
      62.         {
      63.             $errors .= "<li>{$er}</li>\n";
      64.         }
      65.         $errors .= "</ol>";
      66.        
      67.         echo $errors;
      68.     }
      69.     else
      70.     {
      71.         // There were no errors, lets submit the actual message
      72.         if(new smtp_mail($to, $_POST['subject'], $_POST['message'], $to_admin))
      73.         {
      74.             echo "The mail was sent successfully.";
      75.         }
      76.         else
      77.         {
      78.             echo "There was a problem sending the message.";
      79.         }
      80.     }
      81. }
      82. ?>


      5. 2 La función mágica


      Esto no es necesario, pero esto es lo que yo siempre uso para la enfermedad lo propone aquí.

      Yo siempre uso la función mágica __autoload () para cargar las clases. Esto me ahorra una línea cada vez que quiero usar una clase. De esta manera, no tiene que incluir el archivo PHP que contiene la clase...que __autoload () s.

      Con el fin de que funcione correctamente, el archivo PHP necesita para ser salvo de la misma manera que la clase se llama...por lo que en este caso, el nombre de clase es smtp_mail y su guarda como smtp_mail.php. Así que aquí está esa función.
      PHP Código: [ Select ]
      function __autoload($class_name) {
          if(file_exists('includes/' . $class_name . '.php'))
          {
              require_once 'includes/' . $class_name . '.php';
          }
      }
      1. function __autoload($class_name) {
      2.     if(file_exists('includes/' . $class_name . '.php'))
      3.     {
      4.         require_once 'includes/' . $class_name . '.php';
      5.     }
      6. }

      Lo que tengo esta función hacer es comprobar si la página existe en el includes / de la guía...esto significa, que cuando me pongo esta clase sería buscar [/ b] includes / smtp_mail.php [/ b].

      Esto significa que la estructura de la guía debe ser similar a lo siguiente:
      • includes / smtp_mail.php
      • contacto.html
      • contact.php

      Otra cosa que yo recomendaría hacer es tener una página global que se incluirá en todas las páginas todo el tiempo. Echa un vistazo a este tutorial para entender más de lo que estoy hablando aquí.

      En este archivo de configuración, se ponga esta función en la magia. Si ese consejo es entran en juego aquí, entonces la estructura de directorios que cambia a:

      • includes / smtp_mail.php
      • includes / config.php
      • contacto.html
      • de contacto. php

      Por lo tanto, si nos fijamos en la línea donde se incluiría la clase smtp_mail (en contact.php):
      PHP Código: [ Select ]
              if(new smtp_mail($to, $_POST['subject'], $_POST['message'], $to_admin))

      Usted ve que sus instancias de un objeto nuevo "smtp_mail" sin mí incluyendo smtp_mail.php. Cuando el intérprete PHP llega a esta línea sería tratar de incluir includes / smtp_mail.php para poder crear una instancia del objeto. Esta es la belleza de las funciones de magia.

      Si no desea utilizar la función de magia, simplemente incluya smtp_mail. php en contact.php. Recuerde que debe incluir el derecho smtp_mail.php antes de la línea que utiliza esta función. (El código PHP bloque de la derecha por encima de este).
      PHP Código: [ Select ]
      include_once 'includes/smtp_mail.php';


      6.0 Conclusión


      Es (en la mayoría de los casos) tienen un valor incalculable para una forma de enviar mensajes de correo electrónico a sus usuarios, ya sea para boletines de noticias o actualizaciones o simplemente lo que usted necesita para enviar un mensaje para, ahora tiene una forma bastante avanzada de enviar mensajes con un SMTP servidor.
"Bring forth therefore fruits meet for repentance:" Matthew 3:8
  • Anonymous
  • Bot
  • No Avatar
  • Registrado: 25 Feb 2008
  • Mensajes: ?
  • Loc: Ozzuland
  • Status: Online

Nota Septiembre 27th, 2010, 11:45 pm

  • Bogey
  • Bogey
  • Genius
  • Avatar de Usuario
  • Registrado: Jul 14, 2005
  • Mensajes: 8211
  • Loc: USA
  • Status: Offline

Nota Noviembre 17th, 2010, 1:06 pm

Acabo de encontrar donde lo ha recibido...

phpclasses.org página de clase
"Bring forth therefore fruits meet for repentance:" Matthew 3:8
  • Mark709
  • Novice
  • Novice
  • No Avatar
  • Registrado: Sep 30, 2010
  • Mensajes: 22
  • Status: Offline

Nota Enero 27th, 2011, 8:35 pm

Hay que decir este artículo es maravilloso - por desgracia yo no soy más que un principiante sin embargo, incluso puedo ver que si lo estudio mucho beneficio vendrá a mí - así que gracias por sus esfuerzos y desplazamiento para todos nosotros.
  • spork
  • Brewmaster
  • Silver Member
  • Avatar de Usuario
  • Registrado: Sep 22, 2003
  • Mensajes: 6130
  • Loc: Seattle, WA
  • Status: Offline

Nota Enero 28th, 2011, 10:53 am

No creo que entiendo muy bien el propósito de constructores y destructores en este tutorial. Los constructores son llamados cada vez que un objeto se crea uno nuevo, su propósito es inicializar los miembros de datos y configurar el objeto de ser utilizados por la persona que llama. Nunca debe usted volver cualquier cosa, desde un constructor, la naturaleza de la función es la de devolver el objeto se está creando.

El otro problema es que está utilizando la creación de objetos como una llamada al método, cuando en realidad debe ser debidamente la construcción del objeto y a continuación, permitiendo que la persona que llama a tomar medidas con él. Invocando el mail () la funcionalidad en tiempo de creación de instancias no es correcto, yo debería ser capaz de crear un objeto smtp_mail y elija cuando el correo es enviado.

El propósito de un destructor es no tomar medidas "en caso de que se interrumpe la clase", las clases no se puede "parar" o "ir" (hilos y procesos, pero eso es otro tema). El propósito del destructor es limpiar después de que el objeto cuando se suprime, ya sea directamente o se sale del ámbito de aplicación (o en el caso de los lenguajes administrados, cuando se pone recolector de basura).

También veo trozos de HTML y las llamadas a funciones de salida diferentes llena toda la clase, que bien pareja la clase a cualquier aplicación que el usuario piensa que el uso in Sería mejor para permitir al usuario para leer y actualizar los resultados a través de acceso y mutadores de tal manera que la aplicación que utiliza esta clase puede dar salida a los datos que estime conveniente.

Para esta clase para ser útil en una aplicación, ésta debe cumplir con una interfaz que me permita utilizar de esta manera:

PHP Código: [ Select ]
<?php
 
$myMailer = new SmtpMailer(new SmtpMailerCredentials(...));
 
// a class such as SmtpMailerCredentials could help
// organize and decouple the non-essential aspects of
// the mail from the mailer class
 
// don't assume only one recipient
$myMailer->addToAddress("someone@domain.com");
$myMailer->addToAddress("someoneelse@domain.com");
 
// ...and don't assume everyone will be on the "to" line!
$myMailer->addCcAddress("athirdperson@domain.com");
 
$myMailer->setSubject("This is a test message");
$myMailer->setBody("This is the body of the message.");
 
// do some other stuff. perhaps add this mailer
// object to a queue of mail to be sent, or do
// whatever else I need to do before the email goes out
 
// now I choose exactly when to send the mail
$mailer->send();
 
?<
  1. <?php
  2.  
  3. $myMailer = new SmtpMailer(new SmtpMailerCredentials(...));
  4.  
  5. // a class such as SmtpMailerCredentials could help
  6. // organize and decouple the non-essential aspects of
  7. // the mail from the mailer class
  8.  
  9. // don't assume only one recipient
  10. $myMailer->addToAddress("someone@domain.com");
  11. $myMailer->addToAddress("someoneelse@domain.com");
  12.  
  13. // ...and don't assume everyone will be on the "to" line!
  14. $myMailer->addCcAddress("athirdperson@domain.com");
  15.  
  16. $myMailer->setSubject("This is a test message");
  17. $myMailer->setBody("This is the body of the message.");
  18.  
  19. // do some other stuff. perhaps add this mailer
  20. // object to a queue of mail to be sent, or do
  21. // whatever else I need to do before the email goes out
  22.  
  23. // now I choose exactly when to send the mail
  24. $mailer->send();
  25.  
  26. ?<
The Beer Monocle. Classy.
  • Bogey
  • Bogey
  • Genius
  • Avatar de Usuario
  • Registrado: Jul 14, 2005
  • Mensajes: 8211
  • Loc: USA
  • Status: Offline

Nota Enero 28th, 2011, 9:22 pm

Gracias por la Spork revisión. Yo como que recordar la creación de la clase a partir de una mezcla de código escrito como una función (que podría haber confundido esta clase por otra). Me acaba de encontrar en mi directorio de depósito de clase en mi equipo y ya que funciona perfectamente para mí (que sólo puede hacer clases para principiantes de trabajo :lol: Yo no estoy tan avanzado gif "alt = =":(" título de" triste "> ) Así que decidí hacer una caminata a través de tutorías.

Malos arreglarlo pronto, aunque para cumplir con su interfaz y sugirió cambiar algunos trozos de código para solucionar los problemas que usted envió. Gracias por el heads-up.
"Bring forth therefore fruits meet for repentance:" Matthew 3:8
  • pagebot
  • Novice
  • Novice
  • No Avatar
  • Registrado: Nov 17, 2010
  • Mensajes: 16
  • Loc: USA
  • Status: Offline

Nota Abril 13th, 2011, 6:19 pm

Muy buen tutorial, puedo enviar archivos adjuntos de esta manera y cómo puedo bloquear ciertas extensiones? Gracias
  • Mark709
  • Novice
  • Novice
  • No Avatar
  • Registrado: Sep 30, 2010
  • Mensajes: 22
  • Status: Offline

Nota Abril 17th, 2011, 7:59 pm

Revisar este artículo de Bogey todavía me doy cuenta de lo afortunados que somos de tener miembros como Bogey y Spork y otros (sin nombre) que se han preocupado por los demás a escribir como un BIEN - artículo CONSTRUIDOS y clara.

Si usted tiene el tiempo podría también considerar - como - cómo usar el código anterior y INSERT - una capacidad para ejecutar este como
1. una tarea de cron
2. enviar un correo electrónico cada 10 segundos
y / o (lo que es la menor - importante como servidor necesita cambiar de un host a otro Co)
3. un máximo de...correos electrónicos por hora

RAZÓN - hay muchos usuarios, muchos de los que están continuamente con problemas en torno a estos tres elementos y hasta ahora no he visto una explicación clara de la manera de conseguir alrededor de los problemas que muchos se quejan de sus paradas cron (a decir de 500 correos electrónicos en los primeros hora) cuando dicen que su trabajo consiste en enviar mensajes de correo electrónico 5000 - su situación es como volver a empezar sin hacer y envío de los primeros 500 correos electrónicos por segunda vez.

Agradecería sus ideas sobre cómo solucionar este tipo de cuestiones y muchas gracias por las explicaciones de la serie de sesiones de cada uno - usted es un gran maestro y ejemplo para nosotros "novatos"

Página 1 de 1

Publicar Información

  • Total de mensajes en este tema: 8 mensajes
  • Moderador: Tutorial Writers
  • Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 2 invitados
  • No puede abrir nuevos temas en este Foro
  • No puede responder a temas en este Foro
  • No puede editar sus mensajes en este Foro
  • No puede borrar sus mensajes en este Foro
  • No puede enviar adjuntos en este Foro
 
 

© 2011 Unmelted, LLC. Ozzu® es una marca registrada de Unmelted, LLC