Annotation of parser3/src/types/pa_vform.C, revision 1.74.2.11.2.5

1.27      paf         1: /**    @file
                      2:        Parser: @b form class.
1.10      paf         3: 
1.74.2.3  paf         4:        Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
1.52      paf         5:        Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.39      parser      6: 
1.38      parser      7:        based on The CGI_C library, by Thomas Boutell.
1.3       paf         8: */
1.59      paf         9: 
1.74.2.11.2.5! (paf       10:: static const char* IDENT_VFORM_C="$Date: 2003/03/21 13:42:33 $";
1.3       paf        11: 
1.14      paf        12: #include "pa_sapi.h"
1.1       paf        13: #include "pa_vform.h"
                     14: #include "pa_vstring.h"
1.3       paf        15: #include "pa_globals.h"
                     16: #include "pa_request.h"
1.9       paf        17: #include "pa_vfile.h"
1.21      paf        18: #include "pa_common.h"
1.30      parser     19: #include "pa_vtable.h"
1.50      paf        20: #include "pa_charset.h"
1.3       paf        21: 
1.62      paf        22: // defines
                     23: 
                     24: //#define DEBUG_POST
                     25: 
1.3       paf        26: // parse helper funcs
                     27: 
1.74.2.3  paf        28: static size_t getHeader(const char* data, size_t len){
1.25      paf        29:     size_t i;
                     30:     int enter=-1;
1.3       paf        31:     if (data)
1.62      paf        32:                for (i=0;i<len;i++)
                     33:                        if (data[i]=='\n'){
                     34:                                if (enter>=0) enter++;
                     35:                                if (enter>1) return i;
                     36:                        } else if (data[i]!='\r') enter=0;
                     37:                return 0;
1.3       paf        38: }
                     39: 
1.74.2.3  paf        40: static const char* searchAttribute(const char* data, 
                     41:                                                         const char* attr,  //< expected to be lowercased
1.62      paf        42:                                                         size_t len){
1.16      paf        43:     size_t i;
1.3       paf        44:     if (data)
1.62      paf        45:                for (i=0;i<len;i++)
                     46:                        if (tolower(data[i])==*attr){
                     47:                                size_t j;
                     48:                                for (j=i+1;j<=len;j++)
                     49:                                        if (!attr[j-i]) return &data[j];
                     50:                                        else {
                     51:                                                if (j==len) break;
                     52:                                                if (attr[j-i]!=tolower(data[j])) break;
                     53:                                        }
                     54:                        }
                     55: 
                     56:        return NULL;
1.3       paf        57: }
                     58: 
                     59: // VForm
                     60: 
1.74.2.11.2.4  (paf       61:: extern Methoded* form_base_class;
1.57      paf        62: 
1.74.2.11.2.5! (paf       63:: VForm::VForm(): VStateless_class(0, form_base_class),
1.74.2.8  paf        64:        fcharsets(0),
                     65:        filled(false) {
                     66: }
1.50      paf        67: 
1.74.2.3  paf        68: char *VForm::strpart(const char* str, size_t len) {
1.74.2.11.2.5! (paf       69::     char *result=new(PointerFreeGC) char[len+1];
1.18      paf        70:     memcpy(result, str, len);
1.3       paf        71:     result[len]=0;
                     72:     return result;
                     73: }
                     74: 
1.74.2.3  paf        75: char *VForm::getAttributeValue(const char* data, char *attr, size_t len) {
                     76:     const char* value=searchAttribute(data, attr, len);
1.3       paf        77:     if (value){
1.18      paf        78:                size_t i;
                     79:                if (!(len-=value-data)) return NULL;
                     80:                if (*value=='"') {
                     81:                        for (i=1;i<len;i++)     if (value[i]=='"') break;
                     82:                        return strpart(&value[1], i-1);
                     83:                } else {
                     84:                        for (i=0;i<len;i++)     if (strchr(" ;\"\n\r", value[i])) break;
                     85:                        return strpart(value, i);
                     86:                }
1.3       paf        87:     }
                     88:     return NULL;
                     89: }
                     90: 
1.49      paf        91: void VForm::transcode(
                     92:        const void *client_body, size_t client_content_length,
                     93:        const void *& source_body, size_t& source_content_length) {
1.74.2.11.2.5! (paf       94::       Charset::transcode(
1.74.2.4  paf        95:                fcharsets->client(), client_body, client_content_length,
                     96:                fcharsets->source(), source_body, source_content_length);
1.49      paf        97: }
                     98: 
1.74.2.3  paf        99: void VForm::ParseGetFormInput(const char* query_string, size_t length) {
1.42      parser    100:        ParseFormInput(query_string, length);
1.3       paf       101: }
                    102: 
1.69      paf       103: 
1.74.2.3  paf       104: static int atoi(const char* data, size_t alength) {
1.69      paf       105:        char buf[MAX_STRING];
                    106:        size_t length=min((int)alength, MAX_STRING-1);
                    107:        strncpy(buf, data, length);
                    108:        return atoi(buf);
                    109: }
1.74.2.3  paf       110: void VForm::ParseFormInput(const char* data, size_t length) {
1.68      paf       111:        // cut out ?image_map_tail
                    112:        {
1.67      paf       113:                for(size_t pos=0; pos<length; pos++) {
                    114:                        if(data[pos]=='?') {
1.69      paf       115:                                size_t start=pos+1;
                    116:                                size_t aftercomma=start;
                    117:                                size_t lookingcomma=start;
                    118:                                for(; lookingcomma<length; lookingcomma++) {
                    119:                                        if(data[lookingcomma]==',') {
                    120:                                                aftercomma=++lookingcomma;
                    121:                                                break;
                    122:                                        }
                    123:                                }                               
                    124:                                
                    125:                                if(aftercomma>start) { // ?x,y
                    126:                                        int x=atoi(data+start, aftercomma-1-start);
                    127:                                        int y=atoi(data+aftercomma, length-aftercomma);
1.74.2.11.2.5! (paf      128::                                       imap.put(String("x"), new VInt(x));
        !           129::                                       imap.put(String("y"), new VInt(y));
1.69      paf       130:                                } else { // ?qtail
                    131:                                        AppendFormEntry("qtail", data+start, length-start);
                    132:                                }
1.67      paf       133:                                // cut tail
                    134:                                length=pos;
                    135:                                break;
                    136:                        }
                    137:                }
                    138:        }
1.68      paf       139:        // Scan for pairs, unescaping and storing them as they are found
                    140:        for(size_t pos=0; pos<length; ) {
1.16      paf       141:                size_t start=pos;
1.68      paf       142:                size_t finish=length;
                    143:                for(; pos<length; pos++) {
                    144:                        if(data[pos]=='&') {
                    145:                                finish=pos++;
1.3       paf       146:                                break;
                    147:                        }
                    148:                }
1.68      paf       149: 
                    150:                size_t aftereq=start;
                    151:                size_t lookingeq=start;
                    152:                for(; lookingeq<finish; lookingeq++) {
                    153:                        if(data[lookingeq]=='=') {
                    154:                                aftereq=++lookingeq;
1.3       paf       155:                                break;
                    156:                        }
                    157:                }
1.45      paf       158: 
1.74.2.11.2.5! (paf      159::               const char* attr=aftereq>start?unescape_chars(data+start, aftereq-1-start):"nameless";
        !           160::               char *value=unescape_chars(data+aftereq, finish-aftereq);
1.68      paf       161:                AppendFormEntry(attr, value, strlen(value));
1.3       paf       162:        }
                    163: }
                    164: 
1.62      paf       165: static char *pa_tolower(char *s) {
                    166:        for(char *p=s; *p; p++)
                    167:                *p=tolower(*p);
                    168:        return s;
                    169: }
1.49      paf       170: void VForm::ParseMimeInput(
                    171:                                                   char *content_type, 
1.74.2.3  paf       172:                                                   const char* data, size_t length) {
1.3       paf       173: /* Scan for mime-presented pairs, storing them as they are found. */
                    174:        const char 
1.62      paf       175:                *boundary=pa_tolower(getAttributeValue(content_type, "boundary=", strlen(content_type))), 
1.3       paf       176:            *lastData=&data[length];
                    177:        if(!boundary) 
1.74.2.11.2.2  (paf      178::               throw Exception(0, 
                    179::                       0, 
1.3       paf       180:                        "VForm::ParseMimeInput no boundary attribute of Content-Type");
                    181: 
                    182:        while(true) {
1.66      paf       183:                const char 
1.18      paf       184:                        *dataStart=searchAttribute(data, boundary, lastData-data), 
                    185:                        *dataEnd=searchAttribute(dataStart, boundary, lastData-dataStart);
                    186:                size_t headerSize=getHeader(dataStart, lastData-dataStart);
1.3       paf       187: 
                    188:                if(!dataStart|!dataEnd|!headerSize) break;
1.47      paf       189:                if(searchAttribute(dataStart, "content-disposition: form-data", headerSize)) {
1.16      paf       190:                        size_t valueSize=(dataEnd-dataStart)-headerSize-5-strlen(boundary);
1.18      paf       191:                        char *attr=getAttributeValue(dataStart, " name=", headerSize), 
                    192:                             *fName=getAttributeValue(dataStart, " filename=", headerSize);
1.3       paf       193: 
1.48      paf       194:                        if(attr && valueSize) {
1.3       paf       195:                                /* OK, we have a new pair, add it to the list. */
                    196:                                AppendFormEntry(attr, &dataStart[headerSize+1], valueSize, fName);
                    197:                        }
                    198:                }
                    199:                data=(dataEnd-strlen(boundary));
                    200:        }
                    201: }
                    202: 
1.49      paf       203: void VForm::AppendFormEntry(
1.74.2.11.2.5! (paf      204::                           const char* cname_cstr, 
        !           205::                           const char* raw_cvalue_ptr, const size_t raw_cvalue_size, 
        !           206::                           const char* copy_me_file_name_cstr) {
1.49      paf       207:        const void *sname_ptr;
                    208:        size_t sname_size;
                    209:        transcode(
                    210:                cname_cstr, strlen(cname_cstr),
                    211:                sname_ptr, sname_size);
1.74.2.11.2.5! (paf      212::       const String& sname=*new String((const char* )sname_ptr, sname_size);
1.3       paf       213: 
1.74.2.11.2.4  (paf      214::       Value* value;
1.74.2.4  paf       215:        if(copy_me_file_name_cstr) {
1.74.2.11.2.5! (paf      216::               VFile* vfile=new VFile;
1.61      paf       217:                // maybe transcode text/* files?
1.74.2.11.2.5! (paf      218::               const String& sfile_name=*new String(strdup(copy_me_file_name_cstr));
        !           219::               vfile->set(true/*tainted*/, raw_cvalue_ptr, raw_cvalue_size, sfile_name.cstr());
1.17      paf       220:                value=vfile;
                    221:        } else {
1.74.2.3  paf       222:                const char* premature_zero_pos=(const char* )memchr(raw_cvalue_ptr, 0, raw_cvalue_size);
                    223:                size_t cvalue_size=premature_zero_pos?premature_zero_pos-(const char* )raw_cvalue_ptr
1.73      paf       224:                        :raw_cvalue_size;
1.74.2.11.2.5! (paf      225::               char *cvalue_ptr=strdup(raw_cvalue_ptr, cvalue_size); 
1.49      paf       226:                fix_line_breaks(cvalue_ptr, cvalue_size);
                    227: 
                    228:                const void *svalue_ptr; size_t svalue_size;
                    229:                transcode(
                    230:                        cvalue_ptr, cvalue_size, // client [from]
                    231:                        svalue_ptr, svalue_size); // source [to]
1.47      paf       232:                
1.74.2.11.2.5! (paf      233::               String& string=*new String((const char*)svalue_ptr, svalue_size, true);
1.36      parser    234: 
                    235:                // tables
                    236:                {
1.74.2.11.2.4  (paf      237::                       Value* vtable=tables.get(sname);
1.74.2.4  paf       238:                        if(!vtable) {
1.36      parser    239:                                // first appearence
1.74.2.11.2.5! (paf      240::                               Table::columns_type columns(new ArrayString(1));
        !           241::                               *columns+=new String("field");
1.74.2.4  paf       242: 
1.74.2.11.2.5! (paf      243::                               vtable=new VTable(new Table(columns));
1.74.2.4  paf       244:                                tables.put(sname, vtable);
1.30      parser    245:                        }
1.74.2.4  paf       246:                        Table& table=*vtable->get_table();
                    247: 
1.30      parser    248:                        // this string becomes next row
1.74.2.6  paf       249:                        Table::element_type row(new ArrayString(1));
1.74.2.11.2.5! (paf      250::                       *row+=&string;
1.74.2.4  paf       251:                        table+=row;
1.36      parser    252:                }
1.74.2.11.2.5! (paf      253::               value=new VString(string);
1.3       paf       254:        }
1.69      paf       255: 
                    256:        fields.put_dont_replace(sname, value);
                    257: }
                    258: 
1.74.2.11.2.1  (paf      259:: void VForm::fill_fields_and_tables(Request_charsets& acharsets, 
1.74.2.11.2.5! (paf      260::                                  Request_info& request_info) {
        !           261::       fcharsets=&acharsets;
1.74.2.4  paf       262:        try{
                    263: 
1.74.2.10  paf       264:        //request_info.query_string="a=123";
1.3       paf       265:        // parsing QS [GET and ?name=value from uri rewrite)]
1.74.2.4  paf       266:        if(request_info.query_string) {
                    267:                size_t length=strlen(request_info.query_string);
1.74.2.11.2.5! (paf      268::               char *buf=strdup(request_info.query_string, length);
1.42      parser    269:                ParseGetFormInput(buf, length);
                    270:        }
1.62      paf       271: 
                    272: #ifdef DEBUG_POST
1.74.2.4  paf       273:        request_info.method="POST";
1.62      paf       274:        void *data;
1.74.2.11.2.4  (paf      275::       file_read(*NEW String("opera.stdin"),  //"ie.stdin"), //
1.62      paf       276:                           data, request.post_size, 
                    277:                           false/*as_text*/);   
                    278:        request.post_data=(char*)data;
1.74.2.4  paf       279:        request_info.content_type="multipart/form-data; boundary=----------mcqY2UDNcdEAoN1mLmne2i";
                    280:        //request_info.content_type="multipart/form-data; boundary=---------------------------7d23111f44403a4";
1.62      paf       281: 
                    282: #endif
1.57      paf       283: 
                    284:        // parsing POST data
1.74.2.4  paf       285:        if(request_info.method) {
                    286:                if(const char* content_type=request_info.content_type)
                    287:                        if(StrEqNc(request_info.method, "post", true)) {
1.18      paf       288:                                if(StrEqNc(content_type, "application/x-www-form-urlencoded", true)) 
1.74.2.4  paf       289:                                        ParseFormInput(request_info.post_data, request_info.post_size);
1.74.2.9  paf       290:                                else if(StrEqNc(content_type, "multipart/form-data", 0))
1.74.2.11.2.5! (paf      291::                                       ParseMimeInput(strdup(content_type), 
1.74.2.9  paf       292:                                                request_info.post_data, request_info.post_size);
1.3       paf       293:                        }
1.57      paf       294:        }
1.56      paf       295: 
                    296:        filled=true;
1.74.2.4  paf       297:        
1.74.2.11.2.5! (paf      298::       fcharsets=0;
        !           299::       } catch(...) { fcharsets=0; rethrow; }
1.1       paf       300: }
1.33      parser    301: 
1.74.2.11.2.4  (paf      302:: Value* VForm::get_element(const String& aname, Value& aself, bool looking_up) {
1.56      paf       303:        if(!filled)
                    304:                throw Exception("parser.runtime",
1.74.2.11.2.5! (paf      305::                       &aname,
1.56      paf       306:                        "not determined yet");
                    307: 
1.36      parser    308:        // $fields
1.74.2.11.2.4  (paf      309::       if(aname==FORM_FIELDS_ELEMENT_NAME)
1.74.2.11.2.5! (paf      310::               return new VHash(fields);
1.36      parser    311: 
                    312:        // $tables
1.74.2.11.2.4  (paf      313::       if(aname==FORM_TABLES_ELEMENT_NAME)
1.74.2.11.2.5! (paf      314::               return new VHash(tables);
1.69      paf       315: 
1.74.2.11.2.4  (paf      316::       if(aname==FORM_IMAP_ELEMENT_NAME)
1.74.2.11.2.5! (paf      317::               return new VHash(imap);
1.36      parser    318: 
1.63      paf       319:        // $method
1.74.2.11.2.4  (paf      320::       if(Value* result=VStateless_class::get_element(aname, aself, looking_up))
1.33      parser    321:                return result;
                    322: 
                    323:        // $element
1.74.2.4  paf       324:        return fields.get(aname);
1.72      paf       325: }

E-mail: