ulvis.paste.net

Paste Search Dynamic
Recent pastes
libmail.php
  1. <? php
  2. / *
  3. -------------------------------------------------
  4. php_libmail v 1.6.0 (09.12.2011) webi.ru
  5. Universal PHP class for sending mail
  6. Can send mail via smtp (using sockets), or via the standard function mail ()
  7. http://webi.ru/webi_files/php_libmail.html
  8. -----------------------
  9. Developed by Leo West - [email protected]
  10. continued webi.ru
  11. on all questions write to [email protected]
  12. ________________________________________________
  13.  
  14. What's new:
  15.  
  16. Version 1.6.0 (09/12/2011)
  17. Added ability to add names to mailboxes
  18. Operates in From, To, and ReplyTo
  19. The name is added through the separator ';' eg
  20. $ m-> To ("Maxim; [email protected]");
  21.  
  22. -------------------------------------------
  23. Version 1.5.1 (07.02.2011)
  24. Modernization of the function of checking email addresses for validity under php 5.2 and above.
  25.  
  26. -------------------------------------------
  27. Version 1.5 (28.02.2010)
  28. Added support for sending mail using SMTP
  29.  
  30. -------------------------------------------
  31. Version 1.4 (24.02.2010)
  32.  
  33. adaptation to Russian encoding
  34. the encoding should now be specified not in the body of the message as it was before, but when the class is initialized, for example, $ m = new Mail ('windows-1251');
  35. if you do not specify a character set, the default is windows-1251
  36. -
  37. changed attachment files.
  38. added a new parameter, the name of the file.
  39. now you can give it another name by attaching a file. this is useful when attaching temporary files downloaded via upload, since their names do not match the real ones.
  40. example $ m-> Attach ("/toto.gif", "asd.gif" "image / gif")
  41. if you do not specify a new name, the name from the path of the attached file is taken
  42. -
  43. added the ability to send letters in html format
  44. _______________________________________________
  45.  
  46.  
  47. example
  48.  
  49. include "libmail.php";
  50.  
  51. $ m = new Mail ('windows-1251'); // you can immediately specify the encoding, you can not specify anything ($ m = new Mail;)
  52. $ m-> From ("Sergey; [email protected]"); // from whom You can use a name, separated by a semicolon
  53. $ m-> ReplyTo ('Sergey Vadimych; [email protected]'); // where to answer, you can also specify a name
  54. $ m-> To ("[email protected]"); // to whom, this field is also allowed to specify a name
  55. $ m-> Subject (the "subject of the message");
  56. $ m-> Body ("Message.");
  57. $ m-> Cc ("[email protected]"); // to whom to send a copy of the letter
  58. $ m-> Bcc ("[email protected]"); // to whom to send a hidden copy
  59. $ m-> Priority (4); // set priority
  60. $ m-> Attach ("/toto.gif", "", "image / gif"); // attached file of type image / gif. file type is optional
  61. $ m-> smtp_on ("smtp.asd.com", "login", "passw", 25, 10); // using the eu command, sending will go through smtp
  62. $ m-> Send (); // send
  63. echo "The letter was sent, here is the original text of the letter: <br> <pre>", $ m-> Get (), "</ pre>";
  64.  
  65. Detailed instructions can be found at http://webi.ru/webi_files/php_libmail.html
  66.  
  67. * /
  68.  
  69.  
  70. class Mail
  71. {
  72.        / * the definition of variables goes through VAR, to ensure work in php older versions
  73.        address arrays to whom to send
  74.        @var array
  75.        * /
  76.        var $ sendto = array ( ) ;
  77.        / *
  78.        @var array
  79.        * /
  80.        var  $ acc = array ( ) ;
  81.        / *
  82.        @var array
  83.        * /
  84.        var $ abcc = array ( ) ;
  85.        / *
  86.        attach files
  87.        @var array
  88.        * /
  89.        var $ aattach = array ( ) ;
  90.        / *
  91.        header array
  92.        @var array
  93.        * /
  94.        var $ xheaders = array ( ) ;
  95.        / *
  96.        priorities
  97.        @var array
  98.        * /
  99.        var $ priorities = array ( '1 (Highest)' , '2 (High)' , '3 (Normal)' , '4 (Low)' , '5 (Lowest)' ) ;
  100.        / *
  101.        default encoding
  102.        @var string
  103.        * /
  104.        var  $ charset = "windows-1251" ;
  105.        var  $ ctencoding = "8bit" ;
  106.        var  $ receipt = 0 ;
  107.        var  $ text_html = "text / plain" ; // the format of the letter. default text
  108.        var  $ smtp_on = false ;    // sending via smtp. disabled by default
  109.        var  $ names_email = array ( ) ; // names for email addresses to pretend ("sergey" <[email protected]>)
  110.  
  111.        / *
  112.        The constructor is also declared old for compatibility with old versions of php
  113.        went the designer.
  114.        incoming letter encoding parameter
  115.        modified webi.ru
  116.        * /
  117.  
  118.        function Mail ( $ charset = "" )
  119.        {
  120.                $ this -> autoCheck ( true ) ;
  121.                $ this -> boundary = "-" . md5 ( uniqid ( "myboundary" ) ) ;
  122.  
  123.  
  124.                if ( $ charset ! = "" ) {
  125.                        $ this -> charset = strtolower ( $ charset ) ;
  126.                        if ( $ this -> charset == "us-ascii" )
  127.                        $ this -> ctencoding = "7bit" ;
  128.                }
  129.        }
  130.  
  131.  
  132.        / *
  133.  
  134.        enable disable validation email
  135.        example: autoCheck (true) check enabled
  136.        by default, the test is enabled
  137.  
  138.  
  139.        * /
  140.        function autoCheck ( $ bool )
  141.        {
  142.                if ( $ bool )
  143.                $ this -> checkAddress = true ;
  144.                else
  145.                $ this -> checkAddress = false ;
  146.        }
  147.  
  148.  
  149.        / *
  150.  
  151.        Letter subject
  152.        changes to the coding of non-Latin characters
  153.  
  154.        * /
  155.        function Subject ( $ subject )
  156.        {
  157.  
  158.                $ this -> xheaders [ 'Subject' ] = "=?" . $ this -> charset . "? Q?" . str_replace ( "+" , "_" , str_replace ( "%" , "=" , urlencode ( strtr ( $ subject , " \ r \ n " , "" ) ) ) ) . "? =" ;
  159.  
  160.        }
  161.  
  162.  
  163.        / *
  164.  
  165.        from whom
  166.        * /
  167.  
  168.        function From ( $ from )
  169.        {
  170.  
  171.                if ( ! is_string ( $ from ) ) {
  172.                        echo "error, From must be a string" ;
  173.                        exit ;
  174.                }
  175.                $ temp_mass = explode ( ';' , $ from ) ; // divide by separator to highlight the name
  176.                if ( count ( $ temp_mass ) == 2 ) // if it was possible to break into two elements
  177.                {
  178.                        $ this -> names_email [ 'from' ] = $ temp_mass [ 0 ] ; // name first part
  179.                        $ this -> xheaders [ 'From' ] = $ temp_mass [ 1 ] ; // address second part
  180.                }
  181.                else // and if the name is not defined
  182.                {
  183.                        $ this -> names_email [ 'from' ] = '' ;
  184.                        $ this -> xheaders [ 'From' ] = $ from ;
  185.                }
  186.        }
  187.  
  188.        / *
  189.        to which address to answer
  190.  
  191.        * /
  192.        function ReplyTo ( $ address )
  193.        {
  194.  
  195.                if ( ! is_string ( $ address ) )
  196.                return false ;
  197.  
  198.                $ temp_mass = explode ( ';' , $ address ) ; // divide by separator to highlight the name
  199.  
  200.                if ( count ( $ temp_mass ) ==2 ) // if it was possible to break into two elements
  201.                {
  202.                        $ this -> names_email [ 'Reply-To' ] = $ temp_mass [ 0 ] ; // name first part
  203.                        $ this -> xheaders [ 'Reply-To' ] = $ temp_mass [ 1 ] ; // address second part
  204.                }
  205.                else // and if the name is not defined
  206.                {
  207.                        $ this -> names_email [ 'Reply-To' ] = '' ;
  208.                        $ this -> xheaders [ 'Reply-To' ] = $ address ;
  209.                }
  210.  
  211.  
  212.        }
  213.  
  214.  
  215.        / *
  216.        Add a header to receive a read receipt. the return address is taken from "From" (or from "ReplyTo" if specified)
  217.  
  218.        * /
  219.  
  220.        function Receipt ( )
  221.        {
  222.                $ this -> receipt = 1 ;
  223.        }
  224.  
  225.  
  226.        / *
  227.        set the mail recipient
  228.        @param string $ to email address, accept both a single address or an array of addresses
  229.  
  230.        * /
  231.  
  232.        function To ( $ to )
  233.        {
  234.  
  235.                // if it's an array
  236.                 if ( is_array ( $ to ) )
  237.                 {
  238.                         foreach ( $ to as $ key => $ value ) // sort the array and add it to the array for sending via smtp
  239.                         {
  240.  
  241.                                 $ temp_mass = explode ( ';' , $ value ) ; // divide by separator to highlight the name
  242.  
  243.                                 if ( count ( $ temp_mass ) == 2 ) // if it was possible to break into two elements
  244.                                 {                                      
  245.                                         $ this -> smtpsendto [ $ temp_mass [ 1 ] ] = $ temp_mass [ 1 ] ; // keys and values ​​are the same to exclude duplicate addresses
  246.                                         $ this -> names_email [ 'To' ] [ $ temp_mass [ 1 ] ] = $ temp_mass [ 0 ] ; // name first part
  247.                                         $ this -> sendto [ ] = $ temp_mass [ 1 ] ;
  248.                                 }
  249.                                 else // and if the name is not defined
  250.                                 {
  251.                                         $ this -> smtpsendto [ $ value ] = $ value ; // keys and values ​​are the same to exclude duplicate addresses
  252.                                         $ this -> names_email [ 'To' ] [ $ value ] = '' ; // name first part
  253.                                         $ this -> sendto [ ] = $ value ;
  254.                                 }
  255.                         }
  256.                 }
  257.                 else
  258.                 {
  259.                                 $ temp_mass = explode ( ';' , $ to ) ; // divide by separator to highlight the name
  260.  
  261.                                 if ( count ( $ temp_mass ) == 2 ) // if it was possible to break into two elements
  262.                                 {
  263.                                        
  264.                                         $ this -> sendto [ ] = $ temp_mass [ 1 ] ;
  265.                                 $ this -> smtpsendto [ $ temp_mass [ 1 ] ] = $ temp_mass [ 1 ] ; // keys and values ​​are the same to exclude duplicate addresses
  266.                                         $ this -> names_email [ 'To' ] [ $ temp_mass [ 1 ] ] = $ temp_mass [ 0 ] ; // name first part
  267.                                 }
  268.                                 else // and if the name is not defined
  269.                                 {
  270.                                        
  271.                                         $ this -> sendto [ ] = $ to ;
  272.                                 $ this -> smtpsendto [ $ to ] = $ to ; // keys and values ​​are the same to exclude duplicate addresses
  273.  
  274.                                         $ this -> names_email [ 'To' ] [ $ to ] = '' ; // name first part
  275.                                 }
  276.                        
  277.                        
  278.                        
  279.                 }
  280.  
  281.                 if ( $ this -> checkAddress == true )
  282.                 $ this -> CheckAdresses ( $ this -> sendto ) ;
  283.  
  284.         }
  285.  
  286.  
  287.         / * Cc ()
  288.         * installation of CC padding (an open copy, all recipients will see where the copy left)
  289.         * $ cc: email address (es), accept both array and string
  290.         * /
  291.  
  292.         function Cc ( $ cc )
  293.         {
  294.                 if ( is_array ( $ cc ) )
  295.                 {
  296.                         $ this -> acc = $ cc ;
  297.  
  298.                         foreach ( $ cc as $ key => $ value ) // sort the array and add it to the array for sending via smtp
  299.                         {
  300.                                 $ this -> smtpsendto [ $ value ] = $ value ; // keys and values ​​are the same to exclude duplicate addresses
  301.                         }
  302.                 }
  303.                 else
  304.                 {
  305.                         $ this -> acc [ ] = $ cc ;
  306.                         $ this -> smtpsendto [ $ cc ] = $ cc ; // keys and values ​​are the same to exclude duplicate addresses
  307.                 }
  308.  
  309.                 if ( $ this -> checkAddress == true )
  310.                 $ this -> CheckAdresses ( $ this -> acc ) ;
  311.  
  312.         }
  313.  
  314.  
  315.  
  316.         / * Bcc ()
  317.         * hidden copy. Will not put the title to the person who left the letter
  318.         * $ bcc: email address (es), accept both array and string
  319.         * /
  320.  
  321.         function Bcc ( $ bcc )
  322.         {
  323.                 if ( is_array ( $ bcc ) )
  324.                 {
  325.                         $ this -> abcc = $ bcc ;
  326.                         foreach ( $ bcc as $ key => $ value ) // sort the array and add it to the array for sending via smtp
  327.                         {
  328.                                 $ this -> smtpsendto [ $ value ] = $ value ; // keys and values ​​are the same to exclude duplicate addresses
  329.                         }
  330.                 }
  331.                 else
  332.                 {
  333.                         $ this -> abcc [ ] = $ bcc ;
  334.                         $ this -> smtpsendto [ $ bcc ] = $ bcc ; // keys and values ​​are the same to exclude duplicate addresses
  335.                 }
  336.  
  337.                 if ( $ this -> checkAddress == true )
  338.                 $ this -> CheckAdresses ( $ this -> abcc ) ;
  339.         }
  340.  
  341.  
  342.         / * Body (text [text_html])
  343.         * $ text_html in what format will the letter, in the text or html. the default is text
  344.         * /
  345.         function Body ( $ body , $ text_html = "" )
  346.         {
  347.                 $ this -> body = $ body ;
  348.  
  349.                 if ( $ text_html == "html" ) $ this -> text_html = "text / html" ;
  350.  
  351.         }
  352.  
  353.  
  354.         / * Organization ($ org)
  355.         * set the Organization header
  356.         * /
  357.  
  358.         function Organization ( $ org )
  359.         {
  360.                 if ( trim ( $ org ! = "" )  )
  361.                 $ this -> xheaders [ 'Organization' ] = $ org ;
  362.         }
  363.  
  364.  
  365.         / * Priority ($ priority)
  366.         * set the mail priority
  367.         * $ priority: integer taken between 1 (highest) and 5 (lowest)
  368.         * ex: $ mail-> Priority (1); => Highest
  369.         * /
  370.  
  371.         function Priority ( $ priority )
  372.         {
  373.                 if ( ! intval ( $ priority ) )
  374.                 return false ;
  375.  
  376.                 if ( ! isset ( $ this -> priorities [ $ priority - 1 ] ) )
  377.                 return false ;
  378.  
  379.                 $ this -> xheaders [ "X-Priority" ] = $ this -> priorities [ $ priority - 1 ] ;
  380.  
  381.                 return true ;
  382.  
  383.         }
  384.  
  385.  
  386.         / *
  387.         Attached files
  388.  
  389.         @param string $ filename: path to the file to send
  390.         @param string $ webi_filename: the actual name of the file. if you suddenly insert a temporary file, then its name will fuck what ..
  391.         @param string $ filetype: MIME type of file. by default 'application / x-unknown-content-type'
  392.         @param string $ disposition: Instructions to the mail client how to display the attached file ("inline") as part of the letter or ("attachment") as an attached file
  393.         * /
  394.  
  395.         function Attach ( $ filename , $ webi_filename = "" , $ filetype = "" , $ disposition = "inline" )
  396.         {
  397.                 // TODO: if no file type is specified, put an unknown type
  398.                 if ( $ filetype == "" )
  399.                 $ filetype = "application / x-unknown-content-type" ;
  400.  
  401.                 $ this -> aattach [ ] = $ filename ;
  402.                 $ this -> webi_filename [ ] = $ webi_filename ;
  403.                 $ this -> actype [ ] = $ filetype ;
  404.                 $ this -> adispo [ ] = $ disposition ;
  405.         }
  406.  
  407.         / *
  408.  
  409.         We collect letter
  410.  
  411.  
  412.         * /
  413.         function BuildMail ( )
  414.         {
  415.  
  416.                 $ this -> headers = "" ;
  417.  
  418.                 // create a TO header.
  419.                 // adding names to addresses
  420.         foreach ( $ this -> sendto as $ key => $ value )
  421.         {
  422.                
  423.                 if ( strlen ( $ this -> names_email [ 'To' ] [ $ value ] ) ) $ temp_mass [ ] = "=?" . $ this -> charset . "? Q?" . str_replace ( "+" , "_" , str_replace ( "%" , "=" , urlencode ( strtr ( $ this -> names_email [ 'To', " \ r \ n " , "" ) ) ) ) . "? = <" . $ value . ">" ;
  424.                 else $ temp_mass [ ] = $ value ;
  425.         }
  426.        
  427.                 $ this -> xheaders [ 'To' ] = implode ( "," , $ temp_mass ) ; // this header will not be needed when sending via mail ()
  428.  
  429.                 if ( count ( $ this -> acc ) > 0 )
  430.                 $ this -> xheaders [ 'CC' ] = implode ( "," , $ this -> acc ) ;
  431.  
  432.                 if ( count ( $ this -> abcc ) > 0 )
  433.                 $ this -> xheaders [ 'BCC' ] = implode ( "," , $ this -> abcc ) ;  // this header will not be needed when sending via smtp
  434.  
  435.  
  436.                 if ( $ this -> receipt ) {
  437.                         if ( isset ( $ this -> xheaders [ "Reply-To" ] ) )
  438.                         $ this -> xheaders [ "Disposition-Notification-To" ] = $ this -> xheaders [ "Reply-To" ] ;
  439.                         else
  440.                         $ this -> xheaders [ "Disposition-Notification-To" ] = $ this -> xheaders [ 'From' ] ;
  441.                 }
  442.  
  443.                 if ( $ this -> charset ! = "" ) {
  444.                         $ this -> xheaders [ "Mime-Version" ] = "1.0" ;
  445.                         $ this -> xheaders [ "Content-Type" ] = $ this -> text_html . "; charset = $ this-> charset " ;
  446.                         $ this -> xheaders [ "Content-Transfer-Encoding" ] = $ this -> ctencoding ;
  447.                 }
  448.  
  449.                 $ this -> xheaders [ "X-Mailer" ] = "Php_libMail_v_1.5 (webi.ru)" ;
  450.  
  451.                 // insert files
  452.                 if ( count ( $ this -> aattach ) > 0 ) {
  453.                         $ this -> _build_attachement ( ) ;
  454.                 } else {
  455.                         $ this -> fullBody = $ this -> body ;
  456.                 }
  457.  
  458.  
  459.  
  460.                 // create headers if sending goes through smtp
  461.                 if ( $ this -> smtp_on )
  462.                 {
  463.  
  464.                         // break (FROM - from whom) to the user and domain. domain will be required in title
  465.                         $ user_domen = explode ( '@' , $ this -> xheaders [ 'From' ] ) ;
  466.  
  467.                         $ this -> headers = "Date:" . date ( "D, j MYG: i: s" ) . "+0700 \ r \ n " ;
  468.                         $ this -> headers . = "Message-ID: <" . rand ( ) . "." . date ( "YmjHis" ) . "@" . $ user_domen [ 1 ] . "> \ r \ n " ;
  469.  
  470.  
  471.                         reset ( $ this -> xheaders ) ;
  472.                         while ( list ( $ hdr , $ value ) = each ( $ this -> xheaders )  ) {
  473.                                 if ( $ hdr == "From" and strlen ( $ this -> names_email [ 'from' ] ) ) $ this -> headers . = $ hdr . ": =?" . $ this -> charset . "? Q?" . str_replace ( "+" , "_" , str_replace ( "%" , "=" , urlencode ( strtr ( $ this ->] , " \ r \ n " , "" ) ) ) ) . "? = <" . $ value . "> \ r \ n " ;
  474.                                 elseif ( $ hdr == "Reply-To" and strlen ( $ this -> names_email [ 'Reply-To' ] ) ) $ this -> headers . = $ hdr . ": =?" . $ this -> charset . "? Q?" . str_replace ( "+" , "_" , str_replace ( "%" , "=" , urlencode ( strtr ( $ this ->'Reply-To' ] , " \ r \ n " , "" ) ) ) ) . "? = <" . $ value . "> \ r \ n " ;
  475.                                 elseif ( $ hdr ! = "BCC" ) $ this -> headers . = $ hdr . ":" . $ value . " \ r \ n " ; // skip header to send a hidden copy
  476.  
  477.                         }
  478.  
  479.  
  480.  
  481.                 }
  482.                 // create headers if sending goes via mail ()
  483.                 else
  484.                 {
  485.                         reset ( $ this -> xheaders ) ;
  486.                         while ( list ( $ hdr , $ value ) = each ( $ this -> xheaders )  ) {
  487.                                 if ( $ hdr == "From" and strlen ( $ this -> names_email [ 'from' ] ) ) $ this -> headers . = $ hdr . ": =?" . $ this -> charset . "? Q?" . str_replace ( "+" , "_" , str_replace ( "%" , "=" , urlencode ( strtr ( $ this -> \ r \ n " , "" ) ) ) ) . "? = <" . $ value . "> \ r \ n " ;
  488.                                elseif ( $ hdr == "Reply-To" and strlen ( $ this -> names_email [ 'Reply-To' ] ) ) $ this -> headers . = $ hdr . ": =?" . $ this -> charset . "? Q?" . str_replace ( "+" , "_" , str_replace ( "%" , "=" , urlencode ( strtr ( $ this ->'Reply-To' ] , " \ r \ n " , "" ) ) ) ) . "? = <" . $ value . "> \ r \ n " ;
  489.                                elseif ( $ hdr ! = "Subject" and $ hdr ! = "To" ) $ this -> headers . = " $ hdr : $ value \ n " ; // skip the headers to whom and the topic ... they will insert themselves
  490.                        }
  491.                }
  492.  
  493.  
  494.  
  495.  
  496.        }
  497.  
  498.        // enable sending via smtp using sockets
  499.        // after starting this function, sending via smtp is enabled
  500.        // to send through a secure connection the server should be specified with the addition of "ssl: //" for example, so "ssl: //smtp.gmail.com"
  501.         function smtp_on ( $ smtp_serv , $ login , $ pass , $ port = 25 , $ timeout = 5 )
  502.         {
  503.                 $ this -> smtp_on = true ; // enable sending via smtp
  504.  
  505.                 $ this -> smtp_serv = $ smtp_serv ;
  506.                 $ this -> smtp_login = $ login ;
  507.                 $ this -> smtp_pass = $ pass ;
  508.                 $ this -> smtp_port = $ port ;
  509.                 $ this -> smtp_timeout = $ timeout ;
  510.         }
  511.  
  512.         function get_data ( $ smtp_conn )
  513.         {
  514.                 $ data = "" ;
  515.                 while ( $ str = fgets ( $ smtp_conn , 515 ) )
  516.                 {
  517.                         $ data . = $ str ;
  518.                         if ( substr ( $ str , 3 , 1 ) == "" ) { break ; }
  519.                 }
  520.                 return $ data ;
  521.         }
  522.  
  523.         / *
  524.         sending letter
  525.  
  526.         * /
  527.         function Send ( )
  528.         {
  529.                 $ this -> BuildMail ( ) ;
  530.                 $ this -> strTo = implode ( "," , $ this -> sendto ) ;
  531.  
  532.                 // if sending without using smtp
  533.                 if ( ! $ this -> smtp_on )
  534.                 {
  535.                         $ res = @ mail ( $ this -> strTo , $ this -> xheaders [ 'Subject' ] , $ this -> fullBody , $ this -> headers ) ;
  536.                 }
  537.                 else // if through smtp
  538.                 {
  539.  
  540.                         if ( ! $ this -> smtp_serv OR ! $ this -> smtp_login OR ! $ this -> smtp_pass OR ! $ this -> smtp_port ) return false ; // if there is not at least one of the main data for the connection, we exit with an error
  541.  
  542.  
  543.  
  544.                         // break (FROM - from whom) to the user and domain. user will need a greeting with a servo
  545.                         $ user_domen = explode ( '@' , $ this -> xheaders [ 'From' ] ) ;
  546.  
  547.  
  548.                         $ this -> smtp_log = '' ;
  549.                         $ smtp_conn = fsockopen ( $ this -> smtp_serv , $ this -> smtp_port , $ errno , $ errstr , $ this -> smtp_timeout ) ;
  550.                         the if ( ! $ smtp_conn ) { $ the this -> smtp_log . = "connection to the server has not passed \ n \ n " ; fclose ( $ smtp_conn ) ; return ; }
  551.  
  552.                         $ this -> smtp_log . = $ data = $ this -> get_data ( $ smtp_conn ) . " \ n " ;
  553.  
  554.                         fputs ( $ smtp_conn , "EHLO" . $ user_domen [ 0 ] . " \ r \ n " ) ;
  555.                         $ this -> smtp_log . = "Me: EHLO" . $ user_domen [ 0 ] . " \ n " ;
  556.                         $ this -> smtp_log . = $ data = $ this -> get_data ( $ smtp_conn ) . " \ n " ;
  557.                         $ code = substr ( $ data , 0 , 3 ) ; // get the response code
  558.  
  559.                         if ( $ code ! = 250 ) { $ this -> smtp_log . = "EHLO welcome error \ n " ; fclose ( $ smtp_conn ) ; return ; }
  560.  
  561.                         fputs ( $ smtp_conn , "AUTH LOGIN \ r \ n " ) ;
  562.                         $ this -> smtp_log . = "Me: AUTH LOGIN \ n " ;
  563.                         $ this -> smtp_log . = $ data = $ this -> get_data ( $ smtp_conn ) . " \ n " ;
  564.                         $ code = substr ( $ data , 0 , 3 ) ;
  565.  
  566.                         if ( $ code ! = 334 ) { $ this -> smtp_log . = "the server did not allow authorization to begin \ n " ; fclose ( $ smtp_conn ) ; return ; }
  567.  
  568.                         fputs ( $ smtp_conn , base64_encode ( $ this -> smtp_login ) . " \ r \ n " ) ;
  569.                         $ this -> smtp_log . = "I:" . base64_encode ( $ this -> smtp_login ) . " \ n " ;
  570.                         $ this -> smtp_log . = $ data = $ this -> get_data ( $ smtp_conn ) . " \ n " ;
  571.  
  572.                         $ code = substr ( $ data , 0 , 3 ) ;
  573.                         if ( $ code ! = 334 ) { $ this -> smtp_log . = "access error to such user \ n " ; fclose ( $ smtp_conn ) ; return ; }
  574.  
  575.  
  576.                         fputs ( $ smtp_conn , base64_encode ( $ this -> smtp_pass ) . " \ r \ n " ) ;
  577.                         $ this -> smtp_log . = "I:" . base64_encode ( $ this -> smtp_pass ) . " \ n " ;
  578.                         $ this -> smtp_log . = $ data = $ this -> get_data ( $ smtp_conn ) . " \ n " ;
  579.  
  580.                         $ code = substr ( $ data , 0 , 3 ) ;
  581.                         if ( $ code ! = 235 ) { $ this -> smtp_log . = "wrong password \ n " ; fclose ( $ smtp_conn ) ; return ; }
  582.  
  583.                         fputs ( $ smtp_conn , "MAIL FROM: <" . $ this -> xheaders [ 'From' ] . "> SIZE =" . strlen ( $ this -> headers . " \ r \ n " . $ this -> fullBody ) . " \ r \ n " ) ;
  584.                         $ this -> smtp_log . = "Me: MAIL FROM: <" . $ this -> xheaders [ 'From' ] . "> SIZE =" . strlen ( $ this -> headers . " \ r \ n " . $ this -> fullBody ) . " \ n " ;
  585.                         $ this -> smtp_log . = $ data = $ this -> get_data ( $ smtp_conn ) . " \ n " ;
  586.  
  587.                         $ code = substr ( $ data , 0 , 3 ) ;
  588.                         if ( $ code ! = 250 ) { $ this -> smtp_log . = "the server refused the MAIL FROM command \ n " ; fclose ( $ smtp_conn ) ; return ; }
  589.  
  590.  
  591.  
  592.                         foreach ( $ this -> smtpsendto as $ keywebi => $ valuewebi )
  593.                         {
  594.                                 fputs ( $ smtp_conn , "RCPT TO: <" . $ valuewebi . "> \ r \ n " ) ;
  595.                                 $ this -> smtp_log . = "Me: RCPT TO: <" . $ valuewebi . "> \ n " ;
  596.                                 $this->smtp_log .= $data = $this->get_data($smtp_conn)."\n";
  597.                                 $code = substr($data,0,3);
  598.                                 if($code != 250 AND $code != 251) {$this->smtp_log .= "Сервер не принял команду RCPT TO\n"; fclose($smtp_conn); return ;}
  599.                         }
  600.  
  601.  
  602.  
  603.  
  604.                         fputs($smtp_conn,"DATA\r\n");
  605.                         $this->smtp_log .="Я: DATA\n";
  606.                         $this->smtp_log .= $data = $this->get_data($smtp_conn)."\n";
  607.  
  608.                         $code = substr($data,0,3);
  609.                         if($code != 354) {$this->smtp_log .= "сервер не принял DATA\n"; fclose($smtp_conn); return ;}
  610.  
  611.                         fputs($smtp_conn,$this->headers."\r\n".$this->fullBody."\r\n.\r\n");
  612.                         $this->smtp_log .= "Я: ".$this->headers."\r\n".$this->fullBody."\r\n.\r\n";
  613.  
  614.                         $this->smtp_log .= $data = $this->get_data($smtp_conn)."\n";
  615.  
  616.                         $code = substr($data,0,3);
  617.                         if($code != 250) {$this->smtp_log .= "ошибка отправки письма\n"; fclose($smtp_conn); return ;}
  618.  
  619.                         fputs($smtp_conn,"QUIT\r\n");
  620.                         $this->smtp_log .="QUIT\r\n";
  621.                         $this->smtp_log .= $data = $this->get_data($smtp_conn)."\n";
  622.                         fclose($smtp_conn);
  623.                 }
  624.  
  625.         }
  626.  
  627.  
  628.  
  629.         /*
  630.         *               показывает что было отправлено
  631.         *
  632.         */
  633.  
  634.         function Get()
  635.         {
  636.                 if(isset($this->smtp_log))
  637.                 {
  638.                         if ($this->smtp_log)
  639.                         {
  640.                                 return $this->smtp_log; // если есть лог отправки smtp выведем его
  641.                         }
  642.                 }
  643.  
  644.                 $this->BuildMail();
  645.                 $mail = $this->headers . "\n\n";
  646.                 $mail .= $this->fullBody;
  647.                 return $mail;
  648.         }
  649.  
  650.  
  651.         /*
  652.         проверка мыла
  653.         возвращает true или false
  654.         */
  655.  
  656.         function ValidEmail($address)
  657.         {
  658.  
  659.                 // если существует современная функция фильтрации данных, то проверять будем этой функцией. появилась в php 5.2
  660.                 if (function_exists('filter_list'))
  661.                 {
  662.                         $valid_email = filter_var($address, FILTER_VALIDATE_EMAIL);
  663.                         if ($valid_email !== false) return true;
  664.                         else return false;
  665.                 }
  666.                 else // а если php еще старой версии, то проверка валидности пойдет старым способом
  667.                 {
  668.                         if( ereg( ".*<(.+)>", $address, $regs ) ) {
  669.                                 $address = $regs[1];
  670.                         }
  671.                         if(ereg( "^[^@  ][email protected]([a-zA-Z0-9\-]+\.)+([a-zA-Z0-9\-]{2}|net|com|gov|mil|org|edu|int)\$",$address) )
  672.                         return true;
  673.                         else
  674.                         return false;
  675.                 }
  676.         }
  677.  
  678.  
  679.         /*
  680.  
  681.         проверка массива адресов
  682.  
  683.  
  684.         */
  685.  
  686.         function CheckAdresses( $aad )
  687.         {
  688.                 for($i=0;$i< count( $aad); $i++ ) {
  689.                         if( ! $this->ValidEmail( $aad[$i]) ) {
  690.                                 echo "ошибка : не верный email ".$aad[$i];
  691.                                 exit;
  692.                         }
  693.                 }
  694.         }
  695.  
  696.  
  697.         /*
  698.         сборка файлов для отправки
  699.         */
  700.  
  701.         function _build_attachement()
  702.         {
  703.  
  704.                 $this->xheaders["Content-Type"] = "multipart/mixed;\n boundary=\"$this->boundary\"";
  705.  
  706.                 $this->fullBody = "This is a multi-part message in MIME format.\n--$this->boundary\n";
  707.                 $this->fullBody .= "Content-Type: ".$this->text_html."; charset=$this->charset\nContent-Transfer-Encoding: $this->ctencoding\n\n" . $this->body ."\n";
  708.  
  709.                 $sep= chr(13) . chr(10);
  710.  
  711.                 $ata= array();
  712.                 $k=0;
  713.  
  714.                 // перебираем файлы
  715.                 for( $i=0; $i < count( $this->aattach); $i++ ) {
  716.  
  717.                         $filename = $this->aattach[$i];
  718.  
  719.                         $webi_filename =$this->webi_filename[$i]; // имя файла, которое может приходить в класс, и имеет другое имя файла
  720.                         if(strlen($webi_filename)) $basename=basename($webi_filename); // если есть другое имя файла, то оно будет таким
  721.                         else $basename = basename($filename); // а если нет другого имени файла, то имя будет выдернуто из самого загружаемого файла
  722.  
  723.                         $ctype = $this->actype[$i];     // content-type
  724.                         $disposition = $this->adispo[$i];
  725.  
  726.                         if( ! file_exists( $filename) ) {
  727.                                 echo "ошибка прикрепления файла : файл $filename не существует"; exit;
  728.                         }
  729.                         $subhdr= "--$this->boundary\nContent-type: $ctype;\n name=\"$basename\"\nContent-Transfer-Encoding: base64\nContent-Disposition: $disposition;\n  filename=\"$basename\"\n";
  730.                         $ata[$k++] = $subhdr;
  731.                         // non encoded line length
  732.                         $linesz= filesize( $filename)+1;
  733.                         $ fp = fopen ( $ filename , 'r' ) ;
  734.                         $ ata [ $ k ++ ] = chunk_split ( base64_encode ( fread ( $ fp , $ linesz ) ) ) ;
  735.                         fclose ( $ fp ) ;
  736.                 }
  737.                 $ this -> fullBody . = implode ( $ sep , $ ata ) ;
  738.         }
  739.  
  740.  
  741. } // class Mail
  742.  
  743.  
  744. ?>
Parsed in 0.613 seconds