FREE THOUGHT · FREE SOFTWARE · FREE WORLD

Home » PHP » PHP File Uploads

by comment

turn on open_basedir  error = 6 //Missing a temporary folder.

//./main/rfc1867.c

/* The longest property name we use in an uploaded file array */
#define MAX_SIZE_OF_INDEX sizeof("[tmp_name]")

/* The longest anonymous name */
#define MAX_SIZE_ANONNAME 33

/* Errors */
#define UPLOAD_ERROR_OK   0  /* File upload succesful */
#define UPLOAD_ERROR_A    1  /* Uploaded file exceeded upload_max_filesize */
#define UPLOAD_ERROR_B    2  /* Uploaded file exceeded MAX_FILE_SIZE */
#define UPLOAD_ERROR_C    3  /* Partially uploaded */
#define UPLOAD_ERROR_D    4  /* No file uploaded */
#define UPLOAD_ERROR_E    6  /* Missing /tmp or similar directory */
#define UPLOAD_ERROR_F    7  /* Failed to write file to disk */
#define UPLOAD_ERROR_X    8  /* File upload stopped by extension */

void php_rfc1867_register_constants(TSRMLS_D)
{
    REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_OK",         UPLOAD_ERROR_OK, CONST_CS | CONST_PERSISTENT);
    REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_INI_SIZE",   UPLOAD_ERROR_A,  CONST_CS | CONST_PERSISTENT);
    REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_FORM_SIZE",  UPLOAD_ERROR_B,  CONST_CS | CONST_PERSISTENT);
    REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_PARTIAL",    UPLOAD_ERROR_C,  CONST_CS | CONST_PERSISTENT);
    REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_NO_FILE",    UPLOAD_ERROR_D,  CONST_CS | CONST_PERSISTENT);
    REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_NO_TMP_DIR", UPLOAD_ERROR_E,  CONST_CS | CONST_PERSISTENT);
    REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_CANT_WRITE", UPLOAD_ERROR_F,  CONST_CS | CONST_PERSISTENT);
    REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_EXTENSION",  UPLOAD_ERROR_X,  CONST_CS | CONST_PERSISTENT);
}

/*
 * The combined READER/HANDLER
 *
 */

SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler)
{
    char *boundary, *s=NULL, *boundary_end = NULL, *start_arr=NULL, *array_index=NULL;
    char *temp_filename=NULL, *lbuf=NULL, *abuf=NULL;
    int boundary_len=0, total_bytes=0, cancel_upload=0, is_arr_upload=0, array_len=0;
    int max_file_size=0, skip_upload=0, anonindex=0, is_anonymous;
    zval *http_post_files=NULL; HashTable *uploaded_files=NULL;
#if HAVE_MBSTRING && !defined(COMPILE_DL_MBSTRING)
    int str_len = 0, num_vars = 0, num_vars_max = 2*10, *len_list = NULL;
    char **val_list = NULL;
#endif
    multipart_buffer *mbuff;
    zval *array_ptr = (zval *) arg;
    int fd=-1;
    zend_llist header;
    void *event_extra_data = NULL;
    int llen = 0;

    if (SG(request_info).content_length > SG(post_max_size)) {
        sapi_module.sapi_error(E_WARNING, "POST Content-Length of %ld bytes exceeds the limit of %ld bytes", SG(request_info).content_length, SG(post_max_size));
        return;
    }

    /* Get the boundary */
    boundary = strstr(content_type_dup, "boundary");
    if (!boundary || !(boundary=strchr(boundary, '='))) {
        sapi_module.sapi_error(E_WARNING, "Missing boundary in multipart/form-data POST data");
        return;
    }

    boundary++;
    boundary_len = strlen(boundary);

    if (boundary[0] == '"') {
        boundary++;
        boundary_end = strchr(boundary, '"');
        if (!boundary_end) {
            sapi_module.sapi_error(E_WARNING, "Invalid boundary in multipart/form-data POST data");
            return;
        }
    } else {
        /* search for the end of the boundary */
        boundary_end = strchr(boundary, ',');
    }
    if (boundary_end) {
        boundary_end[0] = '�';
        boundary_len = boundary_end-boundary;
    }

    /* Initialize the buffer */
    if (!(mbuff = multipart_buffer_new(boundary, boundary_len))) {
        sapi_module.sapi_error(E_WARNING, "Unable to initialize the input buffer");
        return;
    }

    /* Initialize $_FILES[] */
    zend_hash_init(&PG(rfc1867_protected_variables), 5, NULL, NULL, 0);

    ALLOC_HASHTABLE(uploaded_files);
    zend_hash_init(uploaded_files, 5, NULL, (dtor_func_t) free_estring, 0);
    SG(rfc1867_uploaded_files) = uploaded_files;

    ALLOC_ZVAL(http_post_files);
    array_init(http_post_files);
    INIT_PZVAL(http_post_files);
    PG(http_globals)[TRACK_VARS_FILES] = http_post_files;

#if HAVE_MBSTRING && !defined(COMPILE_DL_MBSTRING)
    if (php_mb_encoding_translation(TSRMLS_C)) {
        val_list = (char **)ecalloc(num_vars_max+2, sizeof(char *));
        len_list = (int *)ecalloc(num_vars_max+2, sizeof(int));
    }
#endif
    zend_llist_init(&header, sizeof(mime_header_entry), (llist_dtor_func_t) php_free_hdr_entry, 0);

    if (php_rfc1867_callback != NULL) {
        multipart_event_start event_start;

        event_start.content_length = SG(request_info).content_length;
        if (php_rfc1867_callback(MULTIPART_EVENT_START, &event_start, &event_extra_data TSRMLS_CC) == FAILURE) {
            goto fileupload_done;
        }
    }

    while (!multipart_buffer_eof(mbuff TSRMLS_CC))
    {
        char buff[FILLUNIT];
        char *cd=NULL,*param=NULL,*filename=NULL, *tmp=NULL;
        size_t blen=0, wlen=0;
        off_t offset;

        zend_llist_clean(&header);

        if (!multipart_buffer_headers(mbuff, &header TSRMLS_CC)) {
            goto fileupload_done;
        }

        if ((cd = php_mime_get_hdr_value(header, "Content-Disposition"))) {
            char *pair=NULL;
            int end=0;

            while (isspace(*cd)) {
                ++cd;
            }

            while (*cd && (pair = php_ap_getword(&cd, ';')))
            {
                char *key=NULL, *word = pair;

                while (isspace(*cd)) {
                    ++cd;
                }

                if (strchr(pair, '=')) {
                    key = php_ap_getword(&pair, '=');

                    if (!strcasecmp(key, "name")) {
                        if (param) {
                            efree(param);
                        }
                        param = php_ap_getword_conf(&pair TSRMLS_CC);
                    } else if (!strcasecmp(key, "filename")) {
                        if (filename) {
                            efree(filename);
                        }
                        filename = php_ap_getword_conf(&pair TSRMLS_CC);
                    }
                }
                if (key) {
                    efree(key);
                }
                efree(word);
            }

            /* Normal form variable, safe to read all data into memory */
            if (!filename && param) {
                unsigned int value_len;
                char *value = multipart_buffer_read_body(mbuff, &value_len TSRMLS_CC);
                unsigned int new_val_len; /* Dummy variable */

                if (!value) {
                    value = estrdup("");
                }

                if (sapi_module.input_filter(PARSE_POST, param, &value, value_len, &new_val_len TSRMLS_CC)) {
                    if (php_rfc1867_callback != NULL) {
                        multipart_event_formdata event_formdata;
                        size_t newlength = new_val_len;

                        event_formdata.post_bytes_processed = SG(read_post_bytes);
                        event_formdata.name = param;
                        event_formdata.value = &value;
                        event_formdata.length = new_val_len;
                        event_formdata.newlength = &newlength;
                        if (php_rfc1867_callback(MULTIPART_EVENT_FORMDATA, &event_formdata, &event_extra_data TSRMLS_CC) == FAILURE) {
                            efree(param);
                            efree(value);
                            continue;
                        }
                        new_val_len = newlength;
                    }

#if HAVE_MBSTRING && !defined(COMPILE_DL_MBSTRING)
                    if (php_mb_encoding_translation(TSRMLS_C)) {
                        php_mb_gpc_stack_variable(param, value, &val_list, &len_list,
                                                  &num_vars, &num_vars_max TSRMLS_CC);
                    } else {
                        safe_php_register_variable(param, value, new_val_len, array_ptr, 0 TSRMLS_CC);
                    }
#else
                    safe_php_register_variable(param, value, new_val_len, array_ptr, 0 TSRMLS_CC);
#endif
                } else if (php_rfc1867_callback != NULL) {
                    multipart_event_formdata event_formdata;

                    event_formdata.post_bytes_processed = SG(read_post_bytes);
                    event_formdata.name = param;
                    event_formdata.value = &value;
                    event_formdata.length = value_len;
                    event_formdata.newlength = NULL;
                    php_rfc1867_callback(MULTIPART_EVENT_FORMDATA, &event_formdata, &event_extra_data TSRMLS_CC);
                }

                if (!strcasecmp(param, "MAX_FILE_SIZE")) {
                    max_file_size = atol(value);
                }

                efree(param);
                efree(value);
                continue;
            }

            /* If file_uploads=off, skip the file part */
            if (!PG(file_uploads)) {
                skip_upload = 1;
            }

            /* Return with an error if the posted data is garbled */
            if (!param && !filename) {
                sapi_module.sapi_error(E_WARNING, "File Upload Mime headers garbled");
                goto fileupload_done;
            }

            if (!param) {
                is_anonymous = 1;
                param = emalloc(MAX_SIZE_ANONNAME);
                snprintf(param, MAX_SIZE_ANONNAME, "%u", anonindex++);
            } else {
                is_anonymous = 0;
            }

            /* New Rule: never repair potential malicious user input */
            if (!skip_upload) {
                char *tmp = param;
                long c = 0;

                while (*tmp) {
                    if (*tmp == '[') {
                        c++;
                    } else if (*tmp == ']') {
                        c--;
                        if (tmp[1] && tmp[1] != '[') {
                            skip_upload = 1;
                            break;
                        }
                    }
                    if (c < 0) {
                        skip_upload = 1;
                        break;
                    }
                    tmp++;
                }
            }

            total_bytes = cancel_upload = 0;

            if (!skip_upload) {
                /* Handle file */
                fd = php_open_temporary_fd_ex(PG(upload_tmp_dir), "php", &temp_filename, 1 TSRMLS_CC);
                if (fd==-1) {
                    sapi_module.sapi_error(E_WARNING, "File upload error - unable to create a temporary file");
                    cancel_upload = UPLOAD_ERROR_E;
                }
            }

            if (!skip_upload && php_rfc1867_callback != NULL) {
                multipart_event_file_start event_file_start;

                event_file_start.post_bytes_processed = SG(read_post_bytes);
                event_file_start.name = param;
                event_file_start.filename = &filename;
                if (php_rfc1867_callback(MULTIPART_EVENT_FILE_START, &event_file_start, &event_extra_data TSRMLS_CC) == FAILURE) {
                    if (temp_filename) {
                        if (cancel_upload != UPLOAD_ERROR_E) { /* file creation failed */
                            close(fd);
                            unlink(temp_filename);
                        }
                        efree(temp_filename);
                    }
                    temp_filename="";
                    efree(param);
                    efree(filename);
                    continue;
                }
            }

            if (skip_upload) {
                efree(param);
                efree(filename);
                continue;
            }

            if(strlen(filename) == 0) {
#if DEBUG_FILE_UPLOAD
                sapi_module.sapi_error(E_NOTICE, "No file uploaded");
#endif
                cancel_upload = UPLOAD_ERROR_D;
            }

            offset = 0;
            end = 0;
            while (!cancel_upload && (blen = multipart_buffer_read(mbuff, buff, sizeof(buff), &end TSRMLS_CC)))
            {
                if (php_rfc1867_callback != NULL) {
                    multipart_event_file_data event_file_data;

                    event_file_data.post_bytes_processed = SG(read_post_bytes);
                    event_file_data.offset = offset;
                    event_file_data.data = buff;
                    event_file_data.length = blen;
                    event_file_data.newlength = &blen;
                    if (php_rfc1867_callback(MULTIPART_EVENT_FILE_DATA, &event_file_data, &event_extra_data TSRMLS_CC) == FAILURE) {
                        cancel_upload = UPLOAD_ERROR_X;
                        continue;
                    }
                }

                if (PG(upload_max_filesize) > 0 && (total_bytes+blen) > PG(upload_max_filesize)) {
#if DEBUG_FILE_UPLOAD
                    sapi_module.sapi_error(E_NOTICE, "upload_max_filesize of %ld bytes exceeded - file [%s=%s] not saved", PG(upload_max_filesize), param, filename);
#endif
                    cancel_upload = UPLOAD_ERROR_A;
                } else if (max_file_size && ((total_bytes+blen) > max_file_size)) {
#if DEBUG_FILE_UPLOAD
                    sapi_module.sapi_error(E_NOTICE, "MAX_FILE_SIZE of %ld bytes exceeded - file [%s=%s] not saved", max_file_size, param, filename);
#endif
                    cancel_upload = UPLOAD_ERROR_B;
                } else if (blen > 0) {

                    wlen = write(fd, buff, blen);

                    if (wlen == -1) {
                        /* write failed */
#if DEBUG_FILE_UPLOAD
                        sapi_module.sapi_error(E_NOTICE, "write() failed - %s", strerror(errno));
#endif
                        cancel_upload = UPLOAD_ERROR_F;
                    } else if (wlen < blen) {
#if DEBUG_FILE_UPLOAD
                        sapi_module.sapi_error(E_NOTICE, "Only %d bytes were written, expected to write %d", wlen, blen);
#endif
                        cancel_upload = UPLOAD_ERROR_F;
                    } else {
                        total_bytes += wlen;
                    }

                    offset += wlen;
                }
            }
            if (fd!=-1) { /* may not be initialized if file could not be created */
                close(fd);
            }
            if (!cancel_upload && !end) {
#if DEBUG_FILE_UPLOAD
                sapi_module.sapi_error(E_NOTICE, "Missing mime boundary at the end of the data for file %s", strlen(filename) > 0 ? filename : "");
#endif
                cancel_upload = UPLOAD_ERROR_C;
            }
#if DEBUG_FILE_UPLOAD
            if(strlen(filename) > 0 && total_bytes == 0 && !cancel_upload) {
                sapi_module.sapi_error(E_WARNING, "Uploaded file size 0 - file [%s=%s] not saved", param, filename);
                cancel_upload = 5;
            }
#endif

            if (php_rfc1867_callback != NULL) {
                multipart_event_file_end event_file_end;

                event_file_end.post_bytes_processed = SG(read_post_bytes);
                event_file_end.temp_filename = temp_filename;
                event_file_end.cancel_upload = cancel_upload;
                if (php_rfc1867_callback(MULTIPART_EVENT_FILE_END, &event_file_end, &event_extra_data TSRMLS_CC) == FAILURE) {
                    cancel_upload = UPLOAD_ERROR_X;
                }
            }

            if (cancel_upload) {
                if (temp_filename) {
                    if (cancel_upload != UPLOAD_ERROR_E) { /* file creation failed */
                        unlink(temp_filename);
                    }
                    efree(temp_filename);
                }
                temp_filename="";
            } else {
                zend_hash_add(SG(rfc1867_uploaded_files), temp_filename, strlen(temp_filename) + 1, &temp_filename, sizeof(char *), NULL);
            }

            /* is_arr_upload is true when name of file upload field
             * ends in [.*]
             * start_arr is set to point to 1st [
             */
            is_arr_upload = (start_arr = strchr(param,'[')) && (param[strlen(param)-1] == ']');

            if (is_arr_upload) {
                array_len = strlen(start_arr);
                if (array_index) {
                    efree(array_index);
                }
                array_index = estrndup(start_arr+1, array_len-2);
            }

            /* Add $foo_name */
            if (llen < strlen(param) + MAX_SIZE_OF_INDEX + 1) {
                llen = strlen(param);
                lbuf = (char *) safe_erealloc(lbuf, llen, 1, MAX_SIZE_OF_INDEX + 1);
                llen += MAX_SIZE_OF_INDEX + 1;
            }

            if (is_arr_upload) {
                if (abuf) efree(abuf);
                abuf = estrndup(param, strlen(param)-array_len);
                snprintf(lbuf, llen, "%s_name[%s]", abuf, array_index);
            } else {
                snprintf(lbuf, llen, "%s_name", param);
            }

#if HAVE_MBSTRING && !defined(COMPILE_DL_MBSTRING)
            if (php_mb_encoding_translation(TSRMLS_C)) {
                if (num_vars>=num_vars_max){
                    php_mb_gpc_realloc_buffer(&val_list, &len_list, &num_vars_max,
                                              1 TSRMLS_CC);
                }
                val_list[num_vars] = filename;
                len_list[num_vars] = strlen(filename);
                num_vars++;
                if(php_mb_gpc_encoding_detector(val_list, len_list, num_vars, NULL TSRMLS_CC) == SUCCESS) {
                    str_len = strlen(filename);
                    php_mb_gpc_encoding_converter(&filename, &str_len, 1, NULL, NULL TSRMLS_CC);
                }
                s = php_mb_strrchr(filename, '\' TSRMLS_CC);
                if ((tmp = php_mb_strrchr(filename, '/' TSRMLS_CC)) > s) {
                    s = tmp;
                }
                num_vars--;
                goto filedone;
            }
#endif
            /* The  check should technically be needed for win32 systems only where
             * it is a valid path separator. However, IE in all it's wisdom always sends
             * the full path of the file on the user's filesystem, which means that unless
             * the user does basename() they get a bogus file name. Until IE's user base drops
             * to nill or problem is fixed this code must remain enabled for all systems.
             */
            s = strrchr(filename, '\');
            if ((tmp = strrchr(filename, '/')) > s) {
                s = tmp;
            }
#ifdef PHP_WIN32
            if (PG(magic_quotes_gpc)) {
                s = s ? s : filename;
                tmp = strrchr(s, ''');
                s = tmp > s ? tmp : s;
                tmp = strrchr(s, '"');
                s = tmp > s ? tmp : s;
            }
#endif

#if HAVE_MBSTRING && !defined(COMPILE_DL_MBSTRING)
filedone:
#endif

            if (!is_anonymous) {
                if (s && s > filename) {
                    safe_php_register_variable(lbuf, s+1, strlen(s+1), NULL, 0 TSRMLS_CC);
                } else {
                    safe_php_register_variable(lbuf, filename, strlen(filename), NULL, 0 TSRMLS_CC);
                }
            }

            /* Add $foo[name] */
            if (is_arr_upload) {
                snprintf(lbuf, llen, "%s[name][%s]", abuf, array_index);
            } else {
                snprintf(lbuf, llen, "%s[name]", param);
            }
            if (s && s > filename) {
                register_http_post_files_variable(lbuf, s+1, http_post_files, 0 TSRMLS_CC);
            } else {
                register_http_post_files_variable(lbuf, filename, http_post_files, 0 TSRMLS_CC);
            }
            efree(filename);
            s = NULL;

            /* Possible Content-Type: */
            if (cancel_upload || !(cd = php_mime_get_hdr_value(header, "Content-Type"))) {
                cd = "";
            } else {
                /* fix for Opera 6.01 */
                s = strchr(cd, ';');
                if (s != NULL) {
                    *s = '�';
                }
            }

            /* Add $foo_type */
            if (is_arr_upload) {
                snprintf(lbuf, llen, "%s_type[%s]", abuf, array_index);
            } else {
                snprintf(lbuf, llen, "%s_type", param);
            }
            if (!is_anonymous) {
                safe_php_register_variable(lbuf, cd, strlen(cd), NULL, 0 TSRMLS_CC);
            }

            /* Add $foo[type] */
            if (is_arr_upload) {
                snprintf(lbuf, llen, "%s[type][%s]", abuf, array_index);
            } else {
                snprintf(lbuf, llen, "%s[type]", param);
            }
            register_http_post_files_variable(lbuf, cd, http_post_files, 0 TSRMLS_CC);

            /* Restore Content-Type Header */
            if (s != NULL) {
                *s = ';';
            }
            s = "";

            {
                /* store temp_filename as-is (without magic_quotes_gpc-ing it, in case upload_tmp_dir
                 * contains escapeable characters. escape only the variable name.) */
                zval zfilename;

                /* Initialize variables */
                add_protected_variable(param TSRMLS_CC);

                /* if param is of form xxx[.*] this will cut it to xxx */
                if (!is_anonymous) {
                    ZVAL_STRING(&zfilename, temp_filename, 1);
                    safe_php_register_variable_ex(param, &zfilename, NULL, 1 TSRMLS_CC);
                }

                /* Add $foo[tmp_name] */
                if (is_arr_upload) {
                    snprintf(lbuf, llen, "%s[tmp_name][%s]", abuf, array_index);
                } else {
                    snprintf(lbuf, llen, "%s[tmp_name]", param);
                }
                add_protected_variable(lbuf TSRMLS_CC);
                ZVAL_STRING(&zfilename, temp_filename, 1);
                register_http_post_files_variable_ex(lbuf, &zfilename, http_post_files, 1 TSRMLS_CC);
            }

            {
                zval file_size, error_type;

                error_type.value.lval = cancel_upload;
                error_type.type = IS_LONG;

                /* Add $foo[error] */
                if (cancel_upload) {
                    file_size.value.lval = 0;
                    file_size.type = IS_LONG;
                } else {
                    file_size.value.lval = total_bytes;
                    file_size.type = IS_LONG;
                }

                if (is_arr_upload) {
                    snprintf(lbuf, llen, "%s[error][%s]", abuf, array_index);
                } else {
                    snprintf(lbuf, llen, "%s[error]", param);
                }
                register_http_post_files_variable_ex(lbuf, &error_type, http_post_files, 0 TSRMLS_CC);

                /* Add $foo_size */
                if (is_arr_upload) {
                    snprintf(lbuf, llen, "%s_size[%s]", abuf, array_index);
                } else {
                    snprintf(lbuf, llen, "%s_size", param);
                }
                if (!is_anonymous) {
                    safe_php_register_variable_ex(lbuf, &file_size, NULL, 0 TSRMLS_CC);
                }

                /* Add $foo[size] */
                if (is_arr_upload) {
                    snprintf(lbuf, llen, "%s[size][%s]", abuf, array_index);
                } else {
                    snprintf(lbuf, llen, "%s[size]", param);
                }
                register_http_post_files_variable_ex(lbuf, &file_size, http_post_files, 0 TSRMLS_CC);
            }
            efree(param);
        }
    }
fileupload_done:
    if (php_rfc1867_callback != NULL) {
        multipart_event_end event_end;

        event_end.post_bytes_processed = SG(read_post_bytes);
        php_rfc1867_callback(MULTIPART_EVENT_END, &event_end, &event_extra_data TSRMLS_CC);
    }

    SAFE_RETURN;
}

// main/rfc1867.h

/*
  +----------------------------------------------------------------------+
  | PHP Version 5                                                        |
  +----------------------------------------------------------------------+
  | Copyright (c) 1997-2009 The PHP Group                                |
  +----------------------------------------------------------------------+
  | This source file is subject to version 3.01 of the PHP license,      |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | http://www.php.net/license/3_01.txt                                  |
  | If you did not receive a copy of the PHP license and are unable to   |
  | obtain it through the world-wide-web, please send a note to          |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
  | Author:                                                              |
  +----------------------------------------------------------------------+
*/

/* $Id: rfc1867.h,v 1.13.2.1.2.5 2008/12/31 11:17:48 sebastian Exp $ */

#ifndef RFC1867_H
#define RFC1867_H

#include "SAPI.h"

#define MULTIPART_CONTENT_TYPE "multipart/form-data"
#define MULTIPART_EVENT_START           0
#define MULTIPART_EVENT_FORMDATA        1
#define MULTIPART_EVENT_FILE_START      2
#define MULTIPART_EVENT_FILE_DATA       3
#define MULTIPART_EVENT_FILE_END        4
#define MULTIPART_EVENT_END             5

typedef struct _multipart_event_start {
        size_t  content_length;
} multipart_event_start;

typedef struct _multipart_event_formdata {
        size_t  post_bytes_processed;
        char    *name;
        char    **value;
        size_t  length;
        size_t  *newlength;
} multipart_event_formdata;

typedef struct _multipart_event_file_start {
        size_t  post_bytes_processed;
        char    *name;
        char    **filename;
} multipart_event_file_start;

typedef struct _multipart_event_file_data {
        size_t  post_bytes_processed;
        off_t   offset;
        char    *data;
        size_t  length;
        size_t  *newlength;
} multipart_event_file_data;

typedef struct _multipart_event_file_end {
        size_t  post_bytes_processed;
        char    *temp_filename;
        int     cancel_upload;
} multipart_event_file_end;

typedef struct _multipart_event_end {
        size_t  post_bytes_processed;
} multipart_event_end;

SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler);

void destroy_uploaded_files_hash(TSRMLS_D);
void php_rfc1867_register_constants(TSRMLS_D);
extern PHPAPI int (*php_rfc1867_callback)(unsigned int event, void *event_data, void **extra TSRMLS_DC);

#endif /* RFC1867_H */

// main/rfc1867.o
[^_]
[^_]
t)<[t%
< tz<
tr<     tn
[^_]
[^_]
[^_]
[^_]
[^_]
[^_]
t':E
tj<'tfF
[^_]
GF;u
[^_]
t,;u
 t      G
[^_]
tkG
[^_]
[^_]
[^_]
 t      F
t <[
[^_]
2147483648
UPLOAD_ERR_OK
UPLOAD_ERR_INI_SIZE
UPLOAD_ERR_FORM_SIZE
UPLOAD_ERR_PARTIAL
UPLOAD_ERR_NO_FILE
UPLOAD_ERR_NO_TMP_DIR
UPLOAD_ERR_CANT_WRITE
UPLOAD_ERR_EXTENSION
--%s
--%s
boundary
Content-Disposition
name
filename
MAX_FILE_SIZE
%s_name[%s]
%s[name][%s]
%s_type[%s]
%s[type][%s]
%s[tmp_name][%s]
%s[error][%s]
%s_size[%s]
%s[size][%s]
%s[size]
%s_size
%s[error]
%s[tmp_name]
%s[type]
%s_type
Content-Type
%s[name]
%s_name
File upload error - unable to create a temporary file
File Upload Mime headers garbled
Unable to initialize the input buffer
Invalid boundary in multipart/form-data POST data
Missing boundary in multipart/form-data POST data
POST Content-Length of %ld bytes exceeds the limit of %ld bytes

Tags

Comments Welcome

Information is freedom. Freedom is non-negotiable. So please feel free to modify, copy, republish, sell, or use anything on this site in any way at any time ;)

My Online Tools

Popular Articles
Hacking and Hackers

The use of "hacker" to mean "security breaker" is a confusion on the part of the mass media. We hackers refuse to recognize that meaning, and continue using the word to mean someone who loves to program, someone who enjoys playful cleverness, or the combination of the two.
-- Richard M. Stallman


It's very simple - you read the protocol and write the code. -Bill Joy

>

Except where otherwise noted, content on this site is licensed under a Creative Commons Attribution 3.0 License, just credit with a link.
This site is not supported or endorsed by The Apache Software Foundation (ASF). All software and documentation produced by The ASF is licensed. "Apache" is a trademark of The ASF. NCSA HTTPd.
UNIX ® is a registered Trademark of The Open Group. POSIX ® is a registered Trademark of The IEEE.

+Askapache | htaccess.io | htaccess.guru

Site Map | Contact Webmaster | License and Disclaimer | Terms of Service | @Htaccess

↑ TOPMain