Annotation of parser3/src/types/pa_vform.C, revision 1.58
1.27 paf 1: /** @file
2: Parser: @b form class.
1.10 paf 3:
1.53 paf 4: Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
1.52 paf 5: Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.38 parser 6:
1.58 ! paf 7: $Id: pa_vform.C,v 1.57 2002/06/24 11:59:34 paf Exp $
1.39 parser 8:
1.38 parser 9: based on The CGI_C library, by Thomas Boutell.
1.3 paf 10: */
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:
22: // parse helper funcs
23:
1.18 paf 24: static size_t getHeader(const char *data, size_t len){
1.25 paf 25: size_t i;
26: int enter=-1;
1.3 paf 27: if (data)
28: for (i=0;i<len;i++)
29: if (data[i]=='\n'){
30: if (enter>=0) enter++;
31: if (enter>1) return i;
32: } else if (data[i]!='\r') enter=0;
33: return 0;
34: }
35:
1.42 parser 36: static char *searchAttribute(char *data, const char *attr, size_t len){
1.16 paf 37: size_t i;
1.3 paf 38: if (data)
39: for (i=0;i<len;i++)
40: if (tolower(data[i])==*attr){
1.16 paf 41: size_t j;
1.3 paf 42: for (j=i+1;j<=len;j++)
43: if (!attr[j-i]) return &data[j];
44: else {
45: if (j==len) break;
46: if (attr[j-i]!=tolower(data[j])) break;
47: }
48: }
49: return NULL;
50: }
51:
52: // VForm
53:
1.57 paf 54: extern Methoded *form_base_class;
55:
1.55 paf 56: VForm::VForm(Pool& apool) : VStateless_class(apool, 0, form_base_class),
1.50 paf 57: fields(apool),
1.56 paf 58: tables(apool),
59: filled(false) {
1.50 paf 60: }
61:
1.16 paf 62: char *VForm::strpart(const char *str, size_t len) {
1.7 paf 63: char *result=(char *)malloc(len+1);
1.3 paf 64: if (!result) return NULL;
1.18 paf 65: memcpy(result, str, len);
1.3 paf 66: result[len]=0;
67: return result;
68: }
69:
1.42 parser 70: char *VForm::getAttributeValue(char *data, char *attr, size_t len) {
71: char *value=searchAttribute(data, attr, len);
1.3 paf 72: if (value){
1.18 paf 73: size_t i;
74: if (!(len-=value-data)) return NULL;
75: if (*value=='"') {
76: for (i=1;i<len;i++) if (value[i]=='"') break;
77: return strpart(&value[1], i-1);
78: } else {
79: for (i=0;i<len;i++) if (strchr(" ;\"\n\r", value[i])) break;
80: return strpart(value, i);
81: }
1.3 paf 82: }
83: return NULL;
84: }
85:
1.49 paf 86: void VForm::transcode(
87: const void *client_body, size_t client_content_length,
88: const void *& source_body, size_t& source_content_length) {
1.50 paf 89: Charset::transcode(pool(),
90: pool().get_client_charset(), client_body, client_content_length,
91: pool().get_source_charset(), source_body, source_content_length);
1.49 paf 92: }
93:
1.42 parser 94: void VForm::ParseGetFormInput(char *query_string, size_t length) {
95: ParseFormInput(query_string, length);
1.3 paf 96: }
97:
1.42 parser 98: void VForm::ParseFormInput(char *data, size_t length) {
1.8 paf 99: /* Scan for pairs, unescaping and storing them as they are found. */
1.16 paf 100: size_t pos=0;
1.3 paf 101: while(pos !=length) {
1.16 paf 102: size_t foundEq=0;
103: size_t foundAmp=0;
104: size_t start=pos;
105: size_t len=0;
1.3 paf 106: while(pos !=length) {
107: if(data[pos]=='=') {
108: foundEq=1;
109: pos++;
110: break;
111: }
112: pos++;
113: len++;
114: }
115: if(!foundEq)
116: break;
1.42 parser 117: char *attr=unescape_chars(pool(), data+start, len);
1.3 paf 118: start=pos;
119: len=0;
120: while(pos !=length) {
121: if(data[pos]=='&') {
122: foundAmp=1;
123: pos++;
124: break;
125: }
126: pos++;
127: len++;
128: }
129: /* The last pair probably won't be followed by a &, but
130: that's fine, so check for that after accepting it */
1.42 parser 131: char *value=unescape_chars(pool(), data+start, len);
1.3 paf 132: /* OK, we have a new pair, add it to the list. */
1.45 paf 133: size_t value_size=strlen(value);
134: AppendFormEntry(attr, value, value_size);
135:
1.3 paf 136: if(!foundAmp)
137: break;
138: }
139: }
140:
1.49 paf 141: void VForm::ParseMimeInput(
142: char *content_type,
1.42 parser 143: char *data, size_t length) {
1.3 paf 144: /* Scan for mime-presented pairs, storing them as they are found. */
145: const char
1.18 paf 146: *boundary=getAttributeValue(content_type, "boundary=", strlen(content_type)),
1.3 paf 147: *lastData=&data[length];
148: if(!boundary)
1.54 paf 149: throw Exception(0,
1.18 paf 150: 0,
1.3 paf 151: "VForm::ParseMimeInput no boundary attribute of Content-Type");
152:
153: while(true) {
1.42 parser 154: char
1.18 paf 155: *dataStart=searchAttribute(data, boundary, lastData-data),
156: *dataEnd=searchAttribute(dataStart, boundary, lastData-dataStart);
157: size_t headerSize=getHeader(dataStart, lastData-dataStart);
1.3 paf 158:
159: if(!dataStart|!dataEnd|!headerSize) break;
1.47 paf 160: if(searchAttribute(dataStart, "content-disposition: form-data", headerSize)) {
1.16 paf 161: size_t valueSize=(dataEnd-dataStart)-headerSize-5-strlen(boundary);
1.18 paf 162: char *attr=getAttributeValue(dataStart, " name=", headerSize),
163: *fName=getAttributeValue(dataStart, " filename=", headerSize);
1.3 paf 164:
1.48 paf 165: if(attr && valueSize) {
1.3 paf 166: /* OK, we have a new pair, add it to the list. */
167: AppendFormEntry(attr, &dataStart[headerSize+1], valueSize, fName);
168: }
169: }
170: data=(dataEnd-strlen(boundary));
171: }
172: }
173:
1.49 paf 174: void VForm::AppendFormEntry(
175: const char *cname_cstr,
176: char *cvalue_ptr, size_t cvalue_size,
1.3 paf 177: const char *file_name) {
1.49 paf 178: const void *sname_ptr;
179: size_t sname_size;
180: transcode(
181: cname_cstr, strlen(cname_cstr),
182: sname_ptr, sname_size);
183: String& sname=*NEW String(pool(), (const char *)sname_ptr, sname_size);
1.3 paf 184:
185: Value *value;
1.17 paf 186: if(file_name) {
187: VFile *vfile=NEW VFile(pool());
1.49 paf 188: vfile->set(true/*tainted*/, cvalue_ptr, cvalue_size, file_name);
1.17 paf 189: value=vfile;
190: } else {
1.49 paf 191: fix_line_breaks(cvalue_ptr, cvalue_size);
192:
193: const void *svalue_ptr; size_t svalue_size;
194: transcode(
195: cvalue_ptr, cvalue_size, // client [from]
196: svalue_ptr, svalue_size); // source [to]
1.47 paf 197:
1.3 paf 198: String& string=*NEW String(pool());
1.49 paf 199: string.APPEND_TAINTED((const char*)svalue_ptr, svalue_size, "form", 0);
1.36 parser 200:
201: // tables
202: {
203: Value *valready=(Value *)tables.get(sname);
204: bool existed=valready!=0;
205: Table *table;
206: if(existed) {
207: // second+ appearence
208: table=valready->get_table();
209: } else {
210: // first appearence
1.30 parser 211: Array& columns=*NEW Array(pool(), 1);
1.36 parser 212: columns+=NEW String(pool(), "field");
1.30 parser 213: table=NEW Table(pool(), 0, &columns);
214: }
215: // this string becomes next row
216: Array& row=*NEW Array(pool(), 1);
217: row+=&string;
218: *table+=&row;
1.36 parser 219: // not existed before? add it
220: if(!existed)
221: tables.put(sname, NEW VTable(pool(), table));
222: }
223: value=NEW VString(string);
1.3 paf 224: }
225:
1.32 parser 226: fields.put_dont_replace(sname, value);
1.3 paf 227: }
1.1 paf 228:
1.36 parser 229: void VForm::fill_fields_and_tables(Request& request) {
1.3 paf 230: // parsing QS [GET and ?name=value from uri rewrite)]
1.42 parser 231: if(request.info.query_string) {
232: size_t length=strlen(request.info.query_string);
233: char *buf=(char *)malloc(length);
234: memcpy(buf, request.info.query_string, length);
235: ParseGetFormInput(buf, length);
236: }
1.58 ! paf 237: /*throw Exception("test shit",
! 238: 0,
! 239: "happened");*/
1.57 paf 240:
241: // parsing POST data
1.4 paf 242: if(request.info.method) {
1.3 paf 243: if(const char *content_type=request.info.content_type)
1.18 paf 244: if(StrEqNc(request.info.method, "post", true)) {
245: if(StrEqNc(content_type, "application/x-www-form-urlencoded", true))
1.21 paf 246: ParseFormInput(request.post_data, request.post_size);
1.42 parser 247: else if(StrEqNc(content_type, "multipart/form-data", 0)) {
248: size_t length=strlen(content_type)+1;
249: char *buf=(char *)malloc(length);
250: memcpy(buf, content_type, length);
251: ParseMimeInput(buf, request.post_data, request.post_size);
252: }
1.3 paf 253: }
1.57 paf 254: }
1.56 paf 255:
256: filled=true;
1.1 paf 257: }
1.33 parser 258:
259: Value *VForm::get_element(const String& aname) {
1.56 paf 260: if(!filled)
261: throw Exception("parser.runtime",
262: &aname,
263: "not determined yet");
264:
1.36 parser 265: // $fields
266: if(aname==FORM_FIELDS_ELEMENT_NAME)
267: return NEW VHash(pool(), Hash(fields));
268:
269: // $tables
270: if(aname==FORM_TABLES_ELEMENT_NAME)
271: return NEW VHash(pool(), Hash(tables));
272:
1.33 parser 273: // $CLASS,$method
274: if(Value *result=VStateless_class::get_element(aname))
275: return result;
276:
277: // $element
278: return static_cast<Value *>(fields.get(aname));
1.58 ! paf 279: }
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