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