Annotation of parser3/src/types/pa_vform.C, revision 1.74.2.1
1.27 paf 1: /** @file
2: Parser: @b form class.
1.10 paf 3:
1.74 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.1! paf 10: static const char* IDENT_VFORM_C="$Date: 2003/01/21 15:51:19 $";
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.18 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.66 paf 40: static const char *searchAttribute(const char *data,
1.62 paf 41: const char *attr, //< expected to be lowercased
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.57 paf 61: extern Methoded *form_base_class;
62:
1.74.2.1! paf 63: VForm::VForm(): VStateless_class(0, form_base_class) {}
1.50 paf 64:
1.16 paf 65: char *VForm::strpart(const char *str, size_t len) {
1.7 paf 66: char *result=(char *)malloc(len+1);
1.3 paf 67: if (!result) return NULL;
1.18 paf 68: memcpy(result, str, len);
1.3 paf 69: result[len]=0;
70: return result;
71: }
72:
1.66 paf 73: char *VForm::getAttributeValue(const char *data, char *attr, size_t len) {
74: const char *value=searchAttribute(data, attr, len);
1.3 paf 75: if (value){
1.18 paf 76: size_t i;
77: if (!(len-=value-data)) return NULL;
78: if (*value=='"') {
79: for (i=1;i<len;i++) if (value[i]=='"') break;
80: return strpart(&value[1], i-1);
81: } else {
82: for (i=0;i<len;i++) if (strchr(" ;\"\n\r", value[i])) break;
83: return strpart(value, i);
84: }
1.3 paf 85: }
86: return NULL;
87: }
88:
1.49 paf 89: void VForm::transcode(
90: const void *client_body, size_t client_content_length,
91: const void *& source_body, size_t& source_content_length) {
1.50 paf 92: Charset::transcode(pool(),
93: pool().get_client_charset(), client_body, client_content_length,
94: pool().get_source_charset(), source_body, source_content_length);
1.49 paf 95: }
96:
1.66 paf 97: void VForm::ParseGetFormInput(const char *query_string, size_t length) {
1.42 parser 98: ParseFormInput(query_string, length);
1.3 paf 99: }
100:
1.69 paf 101:
102: static int atoi(const char *data, size_t alength) {
103: char buf[MAX_STRING];
104: size_t length=min((int)alength, MAX_STRING-1);
105: strncpy(buf, data, length);
106: return atoi(buf);
107: }
1.66 paf 108: void VForm::ParseFormInput(const char *data, size_t length) {
1.68 paf 109: // cut out ?image_map_tail
110: {
1.67 paf 111: for(size_t pos=0; pos<length; pos++) {
112: if(data[pos]=='?') {
1.69 paf 113: size_t start=pos+1;
114: size_t aftercomma=start;
115: size_t lookingcomma=start;
116: for(; lookingcomma<length; lookingcomma++) {
117: if(data[lookingcomma]==',') {
118: aftercomma=++lookingcomma;
119: break;
120: }
121: }
122:
123: if(aftercomma>start) { // ?x,y
124: int x=atoi(data+start, aftercomma-1-start);
125: int y=atoi(data+aftercomma, length-aftercomma);
126: imap.put(*NEW String(pool(), "x"), NEW VInt(pool(), x));
127: imap.put(*NEW String(pool(), "y"), NEW VInt(pool(), y));
128: } else { // ?qtail
129: AppendFormEntry("qtail", data+start, length-start);
130: }
1.67 paf 131: // cut tail
132: length=pos;
133: break;
134: }
135: }
136: }
1.68 paf 137: // Scan for pairs, unescaping and storing them as they are found
138: for(size_t pos=0; pos<length; ) {
1.16 paf 139: size_t start=pos;
1.68 paf 140: size_t finish=length;
141: for(; pos<length; pos++) {
142: if(data[pos]=='&') {
143: finish=pos++;
1.3 paf 144: break;
145: }
146: }
1.68 paf 147:
148: size_t aftereq=start;
149: size_t lookingeq=start;
150: for(; lookingeq<finish; lookingeq++) {
151: if(data[lookingeq]=='=') {
152: aftereq=++lookingeq;
1.3 paf 153: break;
154: }
155: }
1.45 paf 156:
1.68 paf 157: const char *attr=aftereq>start?unescape_chars(pool(), data+start, aftereq-1-start):"nameless";
158: char *value=unescape_chars(pool(), data+aftereq, finish-aftereq);
159: AppendFormEntry(attr, value, strlen(value));
1.3 paf 160: }
161: }
162:
1.62 paf 163: static char *pa_tolower(char *s) {
164: for(char *p=s; *p; p++)
165: *p=tolower(*p);
166: return s;
167: }
1.49 paf 168: void VForm::ParseMimeInput(
169: char *content_type,
1.66 paf 170: const char *data, size_t length) {
1.3 paf 171: /* Scan for mime-presented pairs, storing them as they are found. */
172: const char
1.62 paf 173: *boundary=pa_tolower(getAttributeValue(content_type, "boundary=", strlen(content_type))),
1.3 paf 174: *lastData=&data[length];
175: if(!boundary)
1.54 paf 176: throw Exception(0,
1.18 paf 177: 0,
1.3 paf 178: "VForm::ParseMimeInput no boundary attribute of Content-Type");
179:
180: while(true) {
1.66 paf 181: const char
1.18 paf 182: *dataStart=searchAttribute(data, boundary, lastData-data),
183: *dataEnd=searchAttribute(dataStart, boundary, lastData-dataStart);
184: size_t headerSize=getHeader(dataStart, lastData-dataStart);
1.3 paf 185:
186: if(!dataStart|!dataEnd|!headerSize) break;
1.47 paf 187: if(searchAttribute(dataStart, "content-disposition: form-data", headerSize)) {
1.16 paf 188: size_t valueSize=(dataEnd-dataStart)-headerSize-5-strlen(boundary);
1.18 paf 189: char *attr=getAttributeValue(dataStart, " name=", headerSize),
190: *fName=getAttributeValue(dataStart, " filename=", headerSize);
1.3 paf 191:
1.48 paf 192: if(attr && valueSize) {
1.3 paf 193: /* OK, we have a new pair, add it to the list. */
194: AppendFormEntry(attr, &dataStart[headerSize+1], valueSize, fName);
195: }
196: }
197: data=(dataEnd-strlen(boundary));
198: }
199: }
200:
1.49 paf 201: void VForm::AppendFormEntry(
202: const char *cname_cstr,
1.66 paf 203: const char *raw_cvalue_ptr, const size_t raw_cvalue_size,
1.3 paf 204: const char *file_name) {
1.49 paf 205: const void *sname_ptr;
206: size_t sname_size;
207: transcode(
208: cname_cstr, strlen(cname_cstr),
209: sname_ptr, sname_size);
210: String& sname=*NEW String(pool(), (const char *)sname_ptr, sname_size);
1.3 paf 211:
212: Value *value;
1.17 paf 213: if(file_name) {
214: VFile *vfile=NEW VFile(pool());
1.61 paf 215: // maybe transcode text/* files?
1.66 paf 216: vfile->set(true/*tainted*/, raw_cvalue_ptr, raw_cvalue_size, file_name);
1.17 paf 217: value=vfile;
218: } else {
1.73 paf 219: const char *premature_zero_pos=(const char *)memchr(raw_cvalue_ptr, 0, raw_cvalue_size);
220: size_t cvalue_size=premature_zero_pos?premature_zero_pos-(const char *)raw_cvalue_ptr
221: :raw_cvalue_size;
222: char *cvalue_ptr=(char *)copy(raw_cvalue_ptr, cvalue_size);
1.49 paf 223: fix_line_breaks(cvalue_ptr, cvalue_size);
224:
225: const void *svalue_ptr; size_t svalue_size;
226: transcode(
227: cvalue_ptr, cvalue_size, // client [from]
228: svalue_ptr, svalue_size); // source [to]
1.47 paf 229:
1.3 paf 230: String& string=*NEW String(pool());
1.49 paf 231: string.APPEND_TAINTED((const char*)svalue_ptr, svalue_size, "form", 0);
1.36 parser 232:
233: // tables
234: {
235: Value *valready=(Value *)tables.get(sname);
236: bool existed=valready!=0;
237: Table *table;
238: if(existed) {
239: // second+ appearence
240: table=valready->get_table();
241: } else {
242: // first appearence
1.30 parser 243: Array& columns=*NEW Array(pool(), 1);
1.36 parser 244: columns+=NEW String(pool(), "field");
1.30 parser 245: table=NEW Table(pool(), 0, &columns);
246: }
247: // this string becomes next row
248: Array& row=*NEW Array(pool(), 1);
249: row+=&string;
250: *table+=&row;
1.36 parser 251: // not existed before? add it
252: if(!existed)
253: tables.put(sname, NEW VTable(pool(), table));
254: }
255: value=NEW VString(string);
1.3 paf 256: }
1.69 paf 257:
258: fields.put_dont_replace(sname, value);
259: }
260:
1.74.2.1! paf 261: void VForm::fill_fields_and_tables(Request_charsets& charsets, Request::Info& info) {
1.3 paf 262: // parsing QS [GET and ?name=value from uri rewrite)]
1.42 parser 263: if(request.info.query_string) {
264: size_t length=strlen(request.info.query_string);
265: char *buf=(char *)malloc(length);
266: memcpy(buf, request.info.query_string, length);
267: ParseGetFormInput(buf, length);
268: }
1.62 paf 269:
270: #ifdef DEBUG_POST
271: request.info.method="POST";
272: void *data;
273: file_read(pool(), *NEW String(pool(), "opera.stdin"), //"ie.stdin"), //
274: data, request.post_size,
275: false/*as_text*/);
276: request.post_data=(char*)data;
277: request.info.content_type="multipart/form-data; boundary=----------mcqY2UDNcdEAoN1mLmne2i";
278: //request.info.content_type="multipart/form-data; boundary=---------------------------7d23111f44403a4";
279:
280: #endif
1.57 paf 281:
282: // parsing POST data
1.4 paf 283: if(request.info.method) {
1.3 paf 284: if(const char *content_type=request.info.content_type)
1.18 paf 285: if(StrEqNc(request.info.method, "post", true)) {
286: if(StrEqNc(content_type, "application/x-www-form-urlencoded", true))
1.21 paf 287: ParseFormInput(request.post_data, request.post_size);
1.42 parser 288: else if(StrEqNc(content_type, "multipart/form-data", 0)) {
289: size_t length=strlen(content_type)+1;
290: char *buf=(char *)malloc(length);
291: memcpy(buf, content_type, length);
292: ParseMimeInput(buf, request.post_data, request.post_size);
293: }
1.3 paf 294: }
1.57 paf 295: }
1.56 paf 296:
297: filled=true;
1.1 paf 298: }
1.33 parser 299:
1.71 paf 300: Value *VForm::get_element(const String& aname, Value& aself, bool looking_up) {
1.56 paf 301: if(!filled)
302: throw Exception("parser.runtime",
303: &aname,
304: "not determined yet");
305:
1.36 parser 306: // $fields
307: if(aname==FORM_FIELDS_ELEMENT_NAME)
308: return NEW VHash(pool(), Hash(fields));
309:
310: // $tables
311: if(aname==FORM_TABLES_ELEMENT_NAME)
312: return NEW VHash(pool(), Hash(tables));
1.69 paf 313:
314: if(aname==FORM_IMAP_ELEMENT_NAME)
315: return NEW VHash(pool(), Hash(imap));
1.36 parser 316:
1.63 paf 317: // $method
1.65 paf 318: if(Value *result=VStateless_class::get_element(aname, aself, looking_up))
1.33 parser 319: return result;
320:
321: // $element
322: return static_cast<Value *>(fields.get(aname));
1.72 paf 323: }
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pa_vform.C CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / types