CMS  Version 3.9
Public Member Functions | Public Attributes | List of all members
SMTP Class Reference
Email

Public Member Functions

 SMTP ()
 
 Connect ($host, $port=0, $tval=30)
 
 Connected ()
 
 Close ()
 
 Data ($msg_data)
 
 Expand ($name)
 
 Hello ($host="")
 
 Help ($keyword="")
 
 Mail ($from)
 
 Noop ()
 
 Quit ($close_on_error=true)
 
 Recipient ($to)
 
 Reset ()
 
 Send ($from)
 
 SendAndMail ($from)
 
 SendOrMail ($from)
 
 Turn ()
 
 Verify ($name)
 
 get_lines ()
 
 Authenticate ($username, $password)
 

Public Attributes

 $SMTP_PORT = 25
 
 $CRLF = "\r\n"
 
 $smtp_conn
 
 $error
 
 $helo_rply
 
 $do_debug
 

Detailed Description

Definition at line 54 of file smtp.inc.

Member Function Documentation

◆ Authenticate()

SMTP::Authenticate (   $username,
  $password 
)

Definition at line 980 of file smtp.inc.

980  {
981  // Start authentication
982  fputs($this->smtp_conn,"AUTH LOGIN" . $this->CRLF);
983 
984  $rply = $this->get_lines();
985  $code = substr($rply,0,3);
986 
987  if($code != 334) {
988  $this->error =
989  array("error" => "AUTH not accepted from server",
990  "smtp_code" => $code,
991  "smtp_msg" => substr($rply,4));
992  if($this->do_debug >= 1) {
993  echo "SMTP -> ERROR: " . $this->error["error"] .
994  ": " . $rply . $this->CRLF;
995  }
996  return false;
997  }
998 
999  // Send encoded username
1000  fputs($this->smtp_conn, base64_encode($username) . $this->CRLF);
1001 
1002  $rply = $this->get_lines();
1003  $code = substr($rply,0,3);
1004 
1005  if($code != 334) {
1006  $this->error =
1007  array("error" => "Username not accepted from server",
1008  "smtp_code" => $code,
1009  "smtp_msg" => substr($rply,4));
1010  if($this->do_debug >= 1) {
1011  echo "SMTP -> ERROR: " . $this->error["error"] .
1012  ": " . $rply . $this->CRLF;
1013  }
1014  return false;
1015  }
1016 
1017  // Send encoded password
1018  fputs($this->smtp_conn, base64_encode($password) . $this->CRLF);
1019 
1020  $rply = $this->get_lines();
1021  $code = substr($rply,0,3);
1022 
1023  if($code != 235) {
1024  $this->error =
1025  array("error" => "Password not accepted from server",
1026  "smtp_code" => $code,
1027  "smtp_msg" => substr($rply,4));
1028  if($this->do_debug >= 1) {
1029  echo "SMTP -> ERROR: " . $this->error["error"] .
1030  ": " . $rply . $this->CRLF;
1031  }
1032  return false;
1033  }
1034 
1035  return true;
1036  }
$username
$username
Definition: password_help.inc:54
SMTP\get_lines
get_lines()
Definition: smtp.inc:947
SMTP\$CRLF
$CRLF
Definition: smtp.inc:56
$code
$code
Definition: hide_hint.inc:36

◆ Close()

SMTP::Close ( )

Definition at line 179 of file smtp.inc.

179  {
180  $this->error = null; # so there is no confusion
181  $this->helo_rply = null;
182  if(!empty($this->smtp_conn)) {
183  # close the connection and cleanup
184  fclose($this->smtp_conn);
185  $this->smtp_conn = 0;
186  }
187  }

◆ Connect()

SMTP::Connect (   $host,
  $port = 0,
  $tval = 30 
)

Definition at line 94 of file smtp.inc.

94  {
95  # set the error val to null so there is no confusion
96  $this->error = null;
97 
98  # make sure we are __not__ connected
99  if($this->connected()) {
100  # ok we are connected! what should we do?
101  # for now we will just give an error saying we
102  # are already connected
103  $this->error =
104  array("error" => "Already connected to a server");
105  return false;
106  }
107 
108  if(empty($port)) {
109  $port = $this->SMTP_PORT;
110  }
111 
112  #connect to the smtp server
113  $this->smtp_conn = fsockopen($host, # the host of the server
114  $port, # the port to use
115  $errno, # error number if any
116  $errstr, # error message if any
117  $tval); # give up after ? secs
118  # verify we connected properly
119  if(empty($this->smtp_conn)) {
120  $this->error = array("error" => "Failed to connect to server",
121  "errno" => $errno,
122  "errstr" => $errstr);
123  if($this->do_debug >= 1) {
124  echo "SMTP -> ERROR: " . $this->error["error"] .
125  ": $errstr ($errno)" . $this->CRLF;
126  }
127  return false;
128  }
129 
130  # sometimes the SMTP server takes a little longer to respond
131  # so we will give it a longer timeout for the first read
132  # I have a report that on Windows systems this doesn't
133  # behave properly.
134  #socket_set_timeout($this->smtp_conn, 1, 0);
135 
136  # get any announcement stuff
137  $announce = $this->get_lines();
138 
139  # set the timeout of any socket functions at 1/10 of a second
140  #socket_set_timeout($this->smtp_conn, 0, 100000);
141 
142  if($this->do_debug >= 2) {
143  echo "SMTP -> FROM SERVER:" . $this->CRLF . $announce;
144  }
145 
146  return true;
147  }
SMTP\$SMTP_PORT
$SMTP_PORT
Definition: smtp.inc:55
to
$forumRequest to
Definition: forum_request_form.inc:51
message
$email message
Definition: test_email_form.inc:42

◆ Connected()

SMTP::Connected ( )

Definition at line 154 of file smtp.inc.

154  {
155  if(!empty($this->smtp_conn)) {
156  $sock_status = socket_get_status($this->smtp_conn);
157  if($sock_status["eof"]) {
158  # hmm this is an odd situation... the socket is
159  # valid but we aren't connected anymore
160  if($this->do_debug >= 1) {
161  echo "SMTP -> NOTICE:" . $this->CRLF .
162  "EOF caught while checking if connected";
163  }
164  $this->Close();
165  return false;
166  }
167  return true; # everything looks good
168  }
169  return false;
170  }
SMTP\Close
Close()
Definition: smtp.inc:179

◆ Data()

SMTP::Data (   $msg_data)

Definition at line 213 of file smtp.inc.

213  {
214  $this->error = null; # so no confusion is caused
215 
216  if(!$this->connected()) {
217  $this->error = array(
218  "error" => "Called Data() without being connected");
219  return false;
220  }
221 
222  fputs($this->smtp_conn,"DATA" . $this->CRLF);
223 
224  $rply = $this->get_lines();
225  $code = substr($rply,0,3);
226 
227  if($this->do_debug >= 2) {
228  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
229  }
230 
231  if($code != 354) {
232  $this->error =
233  array("error" => "DATA command not accepted from server",
234  "smtp_code" => $code,
235  "smtp_msg" => substr($rply,4));
236  if($this->do_debug >= 1) {
237  echo "SMTP -> ERROR: " . $this->error["error"] .
238  ": " . $rply . $this->CRLF;
239  }
240  return false;
241  }
242 
243  # the server is ready to accept data!
244  # according to rfc 821 we should not send more than 1000
245  # including the CRLF
246  # characters on a single line so we will break the data up
247  # into lines by \r and/or \n then if needed we will break
248  # each of those into smaller lines to fit within the limit.
249  # in addition we will be looking for lines that start with
250  # a period '.' and append and additional period '.' to that
251  # line. NOTE: this does not count towards are limit.
252 
253  # normalize the line breaks so we know the explode works
254  $msg_data = str_replace("\r\n","\n",$msg_data);
255  $msg_data = str_replace("\r","\n",$msg_data);
256  $lines = explode("\n",$msg_data);
257 
258  # we need to find a good way to determine is headers are
259  # in the msg_data or if it is a straight msg body
260  # currently I'm assuming rfc 822 definitions of msg headers
261  # and if the first field of the first line (':' sperated)
262  # does not contain a space then it _should_ be a header
263  # and we can process all lines before a blank "" line as
264  # headers.
265  $field = substr($lines[0],0,strpos($lines[0],":"));
266  $in_headers = false;
267  if(!empty($field) && !strstr($field," ")) {
268  $in_headers = true;
269  }
270 
271  $max_line_length = 980; # used below; set here for ease in change
272 
273  while(list(,$line) = @each($lines)) {
274  $lines_out = null;
275  if($line == "" && $in_headers) {
276  $in_headers = false;
277  }
278  # ok we need to break this line up into several
279  # smaller lines
280  while(strlen($line) > $max_line_length) {
281  $pos = strrpos(substr($line,0,$max_line_length)," ");
282  if($pos === false) {
283  $pos = $max_line_length;
284  }
285  $lines_out[] = substr($line,0,$pos);
286  $line = substr($line,$pos + 1);
287  # if we are processing headers we need to
288  # add a LWSP-char to the front of the new line
289  # rfc 822 on long msg headers
290  if($in_headers) {
291  $line = "\t" . $line;
292  }
293  }
294  $lines_out[] = $line;
295 
296  # now send the lines to the server
297  while(list(,$line_out) = @each($lines_out)) {
298  if(!empty($line_out) && $line_out[0] == ".") {
299  $line_out = "." . $line_out;
300  }
301  fputs($this->smtp_conn,$line_out . $this->CRLF);
302  }
303  }
304 
305  # ok all the message data has been sent so lets get this
306  # over with aleady
307  fputs($this->smtp_conn, $this->CRLF . "." . $this->CRLF);
308 
309  $rply = $this->get_lines();
310  $code = substr($rply,0,3);
311 
312  if($this->do_debug >= 2) {
313  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
314  }
315 
316  if($code != 250) {
317  $this->error =
318  array("error" => "DATA not accepted from server",
319  "smtp_code" => $code,
320  "smtp_msg" => substr($rply,4));
321  if($this->do_debug >= 1) {
322  echo "SMTP -> ERROR: " . $this->error["error"] .
323  ": " . $rply . $this->CRLF;
324  }
325  return false;
326  }
327  return true;
328  }
$field
$field
Definition: context_help_form.inc:44

◆ Expand()

SMTP::Expand (   $name)

Definition at line 346 of file smtp.inc.

346  {
347  $this->error = null; # so no confusion is caused
348 
349  if(!$this->connected()) {
350  $this->error = array(
351  "error" => "Called Expand() without being connected");
352  return false;
353  }
354 
355  fputs($this->smtp_conn,"EXPN " . $name . $this->CRLF);
356 
357  $rply = $this->get_lines();
358  $code = substr($rply,0,3);
359 
360  if($this->do_debug >= 2) {
361  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
362  }
363 
364  if($code != 250) {
365  $this->error =
366  array("error" => "EXPN not accepted from server",
367  "smtp_code" => $code,
368  "smtp_msg" => substr($rply,4));
369  if($this->do_debug >= 1) {
370  echo "SMTP -> ERROR: " . $this->error["error"] .
371  ": " . $rply . $this->CRLF;
372  }
373  return false;
374  }
375 
376  # parse the reply and place in our array to return to user
377  $entries = explode($this->CRLF,$rply);
378  while(list(,$l) = @each($entries)) {
379  $list[] = substr($l,4);
380  }
381 
382  return $rval;
383  }
$name
$name
Definition: upload.inc:54
$list
$list
Definition: list_images.inc:41

◆ get_lines()

SMTP::get_lines ( )

Definition at line 947 of file smtp.inc.

947  {
948  $data = "";
949  while($str = fgets($this->smtp_conn,515)) {
950  if($this->do_debug >= 4) {
951  echo "SMTP -> get_lines(): \$data was \"$data\"" .
952  $this->CRLF;
953  echo "SMTP -> get_lines(): \$str is \"$str\"" .
954  $this->CRLF;
955  }
956  $data .= $str;
957  if($this->do_debug >= 4) {
958  echo "SMTP -> get_lines(): \$data is \"$data\"" . $this->CRLF;
959  }
960  # if the 4th character is a space then we are done reading
961  # so just break the loop
962  if(substr($str,3,1) == " ") { break; }
963  }
964  return $data;
965  }

◆ Hello()

SMTP::Hello (   $host = "")

Definition at line 397 of file smtp.inc.

397  {
398  $this->error = null; # so no confusion is caused
399 
400  if(!$this->connected()) {
401  $this->error = array(
402  "error" => "Called Hello() without being connected");
403  return false;
404  }
405 
406  # if a hostname for the HELO wasn't specified determine
407  # a suitable one to send
408  if(empty($host)) {
409  # we need to determine some sort of appopiate default
410  # to send to the server
411  $host = "localhost";
412  }
413 
414  fputs($this->smtp_conn,"HELO " . $host . $this->CRLF);
415 
416  $rply = $this->get_lines();
417  $code = substr($rply,0,3);
418 
419  if($this->do_debug >= 2) {
420  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
421  }
422 
423  if($code != 250) {
424  $this->error =
425  array("error" => "HELO not accepted from server",
426  "smtp_code" => $code,
427  "smtp_msg" => substr($rply,4));
428  if($this->do_debug >= 1) {
429  echo "SMTP -> ERROR: " . $this->error["error"] .
430  ": " . $rply . $this->CRLF;
431  }
432  return false;
433  }
434 
435  $this->helo_rply = $rply;
436 
437  return true;
438  }

◆ Help()

SMTP::Help (   $keyword = "")

Definition at line 455 of file smtp.inc.

455  {
456  $this->error = null; # to avoid confusion
457 
458  if(!$this->connected()) {
459  $this->error = array(
460  "error" => "Called Help() without being connected");
461  return false;
462  }
463 
464  $extra = "";
465  if(!empty($keyword)) {
466  $extra = " " . $keyword;
467  }
468 
469  fputs($this->smtp_conn,"HELP" . $extra . $this->CRLF);
470 
471  $rply = $this->get_lines();
472  $code = substr($rply,0,3);
473 
474  if($this->do_debug >= 2) {
475  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
476  }
477 
478  if($code != 211 && $code != 214) {
479  $this->error =
480  array("error" => "HELP not accepted from server",
481  "smtp_code" => $code,
482  "smtp_msg" => substr($rply,4));
483  if($this->do_debug >= 1) {
484  echo "SMTP -> ERROR: " . $this->error["error"] .
485  ": " . $rply . $this->CRLF;
486  }
487  return false;
488  }
489 
490  return $rply;
491  }
$keyword
$keyword
Definition: fileshare_library_files.inc:38

◆ Mail()

SMTP::Mail (   $from)

Definition at line 507 of file smtp.inc.

507  {
508  $this->error = null; # so no confusion is caused
509 
510  if(!$this->connected()) {
511  $this->error = array(
512  "error" => "Called Mail() without being connected");
513  return false;
514  }
515 
516  fputs($this->smtp_conn,"MAIL FROM:" . $from . $this->CRLF);
517 
518  $rply = $this->get_lines();
519  $code = substr($rply,0,3);
520 
521  if($this->do_debug >= 2) {
522  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
523  }
524 
525  if($code != 250) {
526  $this->error =
527  array("error" => "MAIL not accepted from server",
528  "smtp_code" => $code,
529  "smtp_msg" => substr($rply,4));
530  if($this->do_debug >= 1) {
531  echo "SMTP -> ERROR: " . $this->error["error"] .
532  ": " . $rply . $this->CRLF;
533  }
534  return false;
535  }
536  return true;
537  }
$from
$from
Definition: select_related.inc:28

◆ Noop()

SMTP::Noop ( )

Definition at line 549 of file smtp.inc.

549  {
550  $this->error = null; # so no confusion is caused
551 
552  if(!$this->connected()) {
553  $this->error = array(
554  "error" => "Called Noop() without being connected");
555  return false;
556  }
557 
558  fputs($this->smtp_conn,"NOOP" . $this->CRLF);
559 
560  $rply = $this->get_lines();
561  $code = substr($rply,0,3);
562 
563  if($this->do_debug >= 2) {
564  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
565  }
566 
567  if($code != 250) {
568  $this->error =
569  array("error" => "NOOP not accepted from server",
570  "smtp_code" => $code,
571  "smtp_msg" => substr($rply,4));
572  if($this->do_debug >= 1) {
573  echo "SMTP -> ERROR: " . $this->error["error"] .
574  ": " . $rply . $this->CRLF;
575  }
576  return false;
577  }
578  return true;
579  }

◆ Quit()

SMTP::Quit (   $close_on_error = true)

Definition at line 592 of file smtp.inc.

592  {
593  $this->error = null; # so there is no confusion
594 
595  if(!$this->connected()) {
596  $this->error = array(
597  "error" => "Called Quit() without being connected");
598  return false;
599  }
600 
601  # send the quit command to the server
602  fputs($this->smtp_conn,"quit" . $this->CRLF);
603 
604  # get any good-bye messages
605  $byemsg = $this->get_lines();
606 
607  if($this->do_debug >= 2) {
608  echo "SMTP -> FROM SERVER:" . $this->CRLF . $byemsg;
609  }
610 
611  $rval = true;
612  $e = null;
613 
614  $code = substr($byemsg,0,3);
615  if($code != 221) {
616  # use e as a tmp var cause Close will overwrite $this->error
617  $e = array("error" => "SMTP server rejected quit command",
618  "smtp_code" => $code,
619  "smtp_rply" => substr($byemsg,4));
620  $rval = false;
621  if($this->do_debug >= 1) {
622  echo "SMTP -> ERROR: " . $e["error"] . ": " .
623  $byemsg . $this->CRLF;
624  }
625  }
626 
627  if(empty($e) || $close_on_error) {
628  $this->Close();
629  }
630 
631  return $rval;
632  }

◆ Recipient()

SMTP::Recipient (   $to)

Definition at line 646 of file smtp.inc.

646  {
647  $this->error = null; # so no confusion is caused
648 
649  if(!$this->connected()) {
650  $this->error = array(
651  "error" => "Called Recipient() without being connected");
652  return false;
653  }
654 
655  fputs($this->smtp_conn,"RCPT TO:" . $to . $this->CRLF);
656 
657  $rply = $this->get_lines();
658  $code = substr($rply,0,3);
659 
660  if($this->do_debug >= 2) {
661  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
662  }
663 
664  if($code != 250 && $code != 251) {
665  $this->error =
666  array("error" => "RCPT not accepted from server",
667  "smtp_code" => $code,
668  "smtp_msg" => substr($rply,4));
669  if($this->do_debug >= 1) {
670  echo "SMTP -> ERROR: " . $this->error["error"] .
671  ": " . $rply . $this->CRLF;
672  }
673  return false;
674  }
675  return true;
676  }
$to
$to
Definition: select_related.inc:9

◆ Reset()

SMTP::Reset ( )

Definition at line 690 of file smtp.inc.

690  {
691  $this->error = null; # so no confusion is caused
692 
693  if(!$this->connected()) {
694  $this->error = array(
695  "error" => "Called Reset() without being connected");
696  return false;
697  }
698 
699  fputs($this->smtp_conn,"RSET" . $this->CRLF);
700 
701  $rply = $this->get_lines();
702  $code = substr($rply,0,3);
703 
704  if($this->do_debug >= 2) {
705  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
706  }
707 
708  if($code != 250) {
709  $this->error =
710  array("error" => "RSET failed",
711  "smtp_code" => $code,
712  "smtp_msg" => substr($rply,4));
713  if($this->do_debug >= 1) {
714  echo "SMTP -> ERROR: " . $this->error["error"] .
715  ": " . $rply . $this->CRLF;
716  }
717  return false;
718  }
719 
720  return true;
721  }

◆ Send()

SMTP::Send (   $from)

Definition at line 739 of file smtp.inc.

739  {
740  $this->error = null; # so no confusion is caused
741 
742  if(!$this->connected()) {
743  $this->error = array(
744  "error" => "Called Send() without being connected");
745  return false;
746  }
747 
748  fputs($this->smtp_conn,"SEND FROM:" . $from . $this->CRLF);
749 
750  $rply = $this->get_lines();
751  $code = substr($rply,0,3);
752 
753  if($this->do_debug >= 2) {
754  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
755  }
756 
757  if($code != 250) {
758  $this->error =
759  array("error" => "SEND not accepted from server",
760  "smtp_code" => $code,
761  "smtp_msg" => substr($rply,4));
762  if($this->do_debug >= 1) {
763  echo "SMTP -> ERROR: " . $this->error["error"] .
764  ": " . $rply . $this->CRLF;
765  }
766  return false;
767  }
768  return true;
769  }

◆ SendAndMail()

SMTP::SendAndMail (   $from)

Definition at line 787 of file smtp.inc.

787  {
788  $this->error = null; # so no confusion is caused
789 
790  if(!$this->connected()) {
791  $this->error = array(
792  "error" => "Called SendAndMail() without being connected");
793  return false;
794  }
795 
796  fputs($this->smtp_conn,"SAML FROM:" . $from . $this->CRLF);
797 
798  $rply = $this->get_lines();
799  $code = substr($rply,0,3);
800 
801  if($this->do_debug >= 2) {
802  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
803  }
804 
805  if($code != 250) {
806  $this->error =
807  array("error" => "SAML not accepted from server",
808  "smtp_code" => $code,
809  "smtp_msg" => substr($rply,4));
810  if($this->do_debug >= 1) {
811  echo "SMTP -> ERROR: " . $this->error["error"] .
812  ": " . $rply . $this->CRLF;
813  }
814  return false;
815  }
816  return true;
817  }

◆ SendOrMail()

SMTP::SendOrMail (   $from)

Definition at line 835 of file smtp.inc.

835  {
836  $this->error = null; # so no confusion is caused
837 
838  if(!$this->connected()) {
839  $this->error = array(
840  "error" => "Called SendOrMail() without being connected");
841  return false;
842  }
843 
844  fputs($this->smtp_conn,"SOML FROM:" . $from . $this->CRLF);
845 
846  $rply = $this->get_lines();
847  $code = substr($rply,0,3);
848 
849  if($this->do_debug >= 2) {
850  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
851  }
852 
853  if($code != 250) {
854  $this->error =
855  array("error" => "SOML not accepted from server",
856  "smtp_code" => $code,
857  "smtp_msg" => substr($rply,4));
858  if($this->do_debug >= 1) {
859  echo "SMTP -> ERROR: " . $this->error["error"] .
860  ": " . $rply . $this->CRLF;
861  }
862  return false;
863  }
864  return true;
865  }

◆ SMTP()

SMTP::SMTP ( )

Definition at line 69 of file smtp.inc.

69  {
70  $this->smtp_conn = 0;
71  $this->error = null;
72  $this->helo_rply = null;
73 
74  $this->do_debug = 0;
75  }

◆ Turn()

SMTP::Turn ( )

Definition at line 880 of file smtp.inc.

880  {
881  $this->error = array("error" => "This method, TURN, of the SMTP ".
882  "is not implemented");
883  if($this->do_debug >= 1) {
884  echo "SMTP -> NOTICE: " . $this->error["error"] . $this->CRLF;
885  }
886  return false;
887  }

◆ Verify()

SMTP::Verify (   $name)

Definition at line 902 of file smtp.inc.

902  {
903  $this->error = null; # so no confusion is caused
904 
905  if(!$this->connected()) {
906  $this->error = array(
907  "error" => "Called Verify() without being connected");
908  return false;
909  }
910 
911  fputs($this->smtp_conn,"VRFY " . $name . $this->CRLF);
912 
913  $rply = $this->get_lines();
914  $code = substr($rply,0,3);
915 
916  if($this->do_debug >= 2) {
917  echo "SMTP -> FROM SERVER:" . $this->CRLF . $rply;
918  }
919 
920  if($code != 250 && $code != 251) {
921  $this->error =
922  array("error" => "VRFY failed on name '$name'",
923  "smtp_code" => $code,
924  "smtp_msg" => substr($rply,4));
925  if($this->do_debug >= 1) {
926  echo "SMTP -> ERROR: " . $this->error["error"] .
927  ": " . $rply . $this->CRLF;
928  }
929  return false;
930  }
931  return $rply;
932  }

Member Data Documentation

◆ $CRLF

SMTP::$CRLF = "\r\n"

Definition at line 56 of file smtp.inc.

◆ $do_debug

SMTP::$do_debug

Definition at line 62 of file smtp.inc.

◆ $error

SMTP::$error

Definition at line 59 of file smtp.inc.

◆ $helo_rply

SMTP::$helo_rply

Definition at line 60 of file smtp.inc.

◆ $smtp_conn

SMTP::$smtp_conn

Definition at line 58 of file smtp.inc.

◆ $SMTP_PORT

SMTP::$SMTP_PORT = 25

Definition at line 55 of file smtp.inc.

The documentation for this class was generated from the following file: