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