Commit | Line | Data |
---|---|---|
b42b2bf9 H |
1 | <?php |
2 | //////////////////////////////////////////////////// | |
3 | // SMTP - PHP SMTP class | |
4 | // | |
5 | // Version 1.02 | |
6 | // | |
7 | // Define an SMTP class that can be used to connect | |
8 | // and communicate with any SMTP server. It implements | |
9 | // all the SMTP functions defined in RFC821 except TURN. | |
10 | // | |
11 | // Author: Chris Ryan | |
12 | // | |
13 | // License: LGPL, see LICENSE | |
14 | //////////////////////////////////////////////////// | |
15 | ||
16 | /** | |
17 | * SMTP is rfc 821 compliant and implements all the rfc 821 SMTP | |
18 | * commands except TURN which will always return a not implemented | |
19 | * error. SMTP also provides some utility methods for sending mail | |
20 | * to an SMTP server. | |
21 | * @package PHPMailer | |
22 | * @author Chris Ryan | |
23 | */ | |
24 | class SMTP | |
25 | { | |
26 | /** | |
27 | * SMTP server port | |
28 | * @var int | |
29 | */ | |
30 | var $SMTP_PORT = 25; | |
31 | ||
32 | /** | |
33 | * SMTP reply line ending | |
34 | * @var string | |
35 | */ | |
36 | var $CRLF = "\r\n"; | |
37 | ||
38 | /** | |
39 | * Sets whether debugging is turned on | |
40 | * @var bool | |
41 | */ | |
42 | var $do_debug; # the level of debug to perform | |
43 | ||
44 | /**#@+ | |
45 | * @access private | |
46 | */ | |
47 | var $smtp_conn; # the socket to the server | |
48 | var $error; # error if any on the last call | |
49 | var $helo_rply; # the reply the server sent to us for HELO | |
50 | /**#@-*/ | |
51 | ||
52 | /** | |
53 | * Initialize the class so that the data is in a known state. | |
54 | * @access public | |
55 | * @return void | |
56 | */ | |
57 | function SMTP() { | |
58 | $this->smtp_conn = 0; | |
59 | $this->error = null; | |
60 | $this->helo_rply = null; | |
61 | ||
62 | $this->do_debug = 0; | |
63 | } | |
64 | ||
65 | /************************************************************* | |
66 | * CONNECTION FUNCTIONS * | |
67 | ***********************************************************/ | |
68 | ||
69 | /** | |
70 | * Connect to the server specified on the port specified. | |
71 | * If the port is not specified use the default SMTP_PORT. | |
72 | * If tval is specified then a connection will try and be | |
73 | * established with the server for that number of seconds. | |
74 | * If tval is not specified the default is 30 seconds to | |
75 | * try on the connection. | |
76 | * | |
77 | * SMTP CODE SUCCESS: 220 | |
78 | * SMTP CODE FAILURE: 421 | |
79 | * @access public | |
80 | * @return bool | |
81 | */ | |
82 | function Connect($host,$port=0,$tval=30) { | |
83 | # set the error val to null so there is no confusion | |
84 | $this->error = null; | |
85 | ||
86 | # make sure we are __not__ connected | |
87 | if($this->connected()) { | |
88 | # ok we are connected! what should we do? | |
89 | # for now we will just give an error saying we | |
90 | # are already connected | |
91 | $this->error = | |
92 | array("error" => "Already connected to a server"); | |
93 | return false; | |
94 | } | |
95 | ||
96 | if(empty($port)) { | |
97 | $port = $this->SMTP_PORT; | |
98 | } | |
99 | ||
100 | #connect to the smtp server | |
101 | $this->smtp_conn = fsockopen($host, # the host of the server | |
102 | $port, # the port to use | |
103 | $errno, # error number if any | |
104 | $errstr, # error message if any | |
105 | $tval); # give up after ? secs | |
106 | # verify we connected properly | |
107 | if(empty($this->smtp_conn)) { | |
108 | $this->error = array("error" => "Failed to connect to server", | |
109 | "errno" => $errno, | |
110 | "errstr" => $errstr); | |
111 | if($this->do_debug >= 1) { | |
112 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
113 | ": $errstr ($errno)" . $this->CRLF; | |
114 | } | |
115 | return false; | |
116 | } | |
117 | ||
118 | # sometimes the SMTP server takes a little longer to respond | |
119 | # so we will give it a longer timeout for the first read | |
120 | // Windows still does not have support for this timeout function | |
121 | if(substr(PHP_OS, 0, 3) != "WIN") | |
122 | socket_set_timeout($this->smtp_conn, $tval, 0); | |
123 | ||
124 | # get any announcement stuff | |
125 | $announce = $this->get_lines(); | |
126 | ||
127 | # set the timeout of any socket functions at 1/10 of a second | |
128 | //if(function_exists("socket_set_timeout")) | |
129 | // socket_set_timeout($this->smtp_conn, 0, 100000); | |
130 | ||
131 | if($this->do_debug >= 2) { | |
132 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $announce; | |
133 | } | |
134 | ||
135 | return true; | |
136 | } | |
137 | ||
138 | /** | |
139 | * Performs SMTP authentication. Must be run after running the | |
140 | * Hello() method. Returns true if successfully authenticated. | |
141 | * @access public | |
142 | * @return bool | |
143 | */ | |
144 | function Authenticate($username, $password) { | |
145 | // Start authentication | |
146 | fputs($this->smtp_conn,"AUTH LOGIN" . $this->CRLF); | |
147 | ||
148 | $rply = $this->get_lines(); | |
149 | $code = substr($rply,0,3); | |
150 | ||
151 | if($code != 334) { | |
152 | $this->error = | |
153 | array("error" => "AUTH not accepted from server", | |
154 | "smtp_code" => $code, | |
155 | "smtp_msg" => substr($rply,4)); | |
156 | if($this->do_debug >= 1) { | |
157 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
158 | ": " . $rply . $this->CRLF; | |
159 | } | |
160 | return false; | |
161 | } | |
162 | ||
163 | // Send encoded username | |
164 | fputs($this->smtp_conn, base64_encode($username) . $this->CRLF); | |
165 | ||
166 | $rply = $this->get_lines(); | |
167 | $code = substr($rply,0,3); | |
168 | ||
169 | if($code != 334) { | |
170 | $this->error = | |
171 | array("error" => "Username not accepted from server", | |
172 | "smtp_code" => $code, | |
173 | "smtp_msg" => substr($rply,4)); | |
174 | if($this->do_debug >= 1) { | |
175 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
176 | ": " . $rply . $this->CRLF; | |
177 | } | |
178 | return false; | |
179 | } | |
180 | ||
181 | // Send encoded password | |
182 | fputs($this->smtp_conn, base64_encode($password) . $this->CRLF); | |
183 | ||
184 | $rply = $this->get_lines(); | |
185 | $code = substr($rply,0,3); | |
186 | ||
187 | if($code != 235) { | |
188 | $this->error = | |
189 | array("error" => "Password not accepted from server", | |
190 | "smtp_code" => $code, | |
191 | "smtp_msg" => substr($rply,4)); | |
192 | if($this->do_debug >= 1) { | |
193 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
194 | ": " . $rply . $this->CRLF; | |
195 | } | |
196 | return false; | |
197 | } | |
198 | ||
199 | return true; | |
200 | } | |
201 | ||
202 | /** | |
203 | * Returns true if connected to a server otherwise false | |
204 | * @access private | |
205 | * @return bool | |
206 | */ | |
207 | function Connected() { | |
208 | if(!empty($this->smtp_conn)) { | |
209 | $sock_status = socket_get_status($this->smtp_conn); | |
210 | if($sock_status["eof"]) { | |
211 | # hmm this is an odd situation... the socket is | |
212 | # valid but we aren't connected anymore | |
213 | if($this->do_debug >= 1) { | |
214 | echo "SMTP -> NOTICE:" . $this->CRLF . | |
215 | "EOF caught while checking if connected"; | |
216 | } | |
217 | $this->Close(); | |
218 | return false; | |
219 | } | |
220 | return true; # everything looks good | |
221 | } | |
222 | return false; | |
223 | } | |
224 | ||
225 | /** | |
226 | * Closes the socket and cleans up the state of the class. | |
227 | * It is not considered good to use this function without | |
228 | * first trying to use QUIT. | |
229 | * @access public | |
230 | * @return void | |
231 | */ | |
232 | function Close() { | |
233 | $this->error = null; # so there is no confusion | |
234 | $this->helo_rply = null; | |
235 | if(!empty($this->smtp_conn)) { | |
236 | # close the connection and cleanup | |
237 | fclose($this->smtp_conn); | |
238 | $this->smtp_conn = 0; | |
239 | } | |
240 | } | |
241 | ||
242 | ||
243 | /*************************************************************** | |
244 | * SMTP COMMANDS * | |
245 | *************************************************************/ | |
246 | ||
247 | /** | |
248 | * Issues a data command and sends the msg_data to the server | |
249 | * finializing the mail transaction. $msg_data is the message | |
250 | * that is to be send with the headers. Each header needs to be | |
251 | * on a single line followed by a <CRLF> with the message headers | |
252 | * and the message body being seperated by and additional <CRLF>. | |
253 | * | |
254 | * Implements rfc 821: DATA <CRLF> | |
255 | * | |
256 | * SMTP CODE INTERMEDIATE: 354 | |
257 | * [data] | |
258 | * <CRLF>.<CRLF> | |
259 | * SMTP CODE SUCCESS: 250 | |
260 | * SMTP CODE FAILURE: 552,554,451,452 | |
261 | * SMTP CODE FAILURE: 451,554 | |
262 | * SMTP CODE ERROR : 500,501,503,421 | |
263 | * @access public | |
264 | * @return bool | |
265 | */ | |
266 | function Data($msg_data) { | |
267 | $this->error = null; # so no confusion is caused | |
268 | ||
269 | if(!$this->connected()) { | |
270 | $this->error = array( | |
271 | "error" => "Called Data() without being connected"); | |
272 | return false; | |
273 | } | |
274 | ||
275 | fputs($this->smtp_conn,"DATA" . $this->CRLF); | |
276 | ||
277 | $rply = $this->get_lines(); | |
278 | $code = substr($rply,0,3); | |
279 | ||
280 | if($this->do_debug >= 2) { | |
281 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
282 | } | |
283 | ||
284 | if($code != 354) { | |
285 | $this->error = | |
286 | array("error" => "DATA command not accepted from server", | |
287 | "smtp_code" => $code, | |
288 | "smtp_msg" => substr($rply,4)); | |
289 | if($this->do_debug >= 1) { | |
290 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
291 | ": " . $rply . $this->CRLF; | |
292 | } | |
293 | return false; | |
294 | } | |
295 | ||
296 | # the server is ready to accept data! | |
297 | # according to rfc 821 we should not send more than 1000 | |
298 | # including the CRLF | |
299 | # characters on a single line so we will break the data up | |
300 | # into lines by \r and/or \n then if needed we will break | |
301 | # each of those into smaller lines to fit within the limit. | |
302 | # in addition we will be looking for lines that start with | |
303 | # a period '.' and append and additional period '.' to that | |
304 | # line. NOTE: this does not count towards are limit. | |
305 | ||
306 | # normalize the line breaks so we know the explode works | |
307 | $msg_data = str_replace("\r\n","\n",$msg_data); | |
308 | $msg_data = str_replace("\r","\n",$msg_data); | |
309 | $lines = explode("\n",$msg_data); | |
310 | ||
311 | # we need to find a good way to determine is headers are | |
312 | # in the msg_data or if it is a straight msg body | |
313 | # currently I'm assuming rfc 822 definitions of msg headers | |
314 | # and if the first field of the first line (':' sperated) | |
315 | # does not contain a space then it _should_ be a header | |
316 | # and we can process all lines before a blank "" line as | |
317 | # headers. | |
318 | $field = substr($lines[0],0,strpos($lines[0],":")); | |
319 | $in_headers = false; | |
320 | if(!empty($field) && !strstr($field," ")) { | |
321 | $in_headers = true; | |
322 | } | |
323 | ||
324 | $max_line_length = 998; # used below; set here for ease in change | |
325 | ||
326 | while(list(,$line) = @each($lines)) { | |
327 | $lines_out = null; | |
328 | if($line == "" && $in_headers) { | |
329 | $in_headers = false; | |
330 | } | |
331 | # ok we need to break this line up into several | |
332 | # smaller lines | |
333 | while(strlen($line) > $max_line_length) { | |
334 | $pos = strrpos(substr($line,0,$max_line_length)," "); | |
335 | $lines_out[] = substr($line,0,$pos); | |
336 | $line = substr($line,$pos + 1); | |
337 | # if we are processing headers we need to | |
338 | # add a LWSP-char to the front of the new line | |
339 | # rfc 822 on long msg headers | |
340 | if($in_headers) { | |
341 | $line = "\t" . $line; | |
342 | } | |
343 | } | |
344 | $lines_out[] = $line; | |
345 | ||
346 | # now send the lines to the server | |
347 | while(list(,$line_out) = @each($lines_out)) { | |
348 | if(strlen($line_out) > 0) | |
349 | { | |
350 | if(substr($line_out, 0, 1) == ".") { | |
351 | $line_out = "." . $line_out; | |
352 | } | |
353 | } | |
354 | fputs($this->smtp_conn,$line_out . $this->CRLF); | |
355 | } | |
356 | } | |
357 | ||
358 | # ok all the message data has been sent so lets get this | |
359 | # over with aleady | |
360 | fputs($this->smtp_conn, $this->CRLF . "." . $this->CRLF); | |
361 | ||
362 | $rply = $this->get_lines(); | |
363 | $code = substr($rply,0,3); | |
364 | ||
365 | if($this->do_debug >= 2) { | |
366 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
367 | } | |
368 | ||
369 | if($code != 250) { | |
370 | $this->error = | |
371 | array("error" => "DATA not accepted from server", | |
372 | "smtp_code" => $code, | |
373 | "smtp_msg" => substr($rply,4)); | |
374 | if($this->do_debug >= 1) { | |
375 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
376 | ": " . $rply . $this->CRLF; | |
377 | } | |
378 | return false; | |
379 | } | |
380 | return true; | |
381 | } | |
382 | ||
383 | /** | |
384 | * Expand takes the name and asks the server to list all the | |
385 | * people who are members of the _list_. Expand will return | |
386 | * back and array of the result or false if an error occurs. | |
387 | * Each value in the array returned has the format of: | |
388 | * [ <full-name> <sp> ] <path> | |
389 | * The definition of <path> is defined in rfc 821 | |
390 | * | |
391 | * Implements rfc 821: EXPN <SP> <string> <CRLF> | |
392 | * | |
393 | * SMTP CODE SUCCESS: 250 | |
394 | * SMTP CODE FAILURE: 550 | |
395 | * SMTP CODE ERROR : 500,501,502,504,421 | |
396 | * @access public | |
397 | * @return string array | |
398 | */ | |
399 | function Expand($name) { | |
400 | $this->error = null; # so no confusion is caused | |
401 | ||
402 | if(!$this->connected()) { | |
403 | $this->error = array( | |
404 | "error" => "Called Expand() without being connected"); | |
405 | return false; | |
406 | } | |
407 | ||
408 | fputs($this->smtp_conn,"EXPN " . $name . $this->CRLF); | |
409 | ||
410 | $rply = $this->get_lines(); | |
411 | $code = substr($rply,0,3); | |
412 | ||
413 | if($this->do_debug >= 2) { | |
414 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
415 | } | |
416 | ||
417 | if($code != 250) { | |
418 | $this->error = | |
419 | array("error" => "EXPN not accepted from server", | |
420 | "smtp_code" => $code, | |
421 | "smtp_msg" => substr($rply,4)); | |
422 | if($this->do_debug >= 1) { | |
423 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
424 | ": " . $rply . $this->CRLF; | |
425 | } | |
426 | return false; | |
427 | } | |
428 | ||
429 | # parse the reply and place in our array to return to user | |
430 | $entries = explode($this->CRLF,$rply); | |
431 | while(list(,$l) = @each($entries)) { | |
432 | $list[] = substr($l,4); | |
433 | } | |
434 | ||
435 | return $list; | |
436 | } | |
437 | ||
438 | /** | |
439 | * Sends the HELO command to the smtp server. | |
440 | * This makes sure that we and the server are in | |
441 | * the same known state. | |
442 | * | |
443 | * Implements from rfc 821: HELO <SP> <domain> <CRLF> | |
444 | * | |
445 | * SMTP CODE SUCCESS: 250 | |
446 | * SMTP CODE ERROR : 500, 501, 504, 421 | |
447 | * @access public | |
448 | * @return bool | |
449 | */ | |
450 | function Hello($host="") { | |
451 | $this->error = null; # so no confusion is caused | |
452 | ||
453 | if(!$this->connected()) { | |
454 | $this->error = array( | |
455 | "error" => "Called Hello() without being connected"); | |
456 | return false; | |
457 | } | |
458 | ||
459 | # if a hostname for the HELO wasn't specified determine | |
460 | # a suitable one to send | |
461 | if(empty($host)) { | |
462 | # we need to determine some sort of appopiate default | |
463 | # to send to the server | |
464 | $host = "localhost"; | |
465 | } | |
466 | ||
467 | // Send extended hello first (RFC 2821) | |
468 | if(!$this->SendHello("EHLO", $host)) | |
469 | { | |
470 | if(!$this->SendHello("HELO", $host)) | |
471 | return false; | |
472 | } | |
473 | ||
474 | return true; | |
475 | } | |
476 | ||
477 | /** | |
478 | * Sends a HELO/EHLO command. | |
479 | * @access private | |
480 | * @return bool | |
481 | */ | |
482 | function SendHello($hello, $host) { | |
483 | fputs($this->smtp_conn, $hello . " " . $host . $this->CRLF); | |
484 | ||
485 | $rply = $this->get_lines(); | |
486 | $code = substr($rply,0,3); | |
487 | ||
488 | if($this->do_debug >= 2) { | |
489 | echo "SMTP -> FROM SERVER: " . $this->CRLF . $rply; | |
490 | } | |
491 | ||
492 | if($code != 250) { | |
493 | $this->error = | |
494 | array("error" => $hello . " not accepted from server", | |
495 | "smtp_code" => $code, | |
496 | "smtp_msg" => substr($rply,4)); | |
497 | if($this->do_debug >= 1) { | |
498 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
499 | ": " . $rply . $this->CRLF; | |
500 | } | |
501 | return false; | |
502 | } | |
503 | ||
504 | $this->helo_rply = $rply; | |
505 | ||
506 | return true; | |
507 | } | |
508 | ||
509 | /** | |
510 | * Gets help information on the keyword specified. If the keyword | |
511 | * is not specified then returns generic help, ussually contianing | |
512 | * A list of keywords that help is available on. This function | |
513 | * returns the results back to the user. It is up to the user to | |
514 | * handle the returned data. If an error occurs then false is | |
515 | * returned with $this->error set appropiately. | |
516 | * | |
517 | * Implements rfc 821: HELP [ <SP> <string> ] <CRLF> | |
518 | * | |
519 | * SMTP CODE SUCCESS: 211,214 | |
520 | * SMTP CODE ERROR : 500,501,502,504,421 | |
521 | * @access public | |
522 | * @return string | |
523 | */ | |
524 | function Help($keyword="") { | |
525 | $this->error = null; # to avoid confusion | |
526 | ||
527 | if(!$this->connected()) { | |
528 | $this->error = array( | |
529 | "error" => "Called Help() without being connected"); | |
530 | return false; | |
531 | } | |
532 | ||
533 | $extra = ""; | |
534 | if(!empty($keyword)) { | |
535 | $extra = " " . $keyword; | |
536 | } | |
537 | ||
538 | fputs($this->smtp_conn,"HELP" . $extra . $this->CRLF); | |
539 | ||
540 | $rply = $this->get_lines(); | |
541 | $code = substr($rply,0,3); | |
542 | ||
543 | if($this->do_debug >= 2) { | |
544 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
545 | } | |
546 | ||
547 | if($code != 211 && $code != 214) { | |
548 | $this->error = | |
549 | array("error" => "HELP not accepted from server", | |
550 | "smtp_code" => $code, | |
551 | "smtp_msg" => substr($rply,4)); | |
552 | if($this->do_debug >= 1) { | |
553 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
554 | ": " . $rply . $this->CRLF; | |
555 | } | |
556 | return false; | |
557 | } | |
558 | ||
559 | return $rply; | |
560 | } | |
561 | ||
562 | /** | |
563 | * Starts a mail transaction from the email address specified in | |
564 | * $from. Returns true if successful or false otherwise. If True | |
565 | * the mail transaction is started and then one or more Recipient | |
566 | * commands may be called followed by a Data command. | |
567 | * | |
568 | * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF> | |
569 | * | |
570 | * SMTP CODE SUCCESS: 250 | |
571 | * SMTP CODE SUCCESS: 552,451,452 | |
572 | * SMTP CODE SUCCESS: 500,501,421 | |
573 | * @access public | |
574 | * @return bool | |
575 | */ | |
576 | function Mail($from) { | |
577 | $this->error = null; # so no confusion is caused | |
578 | ||
579 | if(!$this->connected()) { | |
580 | $this->error = array( | |
581 | "error" => "Called Mail() without being connected"); | |
582 | return false; | |
583 | } | |
584 | ||
585 | fputs($this->smtp_conn,"MAIL FROM:<" . $from . ">" . $this->CRLF); | |
586 | ||
587 | $rply = $this->get_lines(); | |
588 | $code = substr($rply,0,3); | |
589 | ||
590 | if($this->do_debug >= 2) { | |
591 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
592 | } | |
593 | ||
594 | if($code != 250) { | |
595 | $this->error = | |
596 | array("error" => "MAIL not accepted from server", | |
597 | "smtp_code" => $code, | |
598 | "smtp_msg" => substr($rply,4)); | |
599 | if($this->do_debug >= 1) { | |
600 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
601 | ": " . $rply . $this->CRLF; | |
602 | } | |
603 | return false; | |
604 | } | |
605 | return true; | |
606 | } | |
607 | ||
608 | /** | |
609 | * Sends the command NOOP to the SMTP server. | |
610 | * | |
611 | * Implements from rfc 821: NOOP <CRLF> | |
612 | * | |
613 | * SMTP CODE SUCCESS: 250 | |
614 | * SMTP CODE ERROR : 500, 421 | |
615 | * @access public | |
616 | * @return bool | |
617 | */ | |
618 | function Noop() { | |
619 | $this->error = null; # so no confusion is caused | |
620 | ||
621 | if(!$this->connected()) { | |
622 | $this->error = array( | |
623 | "error" => "Called Noop() without being connected"); | |
624 | return false; | |
625 | } | |
626 | ||
627 | fputs($this->smtp_conn,"NOOP" . $this->CRLF); | |
628 | ||
629 | $rply = $this->get_lines(); | |
630 | $code = substr($rply,0,3); | |
631 | ||
632 | if($this->do_debug >= 2) { | |
633 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
634 | } | |
635 | ||
636 | if($code != 250) { | |
637 | $this->error = | |
638 | array("error" => "NOOP not accepted from server", | |
639 | "smtp_code" => $code, | |
640 | "smtp_msg" => substr($rply,4)); | |
641 | if($this->do_debug >= 1) { | |
642 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
643 | ": " . $rply . $this->CRLF; | |
644 | } | |
645 | return false; | |
646 | } | |
647 | return true; | |
648 | } | |
649 | ||
650 | /** | |
651 | * Sends the quit command to the server and then closes the socket | |
652 | * if there is no error or the $close_on_error argument is true. | |
653 | * | |
654 | * Implements from rfc 821: QUIT <CRLF> | |
655 | * | |
656 | * SMTP CODE SUCCESS: 221 | |
657 | * SMTP CODE ERROR : 500 | |
658 | * @access public | |
659 | * @return bool | |
660 | */ | |
661 | function Quit($close_on_error=true) { | |
662 | $this->error = null; # so there is no confusion | |
663 | ||
664 | if(!$this->connected()) { | |
665 | $this->error = array( | |
666 | "error" => "Called Quit() without being connected"); | |
667 | return false; | |
668 | } | |
669 | ||
670 | # send the quit command to the server | |
671 | fputs($this->smtp_conn,"quit" . $this->CRLF); | |
672 | ||
673 | # get any good-bye messages | |
674 | $byemsg = $this->get_lines(); | |
675 | ||
676 | if($this->do_debug >= 2) { | |
677 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $byemsg; | |
678 | } | |
679 | ||
680 | $rval = true; | |
681 | $e = null; | |
682 | ||
683 | $code = substr($byemsg,0,3); | |
684 | if($code != 221) { | |
685 | # use e as a tmp var cause Close will overwrite $this->error | |
686 | $e = array("error" => "SMTP server rejected quit command", | |
687 | "smtp_code" => $code, | |
688 | "smtp_rply" => substr($byemsg,4)); | |
689 | $rval = false; | |
690 | if($this->do_debug >= 1) { | |
691 | echo "SMTP -> ERROR: " . $e["error"] . ": " . | |
692 | $byemsg . $this->CRLF; | |
693 | } | |
694 | } | |
695 | ||
696 | if(empty($e) || $close_on_error) { | |
697 | $this->Close(); | |
698 | } | |
699 | ||
700 | return $rval; | |
701 | } | |
702 | ||
703 | /** | |
704 | * Sends the command RCPT to the SMTP server with the TO: argument of $to. | |
705 | * Returns true if the recipient was accepted false if it was rejected. | |
706 | * | |
707 | * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF> | |
708 | * | |
709 | * SMTP CODE SUCCESS: 250,251 | |
710 | * SMTP CODE FAILURE: 550,551,552,553,450,451,452 | |
711 | * SMTP CODE ERROR : 500,501,503,421 | |
712 | * @access public | |
713 | * @return bool | |
714 | */ | |
715 | function Recipient($to) { | |
716 | $this->error = null; # so no confusion is caused | |
717 | ||
718 | if(!$this->connected()) { | |
719 | $this->error = array( | |
720 | "error" => "Called Recipient() without being connected"); | |
721 | return false; | |
722 | } | |
723 | ||
724 | fputs($this->smtp_conn,"RCPT TO:<" . $to . ">" . $this->CRLF); | |
725 | ||
726 | $rply = $this->get_lines(); | |
727 | $code = substr($rply,0,3); | |
728 | ||
729 | if($this->do_debug >= 2) { | |
730 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
731 | } | |
732 | ||
733 | if($code != 250 && $code != 251) { | |
734 | $this->error = | |
735 | array("error" => "RCPT not accepted from server", | |
736 | "smtp_code" => $code, | |
737 | "smtp_msg" => substr($rply,4)); | |
738 | if($this->do_debug >= 1) { | |
739 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
740 | ": " . $rply . $this->CRLF; | |
741 | } | |
742 | return false; | |
743 | } | |
744 | return true; | |
745 | } | |
746 | ||
747 | /** | |
748 | * Sends the RSET command to abort and transaction that is | |
749 | * currently in progress. Returns true if successful false | |
750 | * otherwise. | |
751 | * | |
752 | * Implements rfc 821: RSET <CRLF> | |
753 | * | |
754 | * SMTP CODE SUCCESS: 250 | |
755 | * SMTP CODE ERROR : 500,501,504,421 | |
756 | * @access public | |
757 | * @return bool | |
758 | */ | |
759 | function Reset() { | |
760 | $this->error = null; # so no confusion is caused | |
761 | ||
762 | if(!$this->connected()) { | |
763 | $this->error = array( | |
764 | "error" => "Called Reset() without being connected"); | |
765 | return false; | |
766 | } | |
767 | ||
768 | fputs($this->smtp_conn,"RSET" . $this->CRLF); | |
769 | ||
770 | $rply = $this->get_lines(); | |
771 | $code = substr($rply,0,3); | |
772 | ||
773 | if($this->do_debug >= 2) { | |
774 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
775 | } | |
776 | ||
777 | if($code != 250) { | |
778 | $this->error = | |
779 | array("error" => "RSET failed", | |
780 | "smtp_code" => $code, | |
781 | "smtp_msg" => substr($rply,4)); | |
782 | if($this->do_debug >= 1) { | |
783 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
784 | ": " . $rply . $this->CRLF; | |
785 | } | |
786 | return false; | |
787 | } | |
788 | ||
789 | return true; | |
790 | } | |
791 | ||
792 | /** | |
793 | * Starts a mail transaction from the email address specified in | |
794 | * $from. Returns true if successful or false otherwise. If True | |
795 | * the mail transaction is started and then one or more Recipient | |
796 | * commands may be called followed by a Data command. This command | |
797 | * will send the message to the users terminal if they are logged | |
798 | * in. | |
799 | * | |
800 | * Implements rfc 821: SEND <SP> FROM:<reverse-path> <CRLF> | |
801 | * | |
802 | * SMTP CODE SUCCESS: 250 | |
803 | * SMTP CODE SUCCESS: 552,451,452 | |
804 | * SMTP CODE SUCCESS: 500,501,502,421 | |
805 | * @access public | |
806 | * @return bool | |
807 | */ | |
808 | function Send($from) { | |
809 | $this->error = null; # so no confusion is caused | |
810 | ||
811 | if(!$this->connected()) { | |
812 | $this->error = array( | |
813 | "error" => "Called Send() without being connected"); | |
814 | return false; | |
815 | } | |
816 | ||
817 | fputs($this->smtp_conn,"SEND FROM:" . $from . $this->CRLF); | |
818 | ||
819 | $rply = $this->get_lines(); | |
820 | $code = substr($rply,0,3); | |
821 | ||
822 | if($this->do_debug >= 2) { | |
823 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
824 | } | |
825 | ||
826 | if($code != 250) { | |
827 | $this->error = | |
828 | array("error" => "SEND not accepted from server", | |
829 | "smtp_code" => $code, | |
830 | "smtp_msg" => substr($rply,4)); | |
831 | if($this->do_debug >= 1) { | |
832 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
833 | ": " . $rply . $this->CRLF; | |
834 | } | |
835 | return false; | |
836 | } | |
837 | return true; | |
838 | } | |
839 | ||
840 | /** | |
841 | * Starts a mail transaction from the email address specified in | |
842 | * $from. Returns true if successful or false otherwise. If True | |
843 | * the mail transaction is started and then one or more Recipient | |
844 | * commands may be called followed by a Data command. This command | |
845 | * will send the message to the users terminal if they are logged | |
846 | * in and send them an email. | |
847 | * | |
848 | * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF> | |
849 | * | |
850 | * SMTP CODE SUCCESS: 250 | |
851 | * SMTP CODE SUCCESS: 552,451,452 | |
852 | * SMTP CODE SUCCESS: 500,501,502,421 | |
853 | * @access public | |
854 | * @return bool | |
855 | */ | |
856 | function SendAndMail($from) { | |
857 | $this->error = null; # so no confusion is caused | |
858 | ||
859 | if(!$this->connected()) { | |
860 | $this->error = array( | |
861 | "error" => "Called SendAndMail() without being connected"); | |
862 | return false; | |
863 | } | |
864 | ||
865 | fputs($this->smtp_conn,"SAML FROM:" . $from . $this->CRLF); | |
866 | ||
867 | $rply = $this->get_lines(); | |
868 | $code = substr($rply,0,3); | |
869 | ||
870 | if($this->do_debug >= 2) { | |
871 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
872 | } | |
873 | ||
874 | if($code != 250) { | |
875 | $this->error = | |
876 | array("error" => "SAML not accepted from server", | |
877 | "smtp_code" => $code, | |
878 | "smtp_msg" => substr($rply,4)); | |
879 | if($this->do_debug >= 1) { | |
880 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
881 | ": " . $rply . $this->CRLF; | |
882 | } | |
883 | return false; | |
884 | } | |
885 | return true; | |
886 | } | |
887 | ||
888 | /** | |
889 | * Starts a mail transaction from the email address specified in | |
890 | * $from. Returns true if successful or false otherwise. If True | |
891 | * the mail transaction is started and then one or more Recipient | |
892 | * commands may be called followed by a Data command. This command | |
893 | * will send the message to the users terminal if they are logged | |
894 | * in or mail it to them if they are not. | |
895 | * | |
896 | * Implements rfc 821: SOML <SP> FROM:<reverse-path> <CRLF> | |
897 | * | |
898 | * SMTP CODE SUCCESS: 250 | |
899 | * SMTP CODE SUCCESS: 552,451,452 | |
900 | * SMTP CODE SUCCESS: 500,501,502,421 | |
901 | * @access public | |
902 | * @return bool | |
903 | */ | |
904 | function SendOrMail($from) { | |
905 | $this->error = null; # so no confusion is caused | |
906 | ||
907 | if(!$this->connected()) { | |
908 | $this->error = array( | |
909 | "error" => "Called SendOrMail() without being connected"); | |
910 | return false; | |
911 | } | |
912 | ||
913 | fputs($this->smtp_conn,"SOML FROM:" . $from . $this->CRLF); | |
914 | ||
915 | $rply = $this->get_lines(); | |
916 | $code = substr($rply,0,3); | |
917 | ||
918 | if($this->do_debug >= 2) { | |
919 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
920 | } | |
921 | ||
922 | if($code != 250) { | |
923 | $this->error = | |
924 | array("error" => "SOML not accepted from server", | |
925 | "smtp_code" => $code, | |
926 | "smtp_msg" => substr($rply,4)); | |
927 | if($this->do_debug >= 1) { | |
928 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
929 | ": " . $rply . $this->CRLF; | |
930 | } | |
931 | return false; | |
932 | } | |
933 | return true; | |
934 | } | |
935 | ||
936 | /** | |
937 | * This is an optional command for SMTP that this class does not | |
938 | * support. This method is here to make the RFC821 Definition | |
939 | * complete for this class and __may__ be implimented in the future | |
940 | * | |
941 | * Implements from rfc 821: TURN <CRLF> | |
942 | * | |
943 | * SMTP CODE SUCCESS: 250 | |
944 | * SMTP CODE FAILURE: 502 | |
945 | * SMTP CODE ERROR : 500, 503 | |
946 | * @access public | |
947 | * @return bool | |
948 | */ | |
949 | function Turn() { | |
950 | $this->error = array("error" => "This method, TURN, of the SMTP ". | |
951 | "is not implemented"); | |
952 | if($this->do_debug >= 1) { | |
953 | echo "SMTP -> NOTICE: " . $this->error["error"] . $this->CRLF; | |
954 | } | |
955 | return false; | |
956 | } | |
957 | ||
958 | /** | |
959 | * Verifies that the name is recognized by the server. | |
960 | * Returns false if the name could not be verified otherwise | |
961 | * the response from the server is returned. | |
962 | * | |
963 | * Implements rfc 821: VRFY <SP> <string> <CRLF> | |
964 | * | |
965 | * SMTP CODE SUCCESS: 250,251 | |
966 | * SMTP CODE FAILURE: 550,551,553 | |
967 | * SMTP CODE ERROR : 500,501,502,421 | |
968 | * @access public | |
969 | * @return int | |
970 | */ | |
971 | function Verify($name) { | |
972 | $this->error = null; # so no confusion is caused | |
973 | ||
974 | if(!$this->connected()) { | |
975 | $this->error = array( | |
976 | "error" => "Called Verify() without being connected"); | |
977 | return false; | |
978 | } | |
979 | ||
980 | fputs($this->smtp_conn,"VRFY " . $name . $this->CRLF); | |
981 | ||
982 | $rply = $this->get_lines(); | |
983 | $code = substr($rply,0,3); | |
984 | ||
985 | if($this->do_debug >= 2) { | |
986 | echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply; | |
987 | } | |
988 | ||
989 | if($code != 250 && $code != 251) { | |
990 | $this->error = | |
991 | array("error" => "VRFY failed on name '$name'", | |
992 | "smtp_code" => $code, | |
993 | "smtp_msg" => substr($rply,4)); | |
994 | if($this->do_debug >= 1) { | |
995 | echo "SMTP -> ERROR: " . $this->error["error"] . | |
996 | ": " . $rply . $this->CRLF; | |
997 | } | |
998 | return false; | |
999 | } | |
1000 | return $rply; | |
1001 | } | |
1002 | ||
1003 | /******************************************************************* | |
1004 | * INTERNAL FUNCTIONS * | |
1005 | ******************************************************************/ | |
1006 | ||
1007 | /** | |
1008 | * Read in as many lines as possible | |
1009 | * either before eof or socket timeout occurs on the operation. | |
1010 | * With SMTP we can tell if we have more lines to read if the | |
1011 | * 4th character is '-' symbol. If it is a space then we don't | |
1012 | * need to read anything else. | |
1013 | * @access private | |
1014 | * @return string | |
1015 | */ | |
1016 | function get_lines() { | |
1017 | $data = ""; | |
1018 | while($str = fgets($this->smtp_conn,515)) { | |
1019 | if($this->do_debug >= 4) { | |
1020 | echo "SMTP -> get_lines(): \$data was \"$data\"" . | |
1021 | $this->CRLF; | |
1022 | echo "SMTP -> get_lines(): \$str is \"$str\"" . | |
1023 | $this->CRLF; | |
1024 | } | |
1025 | $data .= $str; | |
1026 | if($this->do_debug >= 4) { | |
1027 | echo "SMTP -> get_lines(): \$data is \"$data\"" . $this->CRLF; | |
1028 | } | |
1029 | # if the 4th character is a space then we are done reading | |
1030 | # so just break the loop | |
1031 | if(substr($str,3,1) == " ") { break; } | |
1032 | } | |
1033 | return $data; | |
1034 | } | |
1035 | ||
1036 | } | |
1037 | ||
1038 | ||
1039 | ?> |