]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - extlib/Net/SMTP.php
define Reply::pkeyGet()
[quix0rs-gnu-social.git] / extlib / Net / SMTP.php
1 <?php
2 /* vim: set expandtab softtabstop=4 tabstop=4 shiftwidth=4: */
3 // +----------------------------------------------------------------------+
4 // | PHP Version 4                                                        |
5 // +----------------------------------------------------------------------+
6 // | Copyright (c) 1997-2003 The PHP Group                                |
7 // +----------------------------------------------------------------------+
8 // | This source file is subject to version 2.02 of the PHP license,      |
9 // | that is bundled with this package in the file LICENSE, and is        |
10 // | available at through the world-wide-web at                           |
11 // | http://www.php.net/license/2_02.txt.                                 |
12 // | If you did not receive a copy of the PHP license and are unable to   |
13 // | obtain it through the world-wide-web, please send a note to          |
14 // | license@php.net so we can mail you a copy immediately.               |
15 // +----------------------------------------------------------------------+
16 // | Authors: Chuck Hagenbuch <chuck@horde.org>                           |
17 // |          Jon Parise <jon@php.net>                                    |
18 // |          Damian Alejandro Fernandez Sosa <damlists@cnba.uba.ar>      |
19 // +----------------------------------------------------------------------+
20 //
21 // $Id: SMTP.php 293948 2010-01-24 21:46:00Z jon $
22
23 require_once 'PEAR.php';
24 require_once 'Net/Socket.php';
25
26 /**
27  * Provides an implementation of the SMTP protocol using PEAR's
28  * Net_Socket:: class.
29  *
30  * @package Net_SMTP
31  * @author  Chuck Hagenbuch <chuck@horde.org>
32  * @author  Jon Parise <jon@php.net>
33  * @author  Damian Alejandro Fernandez Sosa <damlists@cnba.uba.ar>
34  *
35  * @example basic.php   A basic implementation of the Net_SMTP package.
36  */
37 class Net_SMTP
38 {
39     /**
40      * The server to connect to.
41      * @var string
42      * @access public
43      */
44     var $host = 'localhost';
45
46     /**
47      * The port to connect to.
48      * @var int
49      * @access public
50      */
51     var $port = 25;
52
53     /**
54      * The value to give when sending EHLO or HELO.
55      * @var string
56      * @access public
57      */
58     var $localhost = 'localhost';
59
60     /**
61      * List of supported authentication methods, in preferential order.
62      * @var array
63      * @access public
64      */
65     var $auth_methods = array('DIGEST-MD5', 'CRAM-MD5', 'LOGIN', 'PLAIN');
66
67     /**
68      * Use SMTP command pipelining (specified in RFC 2920) if the SMTP
69      * server supports it.
70      *
71      * When pipeling is enabled, rcptTo(), mailFrom(), sendFrom(),
72      * somlFrom() and samlFrom() do not wait for a response from the
73      * SMTP server but return immediately.
74      *
75      * @var bool
76      * @access public
77      */
78     var $pipelining = false;
79
80     /**
81      * Number of pipelined commands.
82      * @var int
83      * @access private
84      */
85     var $_pipelined_commands = 0;
86
87     /**
88      * Should debugging output be enabled?
89      * @var boolean
90      * @access private
91      */
92     var $_debug = false;
93
94     /**
95      * Debug output handler.
96      * @var callback
97      * @access private
98      */
99     var $_debug_handler = null;
100
101     /**
102      * The socket resource being used to connect to the SMTP server.
103      * @var resource
104      * @access private
105      */
106     var $_socket = null;
107
108     /**
109      * The most recent server response code.
110      * @var int
111      * @access private
112      */
113     var $_code = -1;
114
115     /**
116      * The most recent server response arguments.
117      * @var array
118      * @access private
119      */
120     var $_arguments = array();
121
122     /**
123      * Stores the SMTP server's greeting string.
124      * @var string
125      * @access private
126      */
127     var $_greeting = null;
128
129     /**
130      * Stores detected features of the SMTP server.
131      * @var array
132      * @access private
133      */
134     var $_esmtp = array();
135
136     /**
137      * Instantiates a new Net_SMTP object, overriding any defaults
138      * with parameters that are passed in.
139      *
140      * If you have SSL support in PHP, you can connect to a server
141      * over SSL using an 'ssl://' prefix:
142      *
143      *   // 465 is a common smtps port.
144      *   $smtp = new Net_SMTP('ssl://mail.host.com', 465);
145      *   $smtp->connect();
146      *
147      * @param string  $host       The server to connect to.
148      * @param integer $port       The port to connect to.
149      * @param string  $localhost  The value to give when sending EHLO or HELO.
150      * @param boolean $pipeling   Use SMTP command pipelining
151      *
152      * @access  public
153      * @since   1.0
154      */
155     function Net_SMTP($host = null, $port = null, $localhost = null, $pipelining = false)
156     {
157         if (isset($host)) {
158             $this->host = $host;
159         }
160         if (isset($port)) {
161             $this->port = $port;
162         }
163         if (isset($localhost)) {
164             $this->localhost = $localhost;
165         }
166         $this->pipelining = $pipelining;
167
168         $this->_socket = new Net_Socket();
169
170         /* Include the Auth_SASL package.  If the package is not
171          * available, we disable the authentication methods that
172          * depend upon it. */
173         if ((@include_once 'Auth/SASL.php') === false) {
174             $pos = array_search('DIGEST-MD5', $this->auth_methods);
175             unset($this->auth_methods[$pos]);
176             $pos = array_search('CRAM-MD5', $this->auth_methods);
177             unset($this->auth_methods[$pos]);
178         }
179     }
180
181     /**
182      * Set the value of the debugging flag.
183      *
184      * @param   boolean $debug      New value for the debugging flag.
185      *
186      * @access  public
187      * @since   1.1.0
188      */
189     function setDebug($debug, $handler = null)
190     {
191         $this->_debug = $debug;
192         $this->_debug_handler = $handler;
193     }
194
195     /**
196      * Write the given debug text to the current debug output handler.
197      *
198      * @param   string  $message    Debug mesage text.
199      *
200      * @access  private
201      * @since   1.3.3
202      */
203     function _debug($message)
204     {
205         if ($this->_debug) {
206             if ($this->_debug_handler) {
207                 call_user_func_array($this->_debug_handler,
208                                      array(&$this, $message));
209             } else {
210                 echo "DEBUG: $message\n";
211             }
212         }
213     }
214
215     /**
216      * Send the given string of data to the server.
217      *
218      * @param   string  $data       The string of data to send.
219      *
220      * @return  mixed   True on success or a PEAR_Error object on failure.
221      *
222      * @access  private
223      * @since   1.1.0
224      */
225     function _send($data)
226     {
227         $this->_debug("Send: $data");
228
229         $error = $this->_socket->write($data);
230         if ($error === false || PEAR::isError($error)) {
231             $msg = ($error) ? $error->getMessage() : "unknown error";
232             return PEAR::raiseError("Failed to write to socket: $msg");
233         }
234
235         return true;
236     }
237
238     /**
239      * Send a command to the server with an optional string of
240      * arguments.  A carriage return / linefeed (CRLF) sequence will
241      * be appended to each command string before it is sent to the
242      * SMTP server - an error will be thrown if the command string
243      * already contains any newline characters. Use _send() for
244      * commands that must contain newlines.
245      *
246      * @param   string  $command    The SMTP command to send to the server.
247      * @param   string  $args       A string of optional arguments to append
248      *                              to the command.
249      *
250      * @return  mixed   The result of the _send() call.
251      *
252      * @access  private
253      * @since   1.1.0
254      */
255     function _put($command, $args = '')
256     {
257         if (!empty($args)) {
258             $command .= ' ' . $args;
259         }
260
261         if (strcspn($command, "\r\n") !== strlen($command)) {
262             return PEAR::raiseError('Commands cannot contain newlines');
263         }
264
265         return $this->_send($command . "\r\n");
266     }
267
268     /**
269      * Read a reply from the SMTP server.  The reply consists of a response
270      * code and a response message.
271      *
272      * @param   mixed   $valid      The set of valid response codes.  These
273      *                              may be specified as an array of integer
274      *                              values or as a single integer value.
275      * @param   bool    $later      Do not parse the response now, but wait
276      *                              until the last command in the pipelined
277      *                              command group
278      *
279      * @return  mixed   True if the server returned a valid response code or
280      *                  a PEAR_Error object is an error condition is reached.
281      *
282      * @access  private
283      * @since   1.1.0
284      *
285      * @see     getResponse
286      */
287     function _parseResponse($valid, $later = false)
288     {
289         $this->_code = -1;
290         $this->_arguments = array();
291
292         if ($later) {
293             $this->_pipelined_commands++;
294             return true;
295         }
296
297         for ($i = 0; $i <= $this->_pipelined_commands; $i++) {
298             while ($line = $this->_socket->readLine()) {
299                 $this->_debug("Recv: $line");
300
301                 /* If we receive an empty line, the connection has been closed. */
302                 if (empty($line)) {
303                     $this->disconnect();
304                     return PEAR::raiseError('Connection was unexpectedly closed');
305                 }
306
307                 /* Read the code and store the rest in the arguments array. */
308                 $code = substr($line, 0, 3);
309                 $this->_arguments[] = trim(substr($line, 4));
310
311                 /* Check the syntax of the response code. */
312                 if (is_numeric($code)) {
313                     $this->_code = (int)$code;
314                 } else {
315                     $this->_code = -1;
316                     break;
317                 }
318
319                 /* If this is not a multiline response, we're done. */
320                 if (substr($line, 3, 1) != '-') {
321                     break;
322                 }
323             }
324         }
325
326         $this->_pipelined_commands = 0;
327
328         /* Compare the server's response code with the valid code/codes. */
329         if (is_int($valid) && ($this->_code === $valid)) {
330             return true;
331         } elseif (is_array($valid) && in_array($this->_code, $valid, true)) {
332             return true;
333         }
334
335         return PEAR::raiseError('Invalid response code received from server',
336                                 $this->_code);
337     }
338
339     /**
340      * Return a 2-tuple containing the last response from the SMTP server.
341      *
342      * @return  array   A two-element array: the first element contains the
343      *                  response code as an integer and the second element
344      *                  contains the response's arguments as a string.
345      *
346      * @access  public
347      * @since   1.1.0
348      */
349     function getResponse()
350     {
351         return array($this->_code, join("\n", $this->_arguments));
352     }
353
354     /**
355      * Return the SMTP server's greeting string.
356      *
357      * @return  string  A string containing the greeting string, or null if a 
358      *                  greeting has not been received.
359      *
360      * @access  public
361      * @since   1.3.3
362      */
363     function getGreeting()
364     {
365         return $this->_greeting;
366     }
367
368     /**
369      * Attempt to connect to the SMTP server.
370      *
371      * @param   int     $timeout    The timeout value (in seconds) for the
372      *                              socket connection.
373      * @param   bool    $persistent Should a persistent socket connection
374      *                              be used?
375      *
376      * @return mixed Returns a PEAR_Error with an error message on any
377      *               kind of failure, or true on success.
378      * @access public
379      * @since  1.0
380      */
381     function connect($timeout = null, $persistent = false)
382     {
383         $this->_greeting = null;
384         $result = $this->_socket->connect($this->host, $this->port,
385                                           $persistent, $timeout);
386         if (PEAR::isError($result)) {
387             return PEAR::raiseError('Failed to connect socket: ' .
388                                     $result->getMessage());
389         }
390
391         if (PEAR::isError($error = $this->_parseResponse(220))) {
392             return $error;
393         }
394
395         /* Extract and store a copy of the server's greeting string. */
396         list(, $this->_greeting) = $this->getResponse();
397
398         if (PEAR::isError($error = $this->_negotiate())) {
399             return $error;
400         }
401
402         return true;
403     }
404
405     /**
406      * Attempt to disconnect from the SMTP server.
407      *
408      * @return mixed Returns a PEAR_Error with an error message on any
409      *               kind of failure, or true on success.
410      * @access public
411      * @since  1.0
412      */
413     function disconnect()
414     {
415         if (PEAR::isError($error = $this->_put('QUIT'))) {
416             return $error;
417         }
418         if (PEAR::isError($error = $this->_parseResponse(221))) {
419             return $error;
420         }
421         if (PEAR::isError($error = $this->_socket->disconnect())) {
422             return PEAR::raiseError('Failed to disconnect socket: ' .
423                                     $error->getMessage());
424         }
425
426         return true;
427     }
428
429     /**
430      * Attempt to send the EHLO command and obtain a list of ESMTP
431      * extensions available, and failing that just send HELO.
432      *
433      * @return mixed Returns a PEAR_Error with an error message on any
434      *               kind of failure, or true on success.
435      *
436      * @access private
437      * @since  1.1.0
438      */
439     function _negotiate()
440     {
441         if (PEAR::isError($error = $this->_put('EHLO', $this->localhost))) {
442             return $error;
443         }
444
445         if (PEAR::isError($this->_parseResponse(250))) {
446             /* If we receive a 503 response, we're already authenticated. */
447             if ($this->_code === 503) {
448                 return true;
449             }
450
451             /* If the EHLO failed, try the simpler HELO command. */
452             if (PEAR::isError($error = $this->_put('HELO', $this->localhost))) {
453                 return $error;
454             }
455             if (PEAR::isError($this->_parseResponse(250))) {
456                 return PEAR::raiseError('HELO was not accepted: ', $this->_code);
457             }
458
459             return true;
460         }
461
462         foreach ($this->_arguments as $argument) {
463             $verb = strtok($argument, ' ');
464             $arguments = substr($argument, strlen($verb) + 1,
465                                 strlen($argument) - strlen($verb) - 1);
466             $this->_esmtp[$verb] = $arguments;
467         }
468
469         if (!isset($this->_esmtp['PIPELINING'])) {
470             $this->pipelining = false;
471         }
472
473         return true;
474     }
475
476     /**
477      * Returns the name of the best authentication method that the server
478      * has advertised.
479      *
480      * @return mixed    Returns a string containing the name of the best
481      *                  supported authentication method or a PEAR_Error object
482      *                  if a failure condition is encountered.
483      * @access private
484      * @since  1.1.0
485      */
486     function _getBestAuthMethod()
487     {
488         $available_methods = explode(' ', $this->_esmtp['AUTH']);
489
490         foreach ($this->auth_methods as $method) {
491             if (in_array($method, $available_methods)) {
492                 return $method;
493             }
494         }
495
496         return PEAR::raiseError('No supported authentication methods');
497     }
498
499     /**
500      * Attempt to do SMTP authentication.
501      *
502      * @param string The userid to authenticate as.
503      * @param string The password to authenticate with.
504      * @param string The requested authentication method.  If none is
505      *               specified, the best supported method will be used.
506      * @param bool   Flag indicating whether or not TLS should be attempted.
507      *
508      * @return mixed Returns a PEAR_Error with an error message on any
509      *               kind of failure, or true on success.
510      * @access public
511      * @since  1.0
512      */
513     function auth($uid, $pwd , $method = '', $tls = true)
514     {
515         /* We can only attempt a TLS connection if one has been requested,
516          * we're running PHP 5.1.0 or later, have access to the OpenSSL 
517          * extension, are connected to an SMTP server which supports the 
518          * STARTTLS extension, and aren't already connected over a secure 
519          * (SSL) socket connection. */
520         if ($tls && version_compare(PHP_VERSION, '5.1.0', '>=') &&
521             extension_loaded('openssl') && isset($this->_esmtp['STARTTLS']) &&
522             strncasecmp($this->host, 'ssl://', 6) !== 0) {
523             /* Start the TLS connection attempt. */
524             if (PEAR::isError($result = $this->_put('STARTTLS'))) {
525                 return $result;
526             }
527             if (PEAR::isError($result = $this->_parseResponse(220))) {
528                 return $result;
529             }
530             if (PEAR::isError($result = $this->_socket->enableCrypto(true, STREAM_CRYPTO_METHOD_TLS_CLIENT))) {
531                 return $result;
532             } elseif ($result !== true) {
533                 return PEAR::raiseError('STARTTLS failed');
534             }
535
536             /* Send EHLO again to recieve the AUTH string from the
537              * SMTP server. */
538             $this->_negotiate();
539         }
540
541         if (empty($this->_esmtp['AUTH'])) {
542             return PEAR::raiseError('SMTP server does not support authentication');
543         }
544
545         /* If no method has been specified, get the name of the best
546          * supported method advertised by the SMTP server. */
547         if (empty($method)) {
548             if (PEAR::isError($method = $this->_getBestAuthMethod())) {
549                 /* Return the PEAR_Error object from _getBestAuthMethod(). */
550                 return $method;
551             }
552         } else {
553             $method = strtoupper($method);
554             if (!in_array($method, $this->auth_methods)) {
555                 return PEAR::raiseError("$method is not a supported authentication method");
556             }
557         }
558
559         switch ($method) {
560         case 'DIGEST-MD5':
561             $result = $this->_authDigest_MD5($uid, $pwd);
562             break;
563
564         case 'CRAM-MD5':
565             $result = $this->_authCRAM_MD5($uid, $pwd);
566             break;
567
568         case 'LOGIN':
569             $result = $this->_authLogin($uid, $pwd);
570             break;
571
572         case 'PLAIN':
573             $result = $this->_authPlain($uid, $pwd);
574             break;
575
576         default:
577             $result = PEAR::raiseError("$method is not a supported authentication method");
578             break;
579         }
580
581         /* If an error was encountered, return the PEAR_Error object. */
582         if (PEAR::isError($result)) {
583             return $result;
584         }
585
586         return true;
587     }
588
589     /**
590      * Authenticates the user using the DIGEST-MD5 method.
591      *
592      * @param string The userid to authenticate as.
593      * @param string The password to authenticate with.
594      *
595      * @return mixed Returns a PEAR_Error with an error message on any
596      *               kind of failure, or true on success.
597      * @access private
598      * @since  1.1.0
599      */
600     function _authDigest_MD5($uid, $pwd)
601     {
602         if (PEAR::isError($error = $this->_put('AUTH', 'DIGEST-MD5'))) {
603             return $error;
604         }
605         /* 334: Continue authentication request */
606         if (PEAR::isError($error = $this->_parseResponse(334))) {
607             /* 503: Error: already authenticated */
608             if ($this->_code === 503) {
609                 return true;
610             }
611             return $error;
612         }
613
614         $challenge = base64_decode($this->_arguments[0]);
615         $digest = &Auth_SASL::factory('digestmd5');
616         $auth_str = base64_encode($digest->getResponse($uid, $pwd, $challenge,
617                                                        $this->host, "smtp"));
618
619         if (PEAR::isError($error = $this->_put($auth_str))) {
620             return $error;
621         }
622         /* 334: Continue authentication request */
623         if (PEAR::isError($error = $this->_parseResponse(334))) {
624             return $error;
625         }
626
627         /* We don't use the protocol's third step because SMTP doesn't
628          * allow subsequent authentication, so we just silently ignore
629          * it. */
630         if (PEAR::isError($error = $this->_put(''))) {
631             return $error;
632         }
633         /* 235: Authentication successful */
634         if (PEAR::isError($error = $this->_parseResponse(235))) {
635             return $error;
636         }
637     }
638
639     /**
640      * Authenticates the user using the CRAM-MD5 method.
641      *
642      * @param string The userid to authenticate as.
643      * @param string The password to authenticate with.
644      *
645      * @return mixed Returns a PEAR_Error with an error message on any
646      *               kind of failure, or true on success.
647      * @access private
648      * @since  1.1.0
649      */
650     function _authCRAM_MD5($uid, $pwd)
651     {
652         if (PEAR::isError($error = $this->_put('AUTH', 'CRAM-MD5'))) {
653             return $error;
654         }
655         /* 334: Continue authentication request */
656         if (PEAR::isError($error = $this->_parseResponse(334))) {
657             /* 503: Error: already authenticated */
658             if ($this->_code === 503) {
659                 return true;
660             }
661             return $error;
662         }
663
664         $challenge = base64_decode($this->_arguments[0]);
665         $cram = &Auth_SASL::factory('crammd5');
666         $auth_str = base64_encode($cram->getResponse($uid, $pwd, $challenge));
667
668         if (PEAR::isError($error = $this->_put($auth_str))) {
669             return $error;
670         }
671
672         /* 235: Authentication successful */
673         if (PEAR::isError($error = $this->_parseResponse(235))) {
674             return $error;
675         }
676     }
677
678     /**
679      * Authenticates the user using the LOGIN method.
680      *
681      * @param string The userid to authenticate as.
682      * @param string The password to authenticate with.
683      *
684      * @return mixed Returns a PEAR_Error with an error message on any
685      *               kind of failure, or true on success.
686      * @access private
687      * @since  1.1.0
688      */
689     function _authLogin($uid, $pwd)
690     {
691         if (PEAR::isError($error = $this->_put('AUTH', 'LOGIN'))) {
692             return $error;
693         }
694         /* 334: Continue authentication request */
695         if (PEAR::isError($error = $this->_parseResponse(334))) {
696             /* 503: Error: already authenticated */
697             if ($this->_code === 503) {
698                 return true;
699             }
700             return $error;
701         }
702
703         if (PEAR::isError($error = $this->_put(base64_encode($uid)))) {
704             return $error;
705         }
706         /* 334: Continue authentication request */
707         if (PEAR::isError($error = $this->_parseResponse(334))) {
708             return $error;
709         }
710
711         if (PEAR::isError($error = $this->_put(base64_encode($pwd)))) {
712             return $error;
713         }
714
715         /* 235: Authentication successful */
716         if (PEAR::isError($error = $this->_parseResponse(235))) {
717             return $error;
718         }
719
720         return true;
721     }
722
723     /**
724      * Authenticates the user using the PLAIN method.
725      *
726      * @param string The userid to authenticate as.
727      * @param string The password to authenticate with.
728      *
729      * @return mixed Returns a PEAR_Error with an error message on any
730      *               kind of failure, or true on success.
731      * @access private
732      * @since  1.1.0
733      */
734     function _authPlain($uid, $pwd)
735     {
736         if (PEAR::isError($error = $this->_put('AUTH', 'PLAIN'))) {
737             return $error;
738         }
739         /* 334: Continue authentication request */
740         if (PEAR::isError($error = $this->_parseResponse(334))) {
741             /* 503: Error: already authenticated */
742             if ($this->_code === 503) {
743                 return true;
744             }
745             return $error;
746         }
747
748         $auth_str = base64_encode(chr(0) . $uid . chr(0) . $pwd);
749
750         if (PEAR::isError($error = $this->_put($auth_str))) {
751             return $error;
752         }
753
754         /* 235: Authentication successful */
755         if (PEAR::isError($error = $this->_parseResponse(235))) {
756             return $error;
757         }
758
759         return true;
760     }
761
762     /**
763      * Send the HELO command.
764      *
765      * @param string The domain name to say we are.
766      *
767      * @return mixed Returns a PEAR_Error with an error message on any
768      *               kind of failure, or true on success.
769      * @access public
770      * @since  1.0
771      */
772     function helo($domain)
773     {
774         if (PEAR::isError($error = $this->_put('HELO', $domain))) {
775             return $error;
776         }
777         if (PEAR::isError($error = $this->_parseResponse(250))) {
778             return $error;
779         }
780
781         return true;
782     }
783
784     /**
785      * Return the list of SMTP service extensions advertised by the server.
786      *
787      * @return array The list of SMTP service extensions.
788      * @access public
789      * @since 1.3
790      */
791     function getServiceExtensions()
792     {
793         return $this->_esmtp;
794     }
795
796     /**
797      * Send the MAIL FROM: command.
798      *
799      * @param string $sender    The sender (reverse path) to set.
800      * @param string $params    String containing additional MAIL parameters,
801      *                          such as the NOTIFY flags defined by RFC 1891
802      *                          or the VERP protocol.
803      *
804      *                          If $params is an array, only the 'verp' option
805      *                          is supported.  If 'verp' is true, the XVERP
806      *                          parameter is appended to the MAIL command.  If
807      *                          the 'verp' value is a string, the full
808      *                          XVERP=value parameter is appended.
809      *
810      * @return mixed Returns a PEAR_Error with an error message on any
811      *               kind of failure, or true on success.
812      * @access public
813      * @since  1.0
814      */
815     function mailFrom($sender, $params = null)
816     {
817         $args = "FROM:<$sender>";
818
819         /* Support the deprecated array form of $params. */
820         if (is_array($params) && isset($params['verp'])) {
821             /* XVERP */
822             if ($params['verp'] === true) {
823                 $args .= ' XVERP';
824
825             /* XVERP=something */
826             } elseif (trim($params['verp'])) {
827                 $args .= ' XVERP=' . $params['verp'];
828             }
829         } elseif (is_string($params)) {
830             $args .= ' ' . $params;
831         }
832
833         if (PEAR::isError($error = $this->_put('MAIL', $args))) {
834             return $error;
835         }
836         if (PEAR::isError($error = $this->_parseResponse(250, $this->pipelining))) {
837             return $error;
838         }
839
840         return true;
841     }
842
843     /**
844      * Send the RCPT TO: command.
845      *
846      * @param string $recipient The recipient (forward path) to add.
847      * @param string $params    String containing additional RCPT parameters,
848      *                          such as the NOTIFY flags defined by RFC 1891.
849      *
850      * @return mixed Returns a PEAR_Error with an error message on any
851      *               kind of failure, or true on success.
852      *
853      * @access public
854      * @since  1.0
855      */
856     function rcptTo($recipient, $params = null)
857     {
858         $args = "TO:<$recipient>";
859         if (is_string($params)) {
860             $args .= ' ' . $params;
861         }
862
863         if (PEAR::isError($error = $this->_put('RCPT', $args))) {
864             return $error;
865         }
866         if (PEAR::isError($error = $this->_parseResponse(array(250, 251), $this->pipelining))) {
867             return $error;
868         }
869
870         return true;
871     }
872
873     /**
874      * Quote the data so that it meets SMTP standards.
875      *
876      * This is provided as a separate public function to facilitate
877      * easier overloading for the cases where it is desirable to
878      * customize the quoting behavior.
879      *
880      * @param string $data  The message text to quote. The string must be passed
881      *                      by reference, and the text will be modified in place.
882      *
883      * @access public
884      * @since  1.2
885      */
886     function quotedata(&$data)
887     {
888         /* Change Unix (\n) and Mac (\r) linefeeds into
889          * Internet-standard CRLF (\r\n) linefeeds. */
890         $data = preg_replace(array('/(?<!\r)\n/','/\r(?!\n)/'), "\r\n", $data);
891
892         /* Because a single leading period (.) signifies an end to the
893          * data, legitimate leading periods need to be "doubled"
894          * (e.g. '..'). */
895         $data = str_replace("\n.", "\n..", $data);
896     }
897
898     /**
899      * Send the DATA command.
900      *
901      * @param mixed $data     The message data, either as a string or an open
902      *                        file resource.
903      * @param string $headers The message headers.  If $headers is provided,
904      *                        $data is assumed to contain only body data.
905      *
906      * @return mixed Returns a PEAR_Error with an error message on any
907      *               kind of failure, or true on success.
908      * @access public
909      * @since  1.0
910      */
911     function data($data, $headers = null)
912     {
913         /* Verify that $data is a supported type. */
914         if (!is_string($data) && !is_resource($data)) {
915             return PEAR::raiseError('Expected a string or file resource');
916         }
917
918         /* RFC 1870, section 3, subsection 3 states "a value of zero
919          * indicates that no fixed maximum message size is in force".
920          * Furthermore, it says that if "the parameter is omitted no
921          * information is conveyed about the server's fixed maximum
922          * message size". */
923         if (isset($this->_esmtp['SIZE']) && ($this->_esmtp['SIZE'] > 0)) {
924             /* Start by considering the size of the optional headers string.  
925              * We also account for the addition 4 character "\r\n\r\n"
926              * separator sequence. */
927             $size = (is_null($headers)) ? 0 : strlen($headers) + 4;
928
929             if (is_resource($data)) {
930                 $stat = fstat($data);
931                 if ($stat === false) {
932                     return PEAR::raiseError('Failed to get file size');
933                 }
934                 $size += $stat['size'];
935             } else {
936                 $size += strlen($data);
937             }
938
939             if ($size >= $this->_esmtp['SIZE']) {
940                 $this->disconnect();
941                 return PEAR::raiseError('Message size exceeds server limit');
942             }
943         }
944
945         /* Initiate the DATA command. */
946         if (PEAR::isError($error = $this->_put('DATA'))) {
947             return $error;
948         }
949         if (PEAR::isError($error = $this->_parseResponse(354))) {
950             return $error;
951         }
952
953         /* If we have a separate headers string, send it first. */
954         if (!is_null($headers)) {
955             $this->quotedata($headers);
956             if (PEAR::isError($result = $this->_send($headers . "\r\n\r\n"))) {
957                 return $result;
958             }
959         }
960
961         /* Now we can send the message body data. */
962         if (is_resource($data)) {
963             /* Stream the contents of the file resource out over our socket 
964              * connection, line by line.  Each line must be run through the 
965              * quoting routine. */
966             while ($line = fgets($data, 1024)) {
967                 $this->quotedata($line);
968                 if (PEAR::isError($result = $this->_send($line))) {
969                     return $result;
970                 }
971             }
972
973             /* Finally, send the DATA terminator sequence. */
974             if (PEAR::isError($result = $this->_send("\r\n.\r\n"))) {
975                 return $result;
976             }
977         } else {
978             /* Just send the entire quoted string followed by the DATA 
979              * terminator. */
980             $this->quotedata($data);
981             if (PEAR::isError($result = $this->_send($data . "\r\n.\r\n"))) {
982                 return $result;
983             }
984         }
985
986         /* Verify that the data was successfully received by the server. */
987         if (PEAR::isError($error = $this->_parseResponse(250, $this->pipelining))) {
988             return $error;
989         }
990
991         return true;
992     }
993
994     /**
995      * Send the SEND FROM: command.
996      *
997      * @param string The reverse path to send.
998      *
999      * @return mixed Returns a PEAR_Error with an error message on any
1000      *               kind of failure, or true on success.
1001      * @access public
1002      * @since  1.2.6
1003      */
1004     function sendFrom($path)
1005     {
1006         if (PEAR::isError($error = $this->_put('SEND', "FROM:<$path>"))) {
1007             return $error;
1008         }
1009         if (PEAR::isError($error = $this->_parseResponse(250, $this->pipelining))) {
1010             return $error;
1011         }
1012
1013         return true;
1014     }
1015
1016     /**
1017      * Backwards-compatibility wrapper for sendFrom().
1018      *
1019      * @param string The reverse path to send.
1020      *
1021      * @return mixed Returns a PEAR_Error with an error message on any
1022      *               kind of failure, or true on success.
1023      *
1024      * @access      public
1025      * @since       1.0
1026      * @deprecated  1.2.6
1027      */
1028     function send_from($path)
1029     {
1030         return sendFrom($path);
1031     }
1032
1033     /**
1034      * Send the SOML FROM: command.
1035      *
1036      * @param string The reverse path to send.
1037      *
1038      * @return mixed Returns a PEAR_Error with an error message on any
1039      *               kind of failure, or true on success.
1040      * @access public
1041      * @since  1.2.6
1042      */
1043     function somlFrom($path)
1044     {
1045         if (PEAR::isError($error = $this->_put('SOML', "FROM:<$path>"))) {
1046             return $error;
1047         }
1048         if (PEAR::isError($error = $this->_parseResponse(250, $this->pipelining))) {
1049             return $error;
1050         }
1051
1052         return true;
1053     }
1054
1055     /**
1056      * Backwards-compatibility wrapper for somlFrom().
1057      *
1058      * @param string The reverse path to send.
1059      *
1060      * @return mixed Returns a PEAR_Error with an error message on any
1061      *               kind of failure, or true on success.
1062      *
1063      * @access      public
1064      * @since       1.0
1065      * @deprecated  1.2.6
1066      */
1067     function soml_from($path)
1068     {
1069         return somlFrom($path);
1070     }
1071
1072     /**
1073      * Send the SAML FROM: command.
1074      *
1075      * @param string The reverse path to send.
1076      *
1077      * @return mixed Returns a PEAR_Error with an error message on any
1078      *               kind of failure, or true on success.
1079      * @access public
1080      * @since  1.2.6
1081      */
1082     function samlFrom($path)
1083     {
1084         if (PEAR::isError($error = $this->_put('SAML', "FROM:<$path>"))) {
1085             return $error;
1086         }
1087         if (PEAR::isError($error = $this->_parseResponse(250, $this->pipelining))) {
1088             return $error;
1089         }
1090
1091         return true;
1092     }
1093
1094     /**
1095      * Backwards-compatibility wrapper for samlFrom().
1096      *
1097      * @param string The reverse path to send.
1098      *
1099      * @return mixed Returns a PEAR_Error with an error message on any
1100      *               kind of failure, or true on success.
1101      *
1102      * @access      public
1103      * @since       1.0
1104      * @deprecated  1.2.6
1105      */
1106     function saml_from($path)
1107     {
1108         return samlFrom($path);
1109     }
1110
1111     /**
1112      * Send the RSET command.
1113      *
1114      * @return mixed Returns a PEAR_Error with an error message on any
1115      *               kind of failure, or true on success.
1116      * @access public
1117      * @since  1.0
1118      */
1119     function rset()
1120     {
1121         if (PEAR::isError($error = $this->_put('RSET'))) {
1122             return $error;
1123         }
1124         if (PEAR::isError($error = $this->_parseResponse(250, $this->pipelining))) {
1125             return $error;
1126         }
1127
1128         return true;
1129     }
1130
1131     /**
1132      * Send the VRFY command.
1133      *
1134      * @param string The string to verify
1135      *
1136      * @return mixed Returns a PEAR_Error with an error message on any
1137      *               kind of failure, or true on success.
1138      * @access public
1139      * @since  1.0
1140      */
1141     function vrfy($string)
1142     {
1143         /* Note: 251 is also a valid response code */
1144         if (PEAR::isError($error = $this->_put('VRFY', $string))) {
1145             return $error;
1146         }
1147         if (PEAR::isError($error = $this->_parseResponse(array(250, 252)))) {
1148             return $error;
1149         }
1150
1151         return true;
1152     }
1153
1154     /**
1155      * Send the NOOP command.
1156      *
1157      * @return mixed Returns a PEAR_Error with an error message on any
1158      *               kind of failure, or true on success.
1159      * @access public
1160      * @since  1.0
1161      */
1162     function noop()
1163     {
1164         if (PEAR::isError($error = $this->_put('NOOP'))) {
1165             return $error;
1166         }
1167         if (PEAR::isError($error = $this->_parseResponse(250))) {
1168             return $error;
1169         }
1170
1171         return true;
1172     }
1173
1174     /**
1175      * Backwards-compatibility method.  identifySender()'s functionality is
1176      * now handled internally.
1177      *
1178      * @return  boolean     This method always return true.
1179      *
1180      * @access  public
1181      * @since   1.0
1182      */
1183     function identifySender()
1184     {
1185         return true;
1186     }
1187
1188 }