1: #include "server.h"
2: #include "keyvalue.h"
3: #include "log.h"
4:
5: #include <stdlib.h>
6: #include <string.h>
7: #include <stdio.h>
8:
9: static keyvalue http_versions[] = {
10: { HTTP_VERSION_1_1, "HTTP/1.1" },
11: { HTTP_VERSION_1_0, "HTTP/1.0" },
12: { HTTP_VERSION_UNSET, NULL }
13: };
14:
15: static keyvalue http_methods[] = {
16: { HTTP_METHOD_GET, "GET" },
17: { HTTP_METHOD_HEAD, "HEAD" },
18: { HTTP_METHOD_POST, "POST" },
19: { HTTP_METHOD_PUT, "PUT" },
20: { HTTP_METHOD_DELETE, "DELETE" },
21: { HTTP_METHOD_CONNECT, "CONNECT" },
22: { HTTP_METHOD_OPTIONS, "OPTIONS" },
23: { HTTP_METHOD_TRACE, "TRACE" },
24: { HTTP_METHOD_ACL, "ACL" },
25: { HTTP_METHOD_BASELINE_CONTROL, "BASELINE-CONTROL" },
26: { HTTP_METHOD_BIND, "BIND" },
27: { HTTP_METHOD_CHECKIN, "CHECKIN" },
28: { HTTP_METHOD_CHECKOUT, "CHECKOUT" },
29: { HTTP_METHOD_COPY, "COPY" },
30: { HTTP_METHOD_LABEL, "LABEL" },
31: { HTTP_METHOD_LINK, "LINK" },
32: { HTTP_METHOD_LOCK, "LOCK" },
33: { HTTP_METHOD_MERGE, "MERGE" },
34: { HTTP_METHOD_MKACTIVITY, "MKACTIVITY" },
35: { HTTP_METHOD_MKCALENDAR, "MKCALENDAR" },
36: { HTTP_METHOD_MKCOL, "MKCOL" },
37: { HTTP_METHOD_MKREDIRECTREF, "MKREDIRECTREF" },
38: { HTTP_METHOD_MKWORKSPACE, "MKWORKSPACE" },
39: { HTTP_METHOD_MOVE, "MOVE" },
40: { HTTP_METHOD_ORDERPATCH, "ORDERPATCH" },
41: { HTTP_METHOD_PATCH, "PATCH" },
42: { HTTP_METHOD_PROPFIND, "PROPFIND" },
43: { HTTP_METHOD_PROPPATCH, "PROPPATCH" },
44: { HTTP_METHOD_REBIND, "REBIND" },
45: { HTTP_METHOD_REPORT, "REPORT" },
46: { HTTP_METHOD_SEARCH, "SEARCH" },
47: { HTTP_METHOD_UNBIND, "UNBIND" },
48: { HTTP_METHOD_UNCHECKOUT, "UNCHECKOUT" },
49: { HTTP_METHOD_UNLINK, "UNLINK" },
50: { HTTP_METHOD_UNLOCK, "UNLOCK" },
51: { HTTP_METHOD_UPDATE, "UPDATE" },
52: { HTTP_METHOD_UPDATEREDIRECTREF, "UPDATEREDIRECTREF" },
53: { HTTP_METHOD_VERSION_CONTROL, "VERSION-CONTROL" },
54:
55: { HTTP_METHOD_UNSET, NULL }
56: };
57:
58: static keyvalue http_status[] = {
59: { 100, "Continue" },
60: { 101, "Switching Protocols" },
61: { 102, "Processing" }, /* WebDAV */
62: { 200, "OK" },
63: { 201, "Created" },
64: { 202, "Accepted" },
65: { 203, "Non-Authoritative Information" },
66: { 204, "No Content" },
67: { 205, "Reset Content" },
68: { 206, "Partial Content" },
69: { 207, "Multi-status" }, /* WebDAV */
70: { 300, "Multiple Choices" },
71: { 301, "Moved Permanently" },
72: { 302, "Found" },
73: { 303, "See Other" },
74: { 304, "Not Modified" },
75: { 305, "Use Proxy" },
76: { 306, "(Unused)" },
77: { 307, "Temporary Redirect" },
78: { 400, "Bad Request" },
79: { 401, "Unauthorized" },
80: { 402, "Payment Required" },
81: { 403, "Forbidden" },
82: { 404, "Not Found" },
83: { 405, "Method Not Allowed" },
84: { 406, "Not Acceptable" },
85: { 407, "Proxy Authentication Required" },
86: { 408, "Request Timeout" },
87: { 409, "Conflict" },
88: { 410, "Gone" },
89: { 411, "Length Required" },
90: { 412, "Precondition Failed" },
91: { 413, "Request Entity Too Large" },
92: { 414, "Request-URI Too Long" },
93: { 415, "Unsupported Media Type" },
94: { 416, "Requested Range Not Satisfiable" },
95: { 417, "Expectation Failed" },
96: { 422, "Unprocessable Entity" }, /* WebDAV */
97: { 423, "Locked" }, /* WebDAV */
98: { 424, "Failed Dependency" }, /* WebDAV */
99: { 426, "Upgrade Required" }, /* TLS */
100: { 500, "Internal Server Error" },
101: { 501, "Not Implemented" },
102: { 502, "Bad Gateway" },
103: { 503, "Service Not Available" },
104: { 504, "Gateway Timeout" },
105: { 505, "HTTP Version Not Supported" },
106: { 507, "Insufficient Storage" }, /* WebDAV */
107:
108: { -1, NULL }
109: };
110:
111: static keyvalue http_status_body[] = {
112: { 400, "400.html" },
113: { 401, "401.html" },
114: { 403, "403.html" },
115: { 404, "404.html" },
116: { 411, "411.html" },
117: { 416, "416.html" },
118: { 500, "500.html" },
119: { 501, "501.html" },
120: { 503, "503.html" },
121: { 505, "505.html" },
122:
123: { -1, NULL }
124: };
125:
126:
127: const char *keyvalue_get_value(keyvalue *kv, int k) {
128: int i;
129: for (i = 0; kv[i].value; i++) {
130: if (kv[i].key == k) return kv[i].value;
131: }
132: return NULL;
133: }
134:
135: int keyvalue_get_key(keyvalue *kv, const char *s) {
136: int i;
137: for (i = 0; kv[i].value; i++) {
138: if (0 == strcmp(kv[i].value, s)) return kv[i].key;
139: }
140: return -1;
141: }
142:
143: keyvalue_buffer *keyvalue_buffer_init(void) {
144: keyvalue_buffer *kvb;
145:
146: kvb = calloc(1, sizeof(*kvb));
147:
148: return kvb;
149: }
150:
151: int keyvalue_buffer_append(keyvalue_buffer *kvb, int key, const char *value) {
152: size_t i;
153: if (kvb->size == 0) {
154: kvb->size = 4;
155:
156: kvb->kv = malloc(kvb->size * sizeof(*kvb->kv));
157:
158: for(i = 0; i < kvb->size; i++) {
159: kvb->kv[i] = calloc(1, sizeof(**kvb->kv));
160: }
161: } else if (kvb->used == kvb->size) {
162: kvb->size += 4;
163:
164: kvb->kv = realloc(kvb->kv, kvb->size * sizeof(*kvb->kv));
165:
166: for(i = kvb->used; i < kvb->size; i++) {
167: kvb->kv[i] = calloc(1, sizeof(**kvb->kv));
168: }
169: }
170:
171: kvb->kv[kvb->used]->key = key;
172: kvb->kv[kvb->used]->value = strdup(value);
173:
174: kvb->used++;
175:
176: return 0;
177: }
178:
179: void keyvalue_buffer_free(keyvalue_buffer *kvb) {
180: size_t i;
181:
182: for (i = 0; i < kvb->size; i++) {
183: if (kvb->kv[i]->value) free(kvb->kv[i]->value);
184: free(kvb->kv[i]);
185: }
186:
187: if (kvb->kv) free(kvb->kv);
188:
189: free(kvb);
190: }
191:
192:
193: s_keyvalue_buffer *s_keyvalue_buffer_init(void) {
194: s_keyvalue_buffer *kvb;
195:
196: kvb = calloc(1, sizeof(*kvb));
197:
198: return kvb;
199: }
200:
201: int s_keyvalue_buffer_append(s_keyvalue_buffer *kvb, const char *key, const char *value) {
202: size_t i;
203: if (kvb->size == 0) {
204: kvb->size = 4;
205: kvb->used = 0;
206:
207: kvb->kv = malloc(kvb->size * sizeof(*kvb->kv));
208:
209: for(i = 0; i < kvb->size; i++) {
210: kvb->kv[i] = calloc(1, sizeof(**kvb->kv));
211: }
212: } else if (kvb->used == kvb->size) {
213: kvb->size += 4;
214:
215: kvb->kv = realloc(kvb->kv, kvb->size * sizeof(*kvb->kv));
216:
217: for(i = kvb->used; i < kvb->size; i++) {
218: kvb->kv[i] = calloc(1, sizeof(**kvb->kv));
219: }
220: }
221:
222: kvb->kv[kvb->used]->key = key ? strdup(key) : NULL;
223: kvb->kv[kvb->used]->value = strdup(value);
224:
225: kvb->used++;
226:
227: return 0;
228: }
229:
230: void s_keyvalue_buffer_free(s_keyvalue_buffer *kvb) {
231: size_t i;
232:
233: for (i = 0; i < kvb->size; i++) {
234: if (kvb->kv[i]->key) free(kvb->kv[i]->key);
235: if (kvb->kv[i]->value) free(kvb->kv[i]->value);
236: free(kvb->kv[i]);
237: }
238:
239: if (kvb->kv) free(kvb->kv);
240:
241: free(kvb);
242: }
243:
244:
245: httpauth_keyvalue_buffer *httpauth_keyvalue_buffer_init(void) {
246: httpauth_keyvalue_buffer *kvb;
247:
248: kvb = calloc(1, sizeof(*kvb));
249:
250: return kvb;
251: }
252:
253: int httpauth_keyvalue_buffer_append(httpauth_keyvalue_buffer *kvb, const char *key, const char *realm, httpauth_type type) {
254: size_t i;
255: if (kvb->size == 0) {
256: kvb->size = 4;
257:
258: kvb->kv = malloc(kvb->size * sizeof(*kvb->kv));
259:
260: for(i = 0; i < kvb->size; i++) {
261: kvb->kv[i] = calloc(1, sizeof(**kvb->kv));
262: }
263: } else if (kvb->used == kvb->size) {
264: kvb->size += 4;
265:
266: kvb->kv = realloc(kvb->kv, kvb->size * sizeof(*kvb->kv));
267:
268: for(i = kvb->used; i < kvb->size; i++) {
269: kvb->kv[i] = calloc(1, sizeof(**kvb->kv));
270: }
271: }
272:
273: kvb->kv[kvb->used]->key = strdup(key);
274: kvb->kv[kvb->used]->realm = strdup(realm);
275: kvb->kv[kvb->used]->type = type;
276:
277: kvb->used++;
278:
279: return 0;
280: }
281:
282: void httpauth_keyvalue_buffer_free(httpauth_keyvalue_buffer *kvb) {
283: size_t i;
284:
285: for (i = 0; i < kvb->size; i++) {
286: if (kvb->kv[i]->key) free(kvb->kv[i]->key);
287: if (kvb->kv[i]->realm) free(kvb->kv[i]->realm);
288: free(kvb->kv[i]);
289: }
290:
291: if (kvb->kv) free(kvb->kv);
292:
293: free(kvb);
294: }
295:
296:
297: const char *get_http_version_name(int i) {
298: return keyvalue_get_value(http_versions, i);
299: }
300:
301: const char *get_http_status_name(int i) {
302: return keyvalue_get_value(http_status, i);
303: }
304:
305: const char *get_http_method_name(http_method_t i) {
306: return keyvalue_get_value(http_methods, i);
307: }
308:
309: const char *get_http_status_body_name(int i) {
310: return keyvalue_get_value(http_status_body, i);
311: }
312:
313: int get_http_version_key(const char *s) {
314: return keyvalue_get_key(http_versions, s);
315: }
316:
317: http_method_t get_http_method_key(const char *s) {
318: return (http_method_t)keyvalue_get_key(http_methods, s);
319: }
320:
321:
322:
323:
324: pcre_keyvalue_buffer *pcre_keyvalue_buffer_init(void) {
325: pcre_keyvalue_buffer *kvb;
326:
327: kvb = calloc(1, sizeof(*kvb));
328:
329: return kvb;
330: }
331:
332: int pcre_keyvalue_buffer_append(server *srv, pcre_keyvalue_buffer *kvb, const char *key, const char *value) {
333: #ifdef HAVE_PCRE_H
334: size_t i;
335: const char *errptr;
336: int erroff;
337: pcre_keyvalue *kv;
338: #endif
339:
340: if (!key) return -1;
341:
342: #ifdef HAVE_PCRE_H
343: if (kvb->size == 0) {
344: kvb->size = 4;
345: kvb->used = 0;
346:
347: kvb->kv = malloc(kvb->size * sizeof(*kvb->kv));
348:
349: for(i = 0; i < kvb->size; i++) {
350: kvb->kv[i] = calloc(1, sizeof(**kvb->kv));
351: }
352: } else if (kvb->used == kvb->size) {
353: kvb->size += 4;
354:
355: kvb->kv = realloc(kvb->kv, kvb->size * sizeof(*kvb->kv));
356:
357: for(i = kvb->used; i < kvb->size; i++) {
358: kvb->kv[i] = calloc(1, sizeof(**kvb->kv));
359: }
360: }
361:
362: kv = kvb->kv[kvb->used];
363: if (NULL == (kv->key = pcre_compile(key,
364: 0, &errptr, &erroff, NULL))) {
365:
366: log_error_write(srv, __FILE__, __LINE__, "SS",
367: "rexexp compilation error at ", errptr);
368: return -1;
369: }
370:
371: if (NULL == (kv->key_extra = pcre_study(kv->key, 0, &errptr)) &&
372: errptr != NULL) {
373: return -1;
374: }
375:
376: kv->value = buffer_init_string(value);
377:
378: kvb->used++;
379:
380: return 0;
381: #else
382: UNUSED(kvb);
383: UNUSED(value);
384:
385: return -1;
386: #endif
387: }
388:
389: void pcre_keyvalue_buffer_free(pcre_keyvalue_buffer *kvb) {
390: #ifdef HAVE_PCRE_H
391: size_t i;
392: pcre_keyvalue *kv;
393:
394: for (i = 0; i < kvb->size; i++) {
395: kv = kvb->kv[i];
396: if (kv->key) pcre_free(kv->key);
397: if (kv->key_extra) pcre_free(kv->key_extra);
398: if (kv->value) buffer_free(kv->value);
399: free(kv);
400: }
401:
402: if (kvb->kv) free(kvb->kv);
403: #endif
404:
405: free(kvb);
406: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to keyvalue.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src