Back to index

php5  5.3.10
Classes | Defines | Typedefs | Functions | Variables
ftp_fopen_wrapper.c File Reference
#include "php.h"
#include "php_globals.h"
#include "php_network.h"
#include "php_ini.h"
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/param.h>
#include "php_standard.h"
#include <netinet/in.h>
#include <netdb.h>
#include "php_fopen_wrappers.h"

Go to the source code of this file.

Classes

struct  _php_ftp_dirstream_data

Defines

#define FTPS_ENCRYPT_DATA   1
#define GET_FTP_RESULT(stream)   get_ftp_result((stream), tmp_line, sizeof(tmp_line) TSRMLS_CC)
#define PHP_FTP_CNTRL_CHK(val, val_len, err_msg)

Typedefs

typedef struct
_php_ftp_dirstream_data 
php_ftp_dirstream_data

Functions

static int get_ftp_result (php_stream *stream, char *buffer, size_t buffer_size TSRMLS_DC)
static int php_stream_ftp_stream_stat (php_stream_wrapper *wrapper, php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
static int php_stream_ftp_stream_close (php_stream_wrapper *wrapper, php_stream *stream TSRMLS_DC)
static php_stream * php_ftp_fopen_connect (php_stream_wrapper *wrapper, char *path, char *mode, int options, char **opened_path, php_stream_context *context, php_stream **preuseid, php_url **presource, int *puse_ssl, int *puse_ssl_on_data TSRMLS_DC)
static unsigned short php_fopen_do_pasv (php_stream *stream, char *ip, size_t ip_size, char **phoststart TSRMLS_DC)
php_stream * php_stream_url_wrap_ftp (php_stream_wrapper *wrapper, char *path, char *mode, int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
static size_t php_ftp_dirstream_read (php_stream *stream, char *buf, size_t count TSRMLS_DC)
static int php_ftp_dirstream_close (php_stream *stream, int close_handle TSRMLS_DC)
php_stream * php_stream_ftp_opendir (php_stream_wrapper *wrapper, char *path, char *mode, int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
static int php_stream_ftp_url_stat (php_stream_wrapper *wrapper, char *url, int flags, php_stream_statbuf *ssb, php_stream_context *context TSRMLS_DC)
static int php_stream_ftp_unlink (php_stream_wrapper *wrapper, char *url, int options, php_stream_context *context TSRMLS_DC)
static int php_stream_ftp_rename (php_stream_wrapper *wrapper, char *url_from, char *url_to, int options, php_stream_context *context TSRMLS_DC)
static int php_stream_ftp_mkdir (php_stream_wrapper *wrapper, char *url, int mode, int options, php_stream_context *context TSRMLS_DC)
static int php_stream_ftp_rmdir (php_stream_wrapper *wrapper, char *url, int options, php_stream_context *context TSRMLS_DC)

Variables

static php_stream_ops php_ftp_dirstream_ops
static php_stream_wrapper_ops ftp_stream_wops
PHPAPI php_stream_wrapper php_stream_ftp_wrapper

Class Documentation

struct _php_ftp_dirstream_data

Definition at line 75 of file ftp_fopen_wrapper.c.

Class Members
php_stream * controlstream
php_stream * datastream
php_stream * dirstream

Define Documentation

#define FTPS_ENCRYPT_DATA   1

Definition at line 72 of file ftp_fopen_wrapper.c.

#define GET_FTP_RESULT (   stream)    get_ftp_result((stream), tmp_line, sizeof(tmp_line) TSRMLS_CC)

Definition at line 73 of file ftp_fopen_wrapper.c.

#define PHP_FTP_CNTRL_CHK (   val,
  val_len,
  err_msg 
)
Value:
{      \
       unsigned char *s = val, *e = s + val_len; \
       while (s < e) {      \
              if (iscntrl(*s)) {   \
                     php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, err_msg, val);      \
                     goto connect_errexit;       \
              }      \
              s++;   \
       }      \
}

Typedef Documentation


Function Documentation

static int get_ftp_result ( php_stream *  stream,
char *  buffer,
size_t buffer_size  TSRMLS_DC 
) [inline, static]

Definition at line 83 of file ftp_fopen_wrapper.c.

{
       while (php_stream_gets(stream, buffer, buffer_size-1) &&
                 !(isdigit((int) buffer[0]) && isdigit((int) buffer[1]) &&
                      isdigit((int) buffer[2]) && buffer[3] == ' '));
       return strtol(buffer, NULL, 10);
}
static unsigned short php_fopen_do_pasv ( php_stream *  stream,
char *  ip,
size_t  ip_size,
char **phoststart  TSRMLS_DC 
) [static]

Definition at line 323 of file ftp_fopen_wrapper.c.

{
       char tmp_line[512];
       int result, i;
       unsigned short portno;
       char *tpath, *ttpath, *hoststart=NULL;

#ifdef HAVE_IPV6
       /* We try EPSV first, needed for IPv6 and works on some IPv4 servers */
       php_stream_write_string(stream, "EPSV\r\n");
       result = GET_FTP_RESULT(stream);

       /* check if we got a 229 response */
       if (result != 229) {
#endif
              /* EPSV failed, let's try PASV */
              php_stream_write_string(stream, "PASV\r\n");
              result = GET_FTP_RESULT(stream);
              
              /* make sure we got a 227 response */
              if (result != 227) {
                     return 0;
              }

              /* parse pasv command (129, 80, 95, 25, 13, 221) */
              tpath = tmp_line;
              /* skip over the "227 Some message " part */
              for (tpath += 4; *tpath && !isdigit((int) *tpath); tpath++);
              if (!*tpath) {
                     return 0;
              }
              /* skip over the host ip, to get the port */
              hoststart = tpath;
              for (i = 0; i < 4; i++) {
                     for (; isdigit((int) *tpath); tpath++);
                     if (*tpath != ',') {
                            return 0;
                     }
                     *tpath='.';   
                     tpath++;
              }
              tpath[-1] = '\0';
              memcpy(ip, hoststart, ip_size);
              ip[ip_size-1] = '\0';
              hoststart = ip;
              
              /* pull out the MSB of the port */
              portno = (unsigned short) strtoul(tpath, &ttpath, 10) * 256;
              if (ttpath == NULL) {
                     /* didn't get correct response from PASV */
                     return 0;
              }
              tpath = ttpath;
              if (*tpath != ',') {
                     return 0;
              }
              tpath++;
              /* pull out the LSB of the port */
              portno += (unsigned short) strtoul(tpath, &ttpath, 10);
#ifdef HAVE_IPV6
       } else {
              /* parse epsv command (|||6446|) */
              for (i = 0, tpath = tmp_line + 4; *tpath; tpath++) {
                     if (*tpath == '|') {
                            i++;
                            if (i == 3)
                                   break;
                     }
              }
              if (i < 3) {
                     return 0;
              }
              /* pull out the port */
              portno = (unsigned short) strtoul(tpath + 1, &ttpath, 10);
       }
#endif 
       if (ttpath == NULL) {
              /* didn't get correct response from EPSV/PASV */
              return 0;
       }

       if (phoststart) {
              *phoststart = hoststart;
       }      

       return portno;
}

Here is the caller graph for this function:

static int php_ftp_dirstream_close ( php_stream *  stream,
int close_handle  TSRMLS_DC 
) [static]

Definition at line 659 of file ftp_fopen_wrapper.c.

{
       php_ftp_dirstream_data *data = stream->abstract;

       /* close control connection */
       if (data->controlstream) {
              php_stream_close(data->controlstream);
              data->controlstream = NULL;
       }
       /* close data connection */
       php_stream_close(data->datastream);
       data->datastream = NULL;
       
       efree(data);
       stream->abstract = NULL;

       return 0;
}
static size_t php_ftp_dirstream_read ( php_stream *  stream,
char *  buf,
size_t count  TSRMLS_DC 
) [static]

Definition at line 608 of file ftp_fopen_wrapper.c.

{
       php_stream_dirent *ent = (php_stream_dirent *)buf;
       php_stream *innerstream;
       size_t tmp_len;
       char *basename;
       size_t basename_len;

       innerstream =  ((php_ftp_dirstream_data *)stream->abstract)->datastream;

       if (count != sizeof(php_stream_dirent)) {
              return 0;
       }

       if (php_stream_eof(innerstream)) {
              return 0;
       }

       if (!php_stream_get_line(innerstream, ent->d_name, sizeof(ent->d_name), &tmp_len)) {
              return 0;
       }

       php_basename(ent->d_name, tmp_len, NULL, 0, &basename, &basename_len TSRMLS_CC);
       if (!basename) {
              return 0;
       }

       if (!basename_len) {
              efree(basename);
              return 0;
       }

       tmp_len = MIN(sizeof(ent->d_name), basename_len - 1);
       memcpy(ent->d_name, basename, tmp_len);
       ent->d_name[tmp_len - 1] = '\0';
       efree(basename);

       /* Trim off trailing whitespace characters */
       tmp_len--;
       while (tmp_len >= 0 &&
                     (ent->d_name[tmp_len] == '\n' || ent->d_name[tmp_len] == '\r' ||
                      ent->d_name[tmp_len] == '\t' || ent->d_name[tmp_len] == ' ')) {
              ent->d_name[tmp_len--] = '\0';
       }

       return sizeof(php_stream_dirent);
}

Here is the call graph for this function:

static php_stream* php_ftp_fopen_connect ( php_stream_wrapper *  wrapper,
char *  path,
char *  mode,
int  options,
char **  opened_path,
php_stream_context *  context,
php_stream **  preuseid,
php_url **  presource,
int puse_ssl,
int *puse_ssl_on_data  TSRMLS_DC 
) [static]

Definition at line 133 of file ftp_fopen_wrapper.c.

{
       php_stream *stream = NULL, *reuseid = NULL;
       php_url *resource = NULL;
       int result, use_ssl, use_ssl_on_data = 0, tmp_len;
       char tmp_line[512];
       char *transport;
       int transport_len;

       resource = php_url_parse(path);
       if (resource == NULL || resource->path == NULL) {
              if (resource && presource) {
                     *presource = resource;
              }
              return NULL;
       }

       use_ssl = resource->scheme && (strlen(resource->scheme) > 3) && resource->scheme[3] == 's';

       /* use port 21 if one wasn't specified */
       if (resource->port == 0)
              resource->port = 21;
       
       transport_len = spprintf(&transport, 0, "tcp://%s:%d", resource->host, resource->port);
       stream = php_stream_xport_create(transport, transport_len, REPORT_ERRORS, STREAM_XPORT_CLIENT | STREAM_XPORT_CONNECT, NULL, NULL, context, NULL, NULL);
       efree(transport);
       if (stream == NULL) {
              result = 0; /* silence */
              goto connect_errexit;
       }

       php_stream_context_set(stream, context);
       php_stream_notify_info(context, PHP_STREAM_NOTIFY_CONNECT, NULL, 0);

       /* Start talking to ftp server */
       result = GET_FTP_RESULT(stream);
       if (result > 299 || result < 200) {
              php_stream_notify_error(context, PHP_STREAM_NOTIFY_FAILURE, tmp_line, result);
              goto connect_errexit;
       }

       if (use_ssl)  {
       
              /* send the AUTH TLS request name */
              php_stream_write_string(stream, "AUTH TLS\r\n");

              /* get the response */
              result = GET_FTP_RESULT(stream);
              if (result != 234) {
                     /* AUTH TLS not supported try AUTH SSL */
                     php_stream_write_string(stream, "AUTH SSL\r\n");
                     
                     /* get the response */
                     result = GET_FTP_RESULT(stream);
                     if (result != 334) {
                            use_ssl = 0;
                     } else {
                            /* we must reuse the old SSL session id */
                            /* if we talk to an old ftpd-ssl */
                            reuseid = stream;
                     }
              } else {
                     /* encrypt data etc */


              }

       }
       
       if (use_ssl) {
              if (php_stream_xport_crypto_setup(stream,
                            STREAM_CRYPTO_METHOD_SSLv23_CLIENT, NULL TSRMLS_CC) < 0
                            || php_stream_xport_crypto_enable(stream, 1 TSRMLS_CC) < 0) {
                     php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to activate SSL mode");
                     php_stream_close(stream);
                     stream = NULL;
                     goto connect_errexit;
              }
       
              /* set PBSZ to 0 */
              php_stream_write_string(stream, "PBSZ 0\r\n");

              /* ignore the response */
              result = GET_FTP_RESULT(stream);
              
              /* set data connection protection level */
#if FTPS_ENCRYPT_DATA
              php_stream_write_string(stream, "PROT P\r\n");

              /* get the response */
              result = GET_FTP_RESULT(stream);
              use_ssl_on_data = (result >= 200 && result<=299) || reuseid;
#else
              php_stream_write_string(stream, "PROT C\r\n");

              /* get the response */
              result = GET_FTP_RESULT(stream);
#endif
       }

#define PHP_FTP_CNTRL_CHK(val, val_len, err_msg) {      \
       unsigned char *s = val, *e = s + val_len; \
       while (s < e) {      \
              if (iscntrl(*s)) {   \
                     php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, err_msg, val);      \
                     goto connect_errexit;       \
              }      \
              s++;   \
       }      \
} 

       /* send the user name */
       if (resource->user != NULL) {
              tmp_len = php_raw_url_decode(resource->user, strlen(resource->user));

              PHP_FTP_CNTRL_CHK(resource->user, tmp_len, "Invalid login %s")

              php_stream_printf(stream TSRMLS_CC, "USER %s\r\n", resource->user);
       } else {
              php_stream_write_string(stream, "USER anonymous\r\n");
       }
       
       /* get the response */
       result = GET_FTP_RESULT(stream);
       
       /* if a password is required, send it */
       if (result >= 300 && result <= 399) {
              php_stream_notify_info(context, PHP_STREAM_NOTIFY_AUTH_REQUIRED, tmp_line, 0);

              if (resource->pass != NULL) {
                     tmp_len = php_raw_url_decode(resource->pass, strlen(resource->pass));

                     PHP_FTP_CNTRL_CHK(resource->pass, tmp_len, "Invalid password %s")

                     php_stream_printf(stream TSRMLS_CC, "PASS %s\r\n", resource->pass);
              } else {
                     /* if the user has configured who they are,
                        send that as the password */
                     char *from_address = php_ini_string("from", sizeof("from"), 0);
                     if (from_address[0] != '\0') {
                            php_stream_printf(stream TSRMLS_CC, "PASS %s\r\n", from_address);
                     } else {
                            php_stream_write_string(stream, "PASS anonymous\r\n");
                     }
              }

              /* read the response */
              result = GET_FTP_RESULT(stream);

              if (result > 299 || result < 200) {
                     php_stream_notify_error(context, PHP_STREAM_NOTIFY_AUTH_RESULT, tmp_line, result);
              } else {
                     php_stream_notify_info(context, PHP_STREAM_NOTIFY_AUTH_RESULT, tmp_line, result);
              }
       }
       if (result > 299 || result < 200) {
              goto connect_errexit;
       }

       if (puse_ssl) {
              *puse_ssl = use_ssl;
       }
       if (puse_ssl_on_data) {
              *puse_ssl_on_data = use_ssl_on_data;
       }
       if (preuseid) {
              *preuseid = reuseid;
       }
       if (presource) {
              *presource = resource;
       }

       return stream;

connect_errexit:
       if (resource) {
              php_url_free(resource);     
       }

       if (stream) {
              php_stream_close(stream);
       }

       return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int php_stream_ftp_mkdir ( php_stream_wrapper *  wrapper,
char *  url,
int  mode,
int  options,
php_stream_context *context  TSRMLS_DC 
) [static]

Definition at line 1036 of file ftp_fopen_wrapper.c.

{
       php_stream *stream = NULL;
       php_url *resource = NULL;
       int result, recursive = options & PHP_STREAM_MKDIR_RECURSIVE;
       char tmp_line[512];

       stream = php_ftp_fopen_connect(wrapper, url, "r", 0, NULL, NULL, NULL, &resource, NULL, NULL TSRMLS_CC);
       if (!stream) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to connect to %s", url);
              }
              goto mkdir_errexit;
       }

       if (resource->path == NULL) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid path provided in %s", url);
              }
              goto mkdir_errexit;
       }

       if (!recursive) {
              php_stream_printf(stream TSRMLS_CC, "MKD %s\r\n", resource->path);
              result = GET_FTP_RESULT(stream);
    } else {
        /* we look for directory separator from the end of string, thus hopefuly reducing our work load */
        char *p, *e, *buf;

        buf = estrdup(resource->path);
        e = buf + strlen(buf);

        /* find a top level directory we need to create */
        while ((p = strrchr(buf, '/'))) {
            *p = '\0';
                     php_stream_printf(stream TSRMLS_CC, "CWD %s\r\n", buf);
                     result = GET_FTP_RESULT(stream);
                     if (result >= 200 && result <= 299) {
                            *p = '/';
                            break;
                     }
        }
        if (p == buf) {
                     php_stream_printf(stream TSRMLS_CC, "MKD %s\r\n", resource->path);
                     result = GET_FTP_RESULT(stream);
        } else {
                     php_stream_printf(stream TSRMLS_CC, "MKD %s\r\n", buf);
                     result = GET_FTP_RESULT(stream);
                     if (result >= 200 && result <= 299) {
                            if (!p) {
                                   p = buf;
                            }
                            /* create any needed directories if the creation of the 1st directory worked */
                            while (++p != e) {
                                   if (*p == '\0' && *(p + 1) != '\0') {
                                          *p = '/';
                                          php_stream_printf(stream TSRMLS_CC, "MKD %s\r\n", buf);
                                          result = GET_FTP_RESULT(stream);
                                          if (result < 200 || result > 299) {
                                                 if (options & REPORT_ERRORS) {
                                                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", tmp_line);
                                                 }
                                                 break;
                                          }
                                   }
                            }
                     }
              }
        efree(buf);
    }

       php_url_free(resource);
       php_stream_close(stream);

       if (result < 200 || result > 299) {
              /* Failure */
              return 0;
       }

       return 1;

mkdir_errexit:
       if (resource) {
              php_url_free(resource);
       }
       if (stream) {
              php_stream_close(stream);
       }
       return 0;
}

Here is the call graph for this function:

php_stream* php_stream_ftp_opendir ( php_stream_wrapper *  wrapper,
char *  path,
char *  mode,
int  options,
char **  opened_path,
php_stream_context *context STREAMS_DC  TSRMLS_DC 
)

Definition at line 695 of file ftp_fopen_wrapper.c.

{
       php_stream *stream, *reuseid, *datastream = NULL;
       php_ftp_dirstream_data *dirsdata;
       php_url *resource = NULL;
       int result = 0, use_ssl, use_ssl_on_data = 0;
       char *hoststart = NULL, tmp_line[512];
       char ip[sizeof("123.123.123.123")];
       unsigned short portno;

       tmp_line[0] = '\0';

       stream = php_ftp_fopen_connect(wrapper, path, mode, options, opened_path, context, &reuseid, &resource, &use_ssl, &use_ssl_on_data TSRMLS_CC);
       if (!stream) {
              goto opendir_errexit;       
       }

       /* set the connection to be ascii */
       php_stream_write_string(stream, "TYPE A\r\n");
       result = GET_FTP_RESULT(stream);
       if (result > 299 || result < 200)
              goto opendir_errexit;

       /* set up the passive connection */
       portno = php_fopen_do_pasv(stream, ip, sizeof(ip), &hoststart TSRMLS_CC);

       if (!portno) {
              goto opendir_errexit;
       }

       php_stream_printf(stream TSRMLS_CC, "NLST %s\r\n", (resource->path != NULL ? resource->path : "/"));
       
       /* open the data channel */
       if (hoststart == NULL) {
              hoststart = resource->host;
       }
       datastream = php_stream_sock_open_host(hoststart, portno, SOCK_STREAM, 0, 0);
       if (datastream == NULL) {
              goto opendir_errexit;
       }

       result = GET_FTP_RESULT(stream);
       if (result != 150 && result != 125) {
              /* Could not retrieve or send the file 
               * this data will only be sent to us after connection on the data port was initiated.
               */
              php_stream_close(datastream);
              datastream = NULL;
              goto opendir_errexit;       
       }
       
       php_stream_context_set(datastream, context);

       if (use_ssl_on_data && (php_stream_xport_crypto_setup(stream,
                     STREAM_CRYPTO_METHOD_SSLv23_CLIENT, NULL TSRMLS_CC) < 0 ||
                     php_stream_xport_crypto_enable(stream, 1 TSRMLS_CC) < 0)) {

              php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to activate SSL mode");
              php_stream_close(datastream);
              datastream = NULL;
              goto opendir_errexit;
       }

       php_url_free(resource);

       dirsdata = emalloc(sizeof *dirsdata);
       dirsdata->datastream = datastream;
       dirsdata->controlstream = stream;
       dirsdata->dirstream = php_stream_alloc(&php_ftp_dirstream_ops, dirsdata, 0, mode);

       return dirsdata->dirstream;

opendir_errexit:
       if (resource) {
              php_url_free(resource);
       }
       if (stream) {
              php_stream_notify_error(context, PHP_STREAM_NOTIFY_FAILURE, tmp_line, result);
              php_stream_close(stream);
       }
       if (tmp_line[0] != '\0') {
              php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "FTP server reports %s", tmp_line);
       }
       return NULL;
}

Here is the call graph for this function:

static int php_stream_ftp_rename ( php_stream_wrapper *  wrapper,
char *  url_from,
char *  url_to,
int  options,
php_stream_context *context  TSRMLS_DC 
) [static]

Definition at line 957 of file ftp_fopen_wrapper.c.

{
       php_stream *stream = NULL;
       php_url *resource_from = NULL, *resource_to = NULL;
       int result;
       char tmp_line[512];

       resource_from = php_url_parse(url_from);
       resource_to = php_url_parse(url_to);
       /* Must be same scheme (ftp/ftp or ftps/ftps), same host, and same port 
              (or a 21/0 0/21 combination which is also "same") 
          Also require paths to/from */
       if (!resource_from ||
              !resource_to ||
              !resource_from->scheme ||
              !resource_to->scheme ||
              strcmp(resource_from->scheme, resource_to->scheme) ||
              !resource_from->host ||
              !resource_to->host ||
              strcmp(resource_from->host, resource_to->host) ||
              (resource_from->port != resource_to->port && 
               resource_from->port * resource_to->port != 0 && 
               resource_from->port + resource_to->port != 21) ||
              !resource_from->path ||
              !resource_to->path) {
              goto rename_errexit;
       }

       stream = php_ftp_fopen_connect(wrapper, url_from, "r", 0, NULL, NULL, NULL, NULL, NULL, NULL TSRMLS_CC);
       if (!stream) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to connect to %s", resource_from->host);
              }
              goto rename_errexit;
       }

       /* Rename FROM */
       php_stream_printf(stream TSRMLS_CC, "RNFR %s\r\n", (resource_from->path != NULL ? resource_from->path : "/"));

       result = GET_FTP_RESULT(stream);
       if (result < 300 || result > 399) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error Renaming file: %s", tmp_line);
              }
              goto rename_errexit;
       }

       /* Rename TO */
       php_stream_printf(stream TSRMLS_CC, "RNTO %s\r\n", (resource_to->path != NULL ? resource_to->path : "/"));

       result = GET_FTP_RESULT(stream);
       if (result < 200 || result > 299) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error Renaming file: %s", tmp_line);
              }
              goto rename_errexit;
       }

       php_url_free(resource_from);
       php_url_free(resource_to);
       php_stream_close(stream);
       return 1;

rename_errexit:
       if (resource_from) {
              php_url_free(resource_from);
       }
       if (resource_to) {
              php_url_free(resource_to);
       }
       if (stream) {
              php_stream_close(stream);
       }
       return 0;
}

Here is the call graph for this function:

static int php_stream_ftp_rmdir ( php_stream_wrapper *  wrapper,
char *  url,
int  options,
php_stream_context *context  TSRMLS_DC 
) [static]

Definition at line 1130 of file ftp_fopen_wrapper.c.

{
       php_stream *stream = NULL;
       php_url *resource = NULL;
       int result;
       char tmp_line[512];

       stream = php_ftp_fopen_connect(wrapper, url, "r", 0, NULL, NULL, NULL, &resource, NULL, NULL TSRMLS_CC);
       if (!stream) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to connect to %s", url);
              }
              goto rmdir_errexit;
       }

       if (resource->path == NULL) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid path provided in %s", url);
              }
              goto rmdir_errexit;
       }

       php_stream_printf(stream TSRMLS_CC, "RMD %s\r\n", resource->path);
       result = GET_FTP_RESULT(stream);

       if (result < 200 || result > 299) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", tmp_line);
              }
              goto rmdir_errexit;
       }

       php_url_free(resource);
       php_stream_close(stream);

       return 1;

rmdir_errexit:
       if (resource) {
              php_url_free(resource);
       }
       if (stream) {
              php_stream_close(stream);
       }
       return 0;
}

Here is the call graph for this function:

static int php_stream_ftp_stream_close ( php_stream_wrapper *  wrapper,
php_stream *stream  TSRMLS_DC 
) [static]

Definition at line 104 of file ftp_fopen_wrapper.c.

{
       php_stream *controlstream = stream->wrapperthis;
       int ret = 0;
       
       if (controlstream) {
              if (strpbrk(stream->mode, "wa+")) {
                     char tmp_line[512];
                     int result;

                     /* For write modes close data stream first to signal EOF to server */
                     result = GET_FTP_RESULT(controlstream);
                     if (result != 226 && result != 250) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "FTP server error %d:%s", result, tmp_line);
                            ret = EOF;
                     }
              }

              php_stream_write_string(controlstream, "QUIT\r\n");
              php_stream_close(controlstream);
              stream->wrapperthis = NULL;
       }

       return ret;
}
static int php_stream_ftp_stream_stat ( php_stream_wrapper *  wrapper,
php_stream *  stream,
php_stream_statbuf *ssb  TSRMLS_DC 
) [static]

Definition at line 94 of file ftp_fopen_wrapper.c.

{
       /* For now, we return with a failure code to prevent the underlying
        * file's details from being used instead. */
       return -1;
}
static int php_stream_ftp_unlink ( php_stream_wrapper *  wrapper,
char *  url,
int  options,
php_stream_context *context  TSRMLS_DC 
) [static]

Definition at line 907 of file ftp_fopen_wrapper.c.

{
       php_stream *stream = NULL;
       php_url *resource = NULL;
       int result;
       char tmp_line[512];

       stream = php_ftp_fopen_connect(wrapper, url, "r", 0, NULL, NULL, NULL, &resource, NULL, NULL TSRMLS_CC);
       if (!stream) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to connect to %s", url);
              }
              goto unlink_errexit;
       }

       if (resource->path == NULL) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid path provided in %s", url);
              }
              goto unlink_errexit;
       }

       /* Attempt to delete the file */
       php_stream_printf(stream TSRMLS_CC, "DELE %s\r\n", (resource->path != NULL ? resource->path : "/"));

       result = GET_FTP_RESULT(stream);
       if (result < 200 || result > 299) {
              if (options & REPORT_ERRORS) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error Deleting file: %s", tmp_line);
              }
              goto unlink_errexit;
       }

       php_url_free(resource);
       php_stream_close(stream);
       return 1;

unlink_errexit:
       if (resource) {
              php_url_free(resource);
       }
       if (stream) {
              php_stream_close(stream);
       }
       return 0;
}

Here is the call graph for this function:

static int php_stream_ftp_url_stat ( php_stream_wrapper *  wrapper,
char *  url,
int  flags,
php_stream_statbuf ssb,
php_stream_context *context  TSRMLS_DC 
) [static]

Definition at line 784 of file ftp_fopen_wrapper.c.

{
       php_stream *stream = NULL;
       php_url *resource = NULL;
       int result;
       char tmp_line[512];

       /* If ssb is NULL then someone is misbehaving */
       if (!ssb) return -1;

       stream = php_ftp_fopen_connect(wrapper, url, "r", 0, NULL, context, NULL, &resource, NULL, NULL TSRMLS_CC);
       if (!stream) {
              goto stat_errexit;
       }

       ssb->sb.st_mode = 0644;                                                             /* FTP won't give us a valid mode, so aproximate one based on being readable */
       php_stream_printf(stream TSRMLS_CC, "CWD %s\r\n", (resource->path != NULL ? resource->path : "/")); /* If we can CWD to it, it's a directory (maybe a link, but we can't tell) */
       result = GET_FTP_RESULT(stream);
       if (result < 200 || result > 299) {
              ssb->sb.st_mode |= S_IFREG;
       } else {
              ssb->sb.st_mode |= S_IFDIR;
       }

       php_stream_write_string(stream, "TYPE I\r\n"); /* we need this since some servers refuse to accept SIZE command in ASCII mode */
       
       result = GET_FTP_RESULT(stream);

       if(result < 200 || result > 299) {
              goto stat_errexit;
       }
       
       php_stream_printf(stream TSRMLS_CC, "SIZE %s\r\n", (resource->path != NULL ? resource->path : "/"));
       result = GET_FTP_RESULT(stream);
       if (result < 200 || result > 299) {
              /* Failure either means it doesn't exist 
                 or it's a directory and this server
                 fails on listing directory sizes */
              if (ssb->sb.st_mode & S_IFDIR) {
                     ssb->sb.st_size = 0;
              } else {
                     goto stat_errexit;
              }
       } else {
              ssb->sb.st_size = atoi(tmp_line + 4);
       }

       php_stream_printf(stream TSRMLS_CC, "MDTM %s\r\n", (resource->path != NULL ? resource->path : "/"));
       result = GET_FTP_RESULT(stream);
       if (result == 213) {
              char *p = tmp_line + 4;
              int n;
              struct tm tm, tmbuf, *gmt;
              time_t stamp;

              while (p - tmp_line < sizeof(tmp_line) && !isdigit(*p)) {
                     p++;
              }

              if (p - tmp_line > sizeof(tmp_line)) {
                     goto mdtm_error;
              }

              n = sscanf(p, "%4u%2u%2u%2u%2u%2u", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
              if (n != 6) {
                     goto mdtm_error;
              }

              tm.tm_year -= 1900;
              tm.tm_mon--;
              tm.tm_isdst = -1;

              /* figure out the GMT offset */
              stamp = time(NULL);
              gmt = php_gmtime_r(&stamp, &tmbuf);
              if (!gmt) {
                     goto mdtm_error;
              }
              gmt->tm_isdst = -1;

              /* apply the GMT offset */
              tm.tm_sec += stamp - mktime(gmt);
              tm.tm_isdst = gmt->tm_isdst;

              ssb->sb.st_mtime = mktime(&tm);
       } else {
              /* error or unsupported command */
mdtm_error:
              ssb->sb.st_mtime = -1;
       }

       ssb->sb.st_ino = 0;                                     /* Unknown values */
       ssb->sb.st_dev = 0;
       ssb->sb.st_uid = 0;
       ssb->sb.st_gid = 0;
       ssb->sb.st_atime = -1;
       ssb->sb.st_ctime = -1;

       ssb->sb.st_nlink = 1;
       ssb->sb.st_rdev = -1;
#ifdef HAVE_ST_BLKSIZE
       ssb->sb.st_blksize = 4096;                       /* Guess since FTP won't expose this information */
#ifdef HAVE_ST_BLOCKS
       ssb->sb.st_blocks = (int)((4095 + ssb->sb.st_size) / ssb->sb.st_blksize); /* emulate ceil */
#endif
#endif
       php_stream_close(stream);
       php_url_free(resource);
       return 0;

stat_errexit:
       if (resource) {
              php_url_free(resource);
       }
       if (stream) {
              php_stream_close(stream);
       }
       return -1;
}

Here is the call graph for this function:

php_stream* php_stream_url_wrap_ftp ( php_stream_wrapper *  wrapper,
char *  path,
char *  mode,
int  options,
char **  opened_path,
php_stream_context *context STREAMS_DC  TSRMLS_DC 
)

Definition at line 414 of file ftp_fopen_wrapper.c.

{
       php_stream *stream = NULL, *datastream = NULL;
       php_url *resource = NULL;
       char tmp_line[512];
       char ip[sizeof("123.123.123.123")];
       unsigned short portno;
       char *hoststart = NULL;
       int result = 0, use_ssl, use_ssl_on_data=0;
       php_stream *reuseid=NULL;
       size_t file_size = 0;
       zval **tmpzval;
       int allow_overwrite = 0;
       int read_write = 0;
       char *transport;
       int transport_len;

       tmp_line[0] = '\0';

       if (strpbrk(mode, "r+")) {
              read_write = 1; /* Open for reading */
       }
       if (strpbrk(mode, "wa+")) {
              if (read_write) {
                     php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "FTP does not support simultaneous read/write connections");
                     return NULL;
              }
              if (strchr(mode, 'a')) {
                     read_write = 3; /* Open for Appending */
              } else {
                     read_write = 2; /* Open for writting */
              }
       }
       if (!read_write) {
              /* No mode specified? */
              php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unknown file open mode");
              return NULL;
       }

       if (context &&
              php_stream_context_get_option(context, "ftp", "proxy", &tmpzval) == SUCCESS) {
              if (read_write == 1) {
                     /* Use http wrapper to proxy ftp request */
                     return php_stream_url_wrap_http(wrapper, path, mode, options, opened_path, context STREAMS_CC TSRMLS_CC);
              } else {
                     /* ftp proxy is read-only */
                     php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "FTP proxy may only be used in read mode");
                     return NULL;
              }
       }

       stream = php_ftp_fopen_connect(wrapper, path, mode, options, opened_path, context, &reuseid, &resource, &use_ssl, &use_ssl_on_data TSRMLS_CC);
       if (!stream) {
              goto errexit;
       }

       /* set the connection to be binary */
       php_stream_write_string(stream, "TYPE I\r\n");
       result = GET_FTP_RESULT(stream);
       if (result > 299 || result < 200)
              goto errexit;
       
       /* find out the size of the file (verifying it exists) */
       php_stream_printf(stream TSRMLS_CC, "SIZE %s\r\n", resource->path);
       
       /* read the response */
       result = GET_FTP_RESULT(stream);
       if (read_write == 1) {
              /* Read Mode */
              char *sizestr;
              
              /* when reading file, it must exist */
              if (result > 299 || result < 200) {
                     errno = ENOENT;
                     goto errexit;
              }
              
              sizestr = strchr(tmp_line, ' ');
              if (sizestr) {
                     sizestr++;
                     file_size = atoi(sizestr);
                     php_stream_notify_file_size(context, file_size, tmp_line, result);
              }      
       } else if (read_write == 2) {
              /* when writing file (but not appending), it must NOT exist, unless a context option exists which allows it */
              if (context && php_stream_context_get_option(context, "ftp", "overwrite", &tmpzval) == SUCCESS) {
                     allow_overwrite = Z_LVAL_PP(tmpzval);
              }
              if (result <= 299 && result >= 200) {
                     if (allow_overwrite) {
                            /* Context permits overwritting file, 
                               so we just delete whatever's there in preparation */
                            php_stream_printf(stream TSRMLS_CC, "DELE %s\r\n", resource->path);
                            result = GET_FTP_RESULT(stream);
                            if (result >= 300 || result <= 199) {
                                   goto errexit;
                            }
                     } else {
                            php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Remote file already exists and overwrite context option not specified");
                            errno = EEXIST;
                            goto errexit;
                     }
              }
       }

       /* set up the passive connection */
       portno = php_fopen_do_pasv(stream, ip, sizeof(ip), &hoststart TSRMLS_CC);

       if (!portno) {
              goto errexit;
       }

       /* Send RETR/STOR command */
       if (read_write == 1) {
              /* set resume position if applicable */
              if (context &&
                     php_stream_context_get_option(context, "ftp", "resume_pos", &tmpzval) == SUCCESS &&
                     Z_TYPE_PP(tmpzval) == IS_LONG &&
                     Z_LVAL_PP(tmpzval) > 0) {
                     php_stream_printf(stream TSRMLS_CC, "REST %ld\r\n", Z_LVAL_PP(tmpzval));
                     result = GET_FTP_RESULT(stream);
                     if (result < 300 || result > 399) {                     
                            php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to resume from offset %ld", Z_LVAL_PP(tmpzval));
                            goto errexit;
                     }
              }

              /* retrieve file */
              memcpy(tmp_line, "RETR", sizeof("RETR"));
       } else if (read_write == 2) {
              /* Write new file */
              memcpy(tmp_line, "STOR", sizeof("STOR"));
       } else {
              /* Append */
              memcpy(tmp_line, "APPE", sizeof("APPE"));
       } 
       php_stream_printf(stream TSRMLS_CC, "%s %s\r\n", tmp_line, (resource->path != NULL ? resource->path : "/"));
       
       /* open the data channel */
       if (hoststart == NULL) {
              hoststart = resource->host;
       }
       transport_len = spprintf(&transport, 0, "tcp://%s:%d", hoststart, portno);
       datastream = php_stream_xport_create(transport, transport_len, REPORT_ERRORS, STREAM_XPORT_CLIENT | STREAM_XPORT_CONNECT, NULL, NULL, context, NULL, NULL);
       efree(transport);
       if (datastream == NULL) {
              goto errexit;
       }

       result = GET_FTP_RESULT(stream);
       if (result != 150 && result != 125) {
              /* Could not retrieve or send the file 
               * this data will only be sent to us after connection on the data port was initiated.
               */
              php_stream_close(datastream);
              datastream = NULL;
              goto errexit; 
       }
       
       php_stream_context_set(datastream, context);
       php_stream_notify_progress_init(context, 0, file_size);

       if (use_ssl_on_data && (php_stream_xport_crypto_setup(datastream,
                     STREAM_CRYPTO_METHOD_SSLv23_CLIENT, NULL TSRMLS_CC) < 0 ||
                     php_stream_xport_crypto_enable(datastream, 1 TSRMLS_CC) < 0)) {

              php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to activate SSL mode");
              php_stream_close(datastream);
              datastream = NULL;
              goto errexit;
       }

       /* remember control stream */      
       datastream->wrapperthis = stream;

       php_url_free(resource);
       return datastream;

errexit:
       if (resource) {
              php_url_free(resource);
       }
       if (stream) {
              php_stream_notify_error(context, PHP_STREAM_NOTIFY_FAILURE, tmp_line, result);
              php_stream_close(stream);
       }
       if (tmp_line[0] != '\0')
              php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "FTP server reports %s", tmp_line);
       return NULL;
}

Here is the call graph for this function:


Variable Documentation

Initial value:

Definition at line 681 of file ftp_fopen_wrapper.c.

PHPAPI php_stream_wrapper php_stream_ftp_wrapper
Initial value:

Definition at line 1191 of file ftp_fopen_wrapper.c.