Ankündigung

Einklappen
Keine Ankündigung bisher.

PayPal IpIn und Bestell E-mails nach Update nicht mehr kompatibel

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

    PayPal IpIn und Bestell E-mails nach Update nicht mehr kompatibel

    Hallo Zusammen,

    folgendes Problem seit meinen Update auf 1.55
    Wenn kunden im Shop auf Rechnung oder per Vorkasse bestellen, bekomme ich die Kopie der Bestellbestätigung, zahlen aber dagegen die Kunden sofort per PayPal bekomme ich keine Bestellbestätigung.
    Vor dem Update ist alles gelaufen, seit dem Update geht es nicht mehr, aber die Einstellungen sind alle gleich geblieben, bzw. bei der neuinstalation von PP wieder gleich eingestellt worden.
    Hat wer noch das Problem, bzw. hat wer eine Idee dazu?

    Im Log ist auch was vorhanden:
    [16-Sep-2016 09:48:33 Europe/Berlin] PHP Fatal error: Call to undefined method SMTP::setTimeout() in /var/www/clients//web/ZC_SHOP_155/includes/classes/vendors/PHPMailer/class.phpmailer.php on line 1534


    Grüße

    Guido
    Zuletzt geändert von bumerang24; 16.09.2016, 11:29.

    #2
    Da würde ich nur eins empfehlen, zu warten, vielleicht ist das ein Prozessfehler, das bald behebt wird.

    Kommentar


      #3
      Super, du hast ja echt Ahnung

      Kommentar


        #4
        Ist bei Dir folgende Datei vorhanden?
        includes/classes/class.smtp.php

        Kommentar


          #5
          ist da, folgender Inhalt:
          HTML-Code:
          <?php
          /*~ class.smtp.php
          .---------------------------------------------------------------------------.
          |  Software: PHPMailer - PHP email class                                    |
          |   Version: 5.2.6                                                          |
          |      Site: https://github.com/PHPMailer/PHPMailer/                        |
          | ------------------------------------------------------------------------- |
          |    Admins: Marcus Bointon                                                 |
          |    Admins: Jim Jagielski                                                  |
          |   Authors: Andy Prevost (codeworxtech) codeworxtech@users.sourceforge.net |
          |          : Marcus Bointon (coolbru) phpmailer@synchromedia.co.uk          |
          |          : Jim Jagielski (jimjag) jimjag@gmail.com                        |
          |   Founder: Brent R. Matzelle (original founder)                           |
          | Copyright (c) 2010-2012, Jim Jagielski. All Rights Reserved.              |
          | Copyright (c) 2004-2009, Andy Prevost. All Rights Reserved.               |
          | Copyright (c) 2001-2003, Brent R. Matzelle                                |
          | ------------------------------------------------------------------------- |
          |   License: Distributed under the Lesser General Public License (LGPL)     |
          |            http://www.gnu.org/copyleft/lesser.html                        |
          | This program is distributed in the hope that it will be useful - WITHOUT  |
          | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or     |
          | FITNESS FOR A PARTICULAR PURPOSE.                                         |
          '---------------------------------------------------------------------------'
          */
          
          /**
           * PHPMailer - PHP SMTP email transport class
           * NOTE: Designed for use with PHP version 5 and up
           * @package PHPMailer
           * @author Andy Prevost
           * @author Marcus Bointon
           * @copyright 2004 - 2008 Andy Prevost
           * @author Jim Jagielski
           * @copyright 2010 - 2012 Jim Jagielski
           * @license http://www.gnu.org/copyleft/lesser.html Distributed under the Lesser General Public License (LGPL)
           */
          
          /**
           * PHP RFC821 SMTP client
           *
           * Implements all the RFC 821 SMTP commands except TURN which will always return a not implemented error.
           * SMTP also provides some utility methods for sending mail to an SMTP server.
           * @author Chris Ryan
           * @package PHPMailer
           */
          
          class SMTP {
            /**
             *  SMTP server port
             *  @var int
             */
            public $SMTP_PORT = 25;
          
            /**
             *  SMTP reply line ending (don't change)
             *  @var string
             */
            public $CRLF = "\r\n";
          
            /**
             *  Debug output level; 0 for no output
             *  @var int
             */
            public $do_debug = 0;
          
            /**
             * Sets the function/method to use for debugging output.
             * Right now we only honor 'echo' or 'error_log'
             * @var string
             */
            public $Debugoutput     = 'echo';
          
            /**
             *  Sets VERP use on/off (default is off)
             *  @var bool
             */
            public $do_verp = false;
          
            /**
             * Sets the SMTP timeout value for reads, in seconds
             * @var int
             */
            public $Timeout         = 15;
          
            /**
             * Sets the SMTP timelimit value for reads, in seconds
             * @var int
             */
            public $Timelimit       = 30;
          
            /**
             * Sets the SMTP PHPMailer Version number
             * @var string
             */
            public $Version         = '5.2.6';
          
            /////////////////////////////////////////////////
            // PROPERTIES, PRIVATE AND PROTECTED
            /////////////////////////////////////////////////
          
            /**
             * @var resource The socket to the server
             */
            private $smtp_conn;
            /**
             * @var string Error message, if any, for the last call
             */
            private $error;
            /**
             * @var string The reply the server sent to us for HELO
             */
            private $helo_rply;
          
            /**
             * Outputs debugging info via user-defined method
             * @param string $str
             */
            private function edebug($str) {
              if ($this->Debugoutput == 'error_log') {
                  error_log($str);
              } else {
                  echo $str;
              }
            }
          
            /**
             * Initialize the class so that the data is in a known state.
             * @access public
             * @return SMTP
             */
            public function __construct() {
              $this->smtp_conn = 0;
              $this->error = null;
              $this->helo_rply = null;
          
              $this->do_debug = 0;
            }
          
            /////////////////////////////////////////////////
            // CONNECTION FUNCTIONS
            /////////////////////////////////////////////////
          
            /**
             * Connect to the server specified on the port specified.
             * If the port is not specified use the default SMTP_PORT.
             * If tval is specified then a connection will try and be
             * established with the server for that number of seconds.
             * If tval is not specified the default is 30 seconds to
             * try on the connection.
             *
             * SMTP CODE SUCCESS: 220
             * SMTP CODE FAILURE: 421
             * @access public
             * @param string $host
             * @param int $port
             * @param int $tval
             * @return bool
             */
            public function Connect($host, $port = 0, $tval = 30) {
              // set the error val to null so there is no confusion
              $this->error = null;
          
              // make sure we are __not__ connected
              if($this->connected()) {
                // already connected, generate error
                $this->error = array('error' => 'Already connected to a server');
                return false;
              }
          
              if(empty($port)) {
                $port = $this->SMTP_PORT;
              }
          
              // connect to the smtp server
              $this->smtp_conn = @fsockopen($host,    // the host of the server
                                           $port,    // the port to use
                                           $errno,   // error number if any
                                           $errstr,  // error message if any
                                           $tval);   // give up after ? secs
              // verify we connected properly
              if(empty($this->smtp_conn)) {
                $this->error = array('error' => 'Failed to connect to server',
                                     'errno' => $errno,
                                     'errstr' => $errstr);
                if($this->do_debug >= 1) {
                  $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ": $errstr ($errno)" . $this->CRLF . '<br />');
                }
                return false;
              }
          
              // SMTP server can take longer to respond, give longer timeout for first read
              // Windows does not have support for this timeout function
              if(substr(PHP_OS, 0, 3) != 'WIN') {
               $max = ini_get('max_execution_time');
               if ($max != 0 && $tval > $max) { // don't bother if unlimited
                @set_time_limit($tval);
               }
               stream_set_timeout($this->smtp_conn, $tval, 0);
              }
          
              // get any announcement
              $announce = $this->get_lines();
          
              if($this->do_debug >= 2) {
                $this->edebug('SMTP -> FROM SERVER:' . $announce . $this->CRLF . '<br />');
              }
          
              return true;
            }
          
            /**
             * Initiate a TLS communication with the server.
             *
             * SMTP CODE 220 Ready to start TLS
             * SMTP CODE 501 Syntax error (no parameters allowed)
             * SMTP CODE 454 TLS not available due to temporary reason
             * @access public
             * @return bool success
             */
            public function StartTLS() {
              $this->error = null; # to avoid confusion
          
              if(!$this->connected()) {
                $this->error = array('error' => 'Called StartTLS() without being connected');
                return false;
              }
          
              $this->client_send('STARTTLS' . $this->CRLF);
          
              $rply = $this->get_lines();
              $code = substr($rply, 0, 3);
          
              if($this->do_debug >= 2) {
                $this->edebug('SMTP -> FROM SERVER:' . $rply . $this->CRLF . '<br />');
              }
          
              if($code != 220) {
                $this->error =
                   array('error'     => 'STARTTLS not accepted from server',
                         'smtp_code' => $code,
                         'smtp_msg'  => substr($rply, 4));
                if($this->do_debug >= 1) {
                  $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                }
                return false;
              }
          
              // Begin encrypted connection
              if(!stream_socket_enable_crypto($this->smtp_conn, true, STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
                return false;
              }
          
              return true;
            }
          
            /**
             * Performs SMTP authentication.  Must be run after running the
             * Hello() method.  Returns true if successfully authenticated.
             * @access public
             * @param string $username
             * @param string $password
             * @param string $authtype
             * @param string $realm
             * @param string $workstation
             * @return bool
             */
            public function Authenticate($username, $password, $authtype='LOGIN', $realm='', $workstation='') {
              if (empty($authtype)) {
                $authtype = 'LOGIN';
              }
          
              switch ($authtype) {
                case 'PLAIN':
                  // Start authentication
                  $this->client_send('AUTH PLAIN' . $this->CRLF);
          
                  $rply = $this->get_lines();
                  $code = substr($rply, 0, 3);
          
                  if($code != 334) {
                    $this->error =
                      array('error' => 'AUTH not accepted from server',
                            'smtp_code' => $code,
                            'smtp_msg' => substr($rply, 4));
                    if($this->do_debug >= 1) {
                      $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                    }
                    return false;
                  }
                  // Send encoded username and password
                    $this->client_send(base64_encode("\0".$username."\0".$password) . $this->CRLF);
          
                  $rply = $this->get_lines();
                  $code = substr($rply, 0, 3);
          
                  if($code != 235) {
                    $this->error =
                      array('error' => 'Authentication not accepted from server',
                            'smtp_code' => $code,
                            'smtp_msg' => substr($rply, 4));
                    if($this->do_debug >= 1) {
                      $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                    }
                    return false;
                  }
                  break;
                case 'LOGIN':
                  // Start authentication
                  $this->client_send('AUTH LOGIN' . $this->CRLF);
          
                  $rply = $this->get_lines();
                  $code = substr($rply, 0, 3);
          
                  if($code != 334) {
                    $this->error =
                      array('error' => 'AUTH not accepted from server',
                            'smtp_code' => $code,
                            'smtp_msg' => substr($rply, 4));
                    if($this->do_debug >= 1) {
                      $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                    }
                    return false;
                  }
          
                  // Send encoded username
                  $this->client_send(base64_encode($username) . $this->CRLF);
          
                  $rply = $this->get_lines();
                  $code = substr($rply, 0, 3);
          
                  if($code != 334) {
                    $this->error =
                      array('error' => 'Username not accepted from server',
                            'smtp_code' => $code,
                            'smtp_msg' => substr($rply, 4));
                    if($this->do_debug >= 1) {
                      $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                    }
                    return false;
                  }
          
                  // Send encoded password
                  $this->client_send(base64_encode($password) . $this->CRLF);
          
                  $rply = $this->get_lines();
                  $code = substr($rply, 0, 3);
          
                  if($code != 235) {
                    $this->error =
                      array('error' => 'Password not accepted from server',
                            'smtp_code' => $code,
                            'smtp_msg' => substr($rply, 4));
                    if($this->do_debug >= 1) {
                      $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                    }
                    return false;
                  }
                  break;
                case 'NTLM':
                  /*
                   * ntlm_sasl_client.php
                   ** Bundled with Permission
                   **
                   ** How to telnet in windows: http://technet.microsoft.com/en-us/library/aa995718%28EXCHG.65%29.aspx
                   ** PROTOCOL Documentation http://curl.haxx.se/rfc/ntlm.html#ntlmSmtpAuthentication
                   */
                  require_once (DIR_FS_CATALOG . 'includes/classes/support/ntlm_sasl_client.php');
                  $temp = new stdClass();
                  $ntlm_client = new ntlm_sasl_client_class;
                  if(! $ntlm_client->Initialize($temp)){//let's test if every function its available
                      $this->error = array('error' => $temp->error);
                      if($this->do_debug >= 1) {
                          $this->edebug('You need to enable some modules in your php.ini file: ' . $this->error['error'] . $this->CRLF);
                      }
                      return false;
                  }
                  $msg1 = $ntlm_client->TypeMsg1($realm, $workstation);//msg1
          
                  $this->client_send('AUTH NTLM ' . base64_encode($msg1) . $this->CRLF);
          
                  $rply = $this->get_lines();
                  $code = substr($rply, 0, 3);
          
          
                  if($code != 334) {
                      $this->error =
                          array('error' => 'AUTH not accepted from server',
                                'smtp_code' => $code,
                                'smtp_msg' => substr($rply, 4));
                      if($this->do_debug >= 1) {
                          $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF);
                      }
                      return false;
                  }
          
                  $challenge = substr($rply, 3);//though 0 based, there is a white space after the 3 digit number....//msg2
                  $challenge = base64_decode($challenge);
                  $ntlm_res = $ntlm_client->NTLMResponse(substr($challenge, 24, 8), $password);
                  $msg3 = $ntlm_client->TypeMsg3($ntlm_res, $username, $realm, $workstation);//msg3
                  // Send encoded username
                  $this->client_send(base64_encode($msg3) . $this->CRLF);
          
                  $rply = $this->get_lines();
                  $code = substr($rply, 0, 3);
          
                  if($code != 235) {
                      $this->error =
                          array('error' => 'Could not authenticate',
                                'smtp_code' => $code,
                                'smtp_msg' => substr($rply, 4));
                      if($this->do_debug >= 1) {
                          $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF);
                      }
                      return false;
                  }
                  break;
                case 'CRAM-MD5':
                  // Start authentication
                  $this->client_send('AUTH CRAM-MD5' . $this->CRLF);
          
                  $rply = $this->get_lines();
                  $code = substr($rply, 0, 3);
          
                  if($code != 334) {
                    $this->error =
                      array('error' => 'AUTH not accepted from server',
                            'smtp_code' => $code,
                            'smtp_msg' => substr($rply, 4));
                    if($this->do_debug >= 1) {
                      $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                    }
                    return false;
                  }
          
                  // Get the challenge
                  $challenge = base64_decode(substr($rply, 4));
          
                  // Build the response
                  $response = $username . ' ' . $this->hmac($challenge, $password);
          
                  // Send encoded credentials
                  $this->client_send(base64_encode($response) . $this->CRLF);
          
                  $rply = $this->get_lines();
                  $code = substr($rply, 0, 3);
          
                  if($code != 334) {
                    $this->error =
                      array('error' => 'Credentials not accepted from server',
                            'smtp_code' => $code,
                            'smtp_msg' => substr($rply, 4));
                    if($this->do_debug >= 1) {
                      $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                    }
                    return false;
                  }
                  break;
              }
              return true;
            }
          
            /**
             * Works like hash_hmac('md5', $data, $key) in case that function is not available
             * @access private
             * @param string $data
             * @param string $key
             * @return string
             */
            private function hmac($data, $key) {
                if (function_exists('hash_hmac')) {
                    return hash_hmac('md5', $data, $key);
                }
          
                // The following borrowed from http://php.net/manual/en/function.mhash.php#27225
          
                // RFC 2104 HMAC implementation for php.
                // Creates an md5 HMAC.
                // Eliminates the need to install mhash to compute a HMAC
                // by Lance Rushing
          
                $b = 64; // byte length for md5
                if (strlen($key) > $b) {
                    $key = pack('H*', md5($key));
                }
                $key  = str_pad($key, $b, chr(0x00));
                $ipad = str_pad('', $b, chr(0x36));
                $opad = str_pad('', $b, chr(0x5c));
                $k_ipad = $key ^ $ipad ;
                $k_opad = $key ^ $opad;
          
                return md5($k_opad  . pack('H*', md5($k_ipad . $data)));
            }
          
            /**
             * Returns true if connected to a server otherwise false
             * @access public
             * @return bool
             */
            public function Connected() {
              if(!empty($this->smtp_conn)) {
                $sock_status = stream_get_meta_data($this->smtp_conn);
                if($sock_status['eof']) {
                  // the socket is valid but we are not connected
                  if($this->do_debug >= 1) {
                      $this->edebug('SMTP -> NOTICE:' . $this->CRLF . 'EOF caught while checking if connected');
                  }
                  $this->Close();
                  return false;
                }
                return true; // everything looks good
              }
              return false;
            }
          
            /**
             * Closes the socket and cleans up the state of the class.
             * It is not considered good to use this function without
             * first trying to use QUIT.
             * @access public
             * @return void
             */
            public function Close() {
              $this->error = null; // so there is no confusion
              $this->helo_rply = null;
              if(!empty($this->smtp_conn)) {
                // close the connection and cleanup
                fclose($this->smtp_conn);
                $this->smtp_conn = 0;
              }
            }
          
            /////////////////////////////////////////////////
            // SMTP COMMANDS
            /////////////////////////////////////////////////
          
            /**
             * Issues a data command and sends the msg_data to the server
             * finializing the mail transaction. $msg_data is the message
             * that is to be send with the headers. Each header needs to be
             * on a single line followed by a <CRLF> with the message headers
             * and the message body being seperated by and additional <CRLF>.
             *
             * Implements rfc 821: DATA <CRLF>
             *
             * SMTP CODE INTERMEDIATE: 354
             *     [data]
             *     <CRLF>.<CRLF>
             *     SMTP CODE SUCCESS: 250
             *     SMTP CODE FAILURE: 552, 554, 451, 452
             * SMTP CODE FAILURE: 451, 554
             * SMTP CODE ERROR  : 500, 501, 503, 421
             * @access public
             * @param string $msg_data
             * @return bool
             */
            public function Data($msg_data) {
              $this->error = null; // so no confusion is caused
          
              if(!$this->connected()) {
                $this->error = array(
                        'error' => 'Called Data() without being connected');
                return false;
              }
          
              $this->client_send('DATA' . $this->CRLF);
          
              $rply = $this->get_lines();
              $code = substr($rply, 0, 3);
          
              if($this->do_debug >= 2) {
                $this->edebug('SMTP -> FROM SERVER:' . $rply . $this->CRLF . '<br />');
              }
          
              if($code != 354) {
                $this->error =
                  array('error' => 'DATA command not accepted from server',
                        'smtp_code' => $code,
                        'smtp_msg' => substr($rply, 4));
                if($this->do_debug >= 1) {
                  $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                }
                return false;
              }
          
              /* the server is ready to accept data!
               * according to rfc 821 we should not send more than 1000
               * including the CRLF
               * characters on a single line so we will break the data up
               * into lines by \r and/or \n then if needed we will break
               * each of those into smaller lines to fit within the limit.
               * in addition we will be looking for lines that start with
               * a period '.' and append and additional period '.' to that
               * line. NOTE: this does not count towards limit.
               */
          
              // normalize the line breaks so we know the explode works
              $msg_data = str_replace("\r\n", "\n", $msg_data);
              $msg_data = str_replace("\r", "\n", $msg_data);
              $lines = explode("\n", $msg_data);
          
              /* we need to find a good way to determine is headers are
               * in the msg_data or if it is a straight msg body
               * currently I am assuming rfc 822 definitions of msg headers
               * and if the first field of the first line (':' sperated)
               * does not contain a space then it _should_ be a header
               * and we can process all lines before a blank "" line as
               * headers.
               */
          
              $field = substr($lines[0], 0, strpos($lines[0], ':'));
              $in_headers = false;
              if(!empty($field) && !strstr($field, ' ')) {
                $in_headers = true;
              }
          
              $max_line_length = 998; // used below; set here for ease in change
          
              while(list(, $line) = @each($lines)) {
                $lines_out = null;
                if($line == '' && $in_headers) {
                  $in_headers = false;
                }
                // ok we need to break this line up into several smaller lines
                while(strlen($line) > $max_line_length) {
                  $pos = strrpos(substr($line, 0, $max_line_length), ' ');
          
                  // Patch to fix DOS attack
                  if(!$pos) {
                    $pos = $max_line_length - 1;
                    $lines_out[] = substr($line, 0, $pos);
                    $line = substr($line, $pos);
                  } else {
                    $lines_out[] = substr($line, 0, $pos);
                    $line = substr($line, $pos + 1);
                  }
          
                  /* if processing headers add a LWSP-char to the front of new line
                   * rfc 822 on long msg headers
                   */
                  if($in_headers) {
                    $line = "\t" . $line;
                  }
                }
                $lines_out[] = $line;
          
                // send the lines to the server
                while(list(, $line_out) = @each($lines_out)) {
                  if(strlen($line_out) > 0)
                  {
                    if(substr($line_out, 0, 1) == '.') {
                      $line_out = '.' . $line_out;
                    }
                  }
                  $this->client_send($line_out . $this->CRLF);
                }
              }
          
              // message data has been sent
              $this->client_send($this->CRLF . '.' . $this->CRLF);
          
              $rply = $this->get_lines();
              $code = substr($rply, 0, 3);
          
              if($this->do_debug >= 2) {
                $this->edebug('SMTP -> FROM SERVER:' . $rply . $this->CRLF . '<br />');
              }
          
              if($code != 250) {
                $this->error =
                  array('error' => 'DATA not accepted from server',
                        'smtp_code' => $code,
                        'smtp_msg' => substr($rply, 4));
                if($this->do_debug >= 1) {
                  $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                }
                return false;
              }
              return true;
            }
          
            /**
             * Sends the HELO command to the smtp server.
             * This makes sure that we and the server are in
             * the same known state.
             *
             * Implements from rfc 821: HELO <SP> <domain> <CRLF>
             *
             * SMTP CODE SUCCESS: 250
             * SMTP CODE ERROR  : 500, 501, 504, 421
             * @access public
             * @param string $host
             * @return bool
             */
            public function Hello($host = '') {
              $this->error = null; // so no confusion is caused
          
              if(!$this->connected()) {
                $this->error = array(
                      'error' => 'Called Hello() without being connected');
                return false;
              }
          
              // if hostname for HELO was not specified send default
              if(empty($host)) {
                // determine appropriate default to send to server
                $host = 'localhost';
              }
          
              // Send extended hello first (RFC 2821)
              if(!$this->SendHello('EHLO', $host)) {
                if(!$this->SendHello('HELO', $host)) {
                  return false;
                }
              }
          
              return true;
            }
          
            /**
             * Sends a HELO/EHLO command.
             * @access private
             * @param string $hello
             * @param string $host
             * @return bool
             */
            private function SendHello($hello, $host) {
              $this->client_send($hello . ' ' . $host . $this->CRLF);
          
              $rply = $this->get_lines();
              $code = substr($rply, 0, 3);
          
              if($this->do_debug >= 2) {
                $this->edebug('SMTP -> FROM SERVER: ' . $rply . $this->CRLF . '<br />');
              }
          
              if($code != 250) {
                $this->error =
                  array('error' => $hello . ' not accepted from server',
                        'smtp_code' => $code,
                        'smtp_msg' => substr($rply, 4));
                if($this->do_debug >= 1) {
                  $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                }
                return false;
              }
          
              $this->helo_rply = $rply;
          
              return true;
            }
          
            /**
             * Starts a mail transaction from the email address specified in
             * $from. Returns true if successful or false otherwise. If True
             * the mail transaction is started and then one or more Recipient
             * commands may be called followed by a Data command.
             *
             * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF>
             *
             * SMTP CODE SUCCESS: 250
             * SMTP CODE SUCCESS: 552, 451, 452
             * SMTP CODE SUCCESS: 500, 501, 421
             * @access public
             * @param string $from
             * @return bool
             */
            public function Mail($from) {
              $this->error = null; // so no confusion is caused
          
              if(!$this->connected()) {
                $this->error = array(
                        'error' => 'Called Mail() without being connected');
                return false;
              }
          
              $useVerp = ($this->do_verp ? ' XVERP' : '');
              $this->client_send('MAIL FROM:<' . $from . '>' . $useVerp . $this->CRLF);
          
              $rply = $this->get_lines();
              $code = substr($rply, 0, 3);
          
              if($this->do_debug >= 2) {
                $this->edebug('SMTP -> FROM SERVER:' . $rply . $this->CRLF . '<br />');
              }
          
              if($code != 250) {
                $this->error =
                  array('error' => 'MAIL not accepted from server',
                        'smtp_code' => $code,
                        'smtp_msg' => substr($rply, 4));
                if($this->do_debug >= 1) {
                  $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                }
                return false;
              }
              return true;
            }
          
            /**
             * Sends the quit command to the server and then closes the socket
             * if there is no error or the $close_on_error argument is true.
             *
             * Implements from rfc 821: QUIT <CRLF>
             *
             * SMTP CODE SUCCESS: 221
             * SMTP CODE ERROR  : 500
             * @access public
             * @param bool $close_on_error
             * @return bool
             */
            public function Quit($close_on_error = true) {
              $this->error = null; // so there is no confusion
          
              if(!$this->connected()) {
                $this->error = array(
                        'error' => 'Called Quit() without being connected');
                return false;
              }
          
              // send the quit command to the server
              $this->client_send('quit' . $this->CRLF);
          
              // get any good-bye messages
              $byemsg = $this->get_lines();
          
              if($this->do_debug >= 2) {
                $this->edebug('SMTP -> FROM SERVER:' . $byemsg . $this->CRLF . '<br />');
              }
          
              $rval = true;
              $e = null;
          
              $code = substr($byemsg, 0, 3);
              if($code != 221) {
                // use e as a tmp var cause Close will overwrite $this->error
                $e = array('error' => 'SMTP server rejected quit command',
                           'smtp_code' => $code,
                           'smtp_rply' => substr($byemsg, 4));
                $rval = false;
                if($this->do_debug >= 1) {
                  $this->edebug('SMTP -> ERROR: ' . $e['error'] . ': ' . $byemsg . $this->CRLF . '<br />');
                }
              }
          
              if(empty($e) || $close_on_error) {
                $this->Close();
              }
          
              return $rval;
            }
          
            /**
             * Sends the command RCPT to the SMTP server with the TO: argument of $to.
             * Returns true if the recipient was accepted false if it was rejected.
             *
             * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>
             *
             * SMTP CODE SUCCESS: 250, 251
             * SMTP CODE FAILURE: 550, 551, 552, 553, 450, 451, 452
             * SMTP CODE ERROR  : 500, 501, 503, 421
             * @access public
             * @param string $to
             * @return bool
             */
            public function Recipient($to) {
              $this->error = null; // so no confusion is caused
          
              if(!$this->connected()) {
                $this->error = array(
                        'error' => 'Called Recipient() without being connected');
                return false;
              }
          
              $this->client_send('RCPT TO:<' . $to . '>' . $this->CRLF);
          
              $rply = $this->get_lines();
              $code = substr($rply, 0, 3);
          
              if($this->do_debug >= 2) {
                $this->edebug('SMTP -> FROM SERVER:' . $rply . $this->CRLF . '<br />');
              }
          
              if($code != 250 && $code != 251) {
                $this->error =
                  array('error' => 'RCPT not accepted from server',
                        'smtp_code' => $code,
                        'smtp_msg' => substr($rply, 4));
                if($this->do_debug >= 1) {
                  $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                }
                return false;
              }
              return true;
            }
          
            /**
             * Sends the RSET command to abort and transaction that is
             * currently in progress. Returns true if successful false
             * otherwise.
             *
             * Implements rfc 821: RSET <CRLF>
             *
             * SMTP CODE SUCCESS: 250
             * SMTP CODE ERROR  : 500, 501, 504, 421
             * @access public
             * @return bool
             */
            public function Reset() {
              $this->error = null; // so no confusion is caused
          
              if(!$this->connected()) {
                $this->error = array('error' => 'Called Reset() without being connected');
                return false;
              }
          
              $this->client_send('RSET' . $this->CRLF);
          
              $rply = $this->get_lines();
              $code = substr($rply, 0, 3);
          
              if($this->do_debug >= 2) {
                $this->edebug('SMTP -> FROM SERVER:' . $rply . $this->CRLF . '<br />');
              }
          
              if($code != 250) {
                $this->error =
                  array('error' => 'RSET failed',
                        'smtp_code' => $code,
                        'smtp_msg' => substr($rply, 4));
                if($this->do_debug >= 1) {
                  $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                }
                return false;
              }
          
              return true;
            }
          
            /**
             * Starts a mail transaction from the email address specified in
             * $from. Returns true if successful or false otherwise. If True
             * the mail transaction is started and then one or more Recipient
             * commands may be called followed by a Data command. This command
             * will send the message to the users terminal if they are logged
             * in and send them an email.
             *
             * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF>
             *
             * SMTP CODE SUCCESS: 250
             * SMTP CODE SUCCESS: 552, 451, 452
             * SMTP CODE SUCCESS: 500, 501, 502, 421
             * @access public
             * @param string $from
             * @return bool
             */
            public function SendAndMail($from) {
              $this->error = null; // so no confusion is caused
          
              if(!$this->connected()) {
                $this->error = array(
                    'error' => 'Called SendAndMail() without being connected');
                return false;
              }
          
              $this->client_send('SAML FROM:' . $from . $this->CRLF);
          
              $rply = $this->get_lines();
              $code = substr($rply, 0, 3);
          
              if($this->do_debug >= 2) {
                $this->edebug('SMTP -> FROM SERVER:' . $rply . $this->CRLF . '<br />');
              }
          
              if($code != 250) {
                $this->error =
                  array('error' => 'SAML not accepted from server',
                        'smtp_code' => $code,
                        'smtp_msg' => substr($rply, 4));
                if($this->do_debug >= 1) {
                  $this->edebug('SMTP -> ERROR: ' . $this->error['error'] . ': ' . $rply . $this->CRLF . '<br />');
                }
                return false;
              }
              return true;
            }
          
            /**
             * This is an optional command for SMTP that this class does not
             * support. This method is here to make the RFC821 Definition
             * complete for this class and __may__ be implimented in the future
             *
             * Implements from rfc 821: TURN <CRLF>
             *
             * SMTP CODE SUCCESS: 250
             * SMTP CODE FAILURE: 502
             * SMTP CODE ERROR  : 500, 503
             * @access public
             * @return bool
             */
            public function Turn() {
              $this->error = array('error' => 'This method, TURN, of the SMTP '.
                                              'is not implemented');
              if($this->do_debug >= 1) {
                $this->edebug('SMTP -> NOTICE: ' . $this->error['error'] . $this->CRLF . '<br />');
              }
              return false;
            }
          
            /**
            * Sends data to the server
            * @param string $data
            * @access public
            * @return Integer number of bytes sent to the server or FALSE on error
            */
            public function client_send($data) {
                if ($this->do_debug >= 1) {
                    $this->edebug("CLIENT -> SMTP: $data" . $this->CRLF . '<br />');
                }
                return fwrite($this->smtp_conn, $data);
            }
          
            /**
            * Get the current error
            * @access public
            * @return array
            */
            public function getError() {
              return $this->error;
            }
          
            /////////////////////////////////////////////////
            // INTERNAL FUNCTIONS
            /////////////////////////////////////////////////
          
            /**
             * Read in as many lines as possible
             * either before eof or socket timeout occurs on the operation.
             * With SMTP we can tell if we have more lines to read if the
             * 4th character is '-' symbol. If it is a space then we don't
             * need to read anything else.
             * @access private
             * @return string
             */
            private function get_lines() {
              $data = '';
              $endtime = 0;
              /* If for some reason the fp is bad, don't inf loop */
              if (!is_resource($this->smtp_conn)) {
                return $data;
              }
              stream_set_timeout($this->smtp_conn, $this->Timeout);
              if ($this->Timelimit > 0) {
                $endtime = time() + $this->Timelimit;
              }
              while(is_resource($this->smtp_conn) && !feof($this->smtp_conn)) {
                $str = @fgets($this->smtp_conn, 515);
                if($this->do_debug >= 4) {
                  $this->edebug("SMTP -> get_lines(): \$data was \"$data\"" . $this->CRLF . '<br />');
                  $this->edebug("SMTP -> get_lines(): \$str is \"$str\"" . $this->CRLF . '<br />');
                }
                $data .= $str;
                if($this->do_debug >= 4) {
                  $this->edebug("SMTP -> get_lines(): \$data is \"$data\"" . $this->CRLF . '<br />');
                }
                // if 4th character is a space, we are done reading, break the loop
                if(substr($str, 3, 1) == ' ') { break; }
                // Timed-out? Log and break
                $info = stream_get_meta_data($this->smtp_conn);
                if ($info['timed_out']) {
                  if($this->do_debug >= 4) {
                    $this->edebug('SMTP -> get_lines(): timed-out (' . $this->Timeout . ' seconds) <br />');
                  }
                  break;
                }
                // Now check if reads took too long
                if ($endtime) {
                  if (time() > $endtime) {
                    if($this->do_debug >= 4) {
                      $this->edebug('SMTP -> get_lines(): timelimit reached (' . $this->Timelimit . ' seconds) <br />');
                    }
                    break;
                  }
                }
              }
              return $data;
            }
          
          }

          Kommentar


            #6
            Diese Datei gibt es in Zen Cart 1.5.5 nicht mehr.
            Da sie bei Dir vorhanden ist, hast Du anscheinend das Update so durchgeführt, dass Du einfach die 1.5.5 Dateien über den bestehenden Shop drübergebügelt hast.
            Ein Update wird so wie in der Updateanleitung beschrieben immer mit einer cleanen 1.5.5 Neuinstallation durchgeführt und nicht durch das Hochladen in einen bestehenden Shop.

            Lösche die Datei includes/classes/class.smtp.php

            Und entferne zusätzlich folgendes aus der includes/autoloaders/paypal_ipn.core.php
            ca. Zeile 25
            Code:
            $autoLoadConfig[0][] = array('autoType'=>'class',
                                            'loadFile'=> 'class.smtp.php');

            Kommentar


              #7
              Hallo Webchills,

              ich habe eigentlich ein Update in einen leeren Shop wie beschrieben gemacht, aber....
              Es geht jetzt auf alle Fälle wieder.

              Mercy wieder mal für die Hilfe

              Kommentar

              Info zu diesem Forenarchiv:
              Mit Release von 1.5.7 wurde die deutsche Zen Cart Version auf eine reine DIY-Lösung umgestellt.
              Für einen Support via Forum stehen keine personellen und zeitlichen Ressourcen mehr zur Verfügung.
              Dieses Supportforum bleibt im Nur-Lesen-Modus als Wissensarchiv noch online verfügbar.
              PM Funktionalität, Registrierung und Posten neuer Beiträge sind deaktiviert.
              Zugriff auf Anhänge in den Postings ist auch ohne Registrierung/Einloggen möglich.
              FAQ und Downloadbereich des Forums wurden in die neue umfangreiche Knowledgebase auf der zen-cart-pro.at Website übernommen.

              Das Development der deutschen Zen Cart Version geht wie bisher auf Github weiter.
              Wir werden auch weiterhin neue Versionen bereitstellen und die Onlinedokumentation/Knowledgebase aktualisieren.
              Fehler in der Software können auf Github als Issues gemeldet werden.
              Follow us
              aktuelle version
              Zen Cart 1.5.7g deutsch
              vom 12.12.2023
              [Download]
              Lädt...
              X