set a default for script timeout
[project/uhttpd.git] / utils.c
1 /*
2  * uhttpd - Tiny single-threaded httpd
3  *
4  *   Copyright (C) 2010-2012 Jo-Philipp Wich <xm@subsignal.org>
5  *   Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
6  *
7  *  Licensed under the Apache License, Version 2.0 (the "License");
8  *  you may not use this file except in compliance with the License.
9  *  You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  *  Unless required by applicable law or agreed to in writing, software
14  *  distributed under the License is distributed on an "AS IS" BASIS,
15  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  *  See the License for the specific language governing permissions and
17  *  limitations under the License.
18  */
19
20 #include <ctype.h>
21 #include "uhttpd.h"
22
23 bool uh_use_chunked(struct client *cl)
24 {
25         if (cl->request.version != UH_HTTP_VER_1_1)
26                 return false;
27
28         if (cl->request.method == UH_HTTP_MSG_HEAD)
29                 return false;
30
31         return true;
32 }
33
34 void uh_chunk_write(struct client *cl, const void *data, int len)
35 {
36         bool chunked = uh_use_chunked(cl);
37
38         uloop_timeout_set(&cl->timeout, conf.network_timeout * 1000);
39         if (chunked)
40                 ustream_printf(cl->us, "%X\r\n", len);
41         ustream_write(cl->us, data, len, true);
42         if (chunked)
43                 ustream_printf(cl->us, "\r\n", len);
44 }
45
46 void uh_chunk_vprintf(struct client *cl, const char *format, va_list arg)
47 {
48         char buf[256];
49         va_list arg2;
50         int len;
51
52         uloop_timeout_set(&cl->timeout, conf.network_timeout * 1000);
53         if (!uh_use_chunked(cl)) {
54                 ustream_vprintf(cl->us, format, arg);
55                 return;
56         }
57
58         va_copy(arg2, arg);
59         len = vsnprintf(buf, sizeof(buf), format, arg2);
60         va_end(arg2);
61
62         ustream_printf(cl->us, "%X\r\n", len);
63         if (len < sizeof(buf))
64                 ustream_write(cl->us, buf, len, true);
65         else
66                 ustream_vprintf(cl->us, format, arg);
67         ustream_printf(cl->us, "\r\n", len);
68 }
69
70 void uh_chunk_printf(struct client *cl, const char *format, ...)
71 {
72         va_list arg;
73
74         va_start(arg, format);
75         uh_chunk_vprintf(cl, format, arg);
76         va_end(arg);
77 }
78
79 void uh_chunk_eof(struct client *cl)
80 {
81         if (!uh_use_chunked(cl))
82                 return;
83
84         ustream_printf(cl->us, "0\r\n\r\n");
85 }
86
87 /* blen is the size of buf; slen is the length of src.  The input-string need
88 ** not be, and the output string will not be, null-terminated.  Returns the
89 ** length of the decoded string, -1 on buffer overflow, -2 on malformed string. */
90 int uh_urldecode(char *buf, int blen, const char *src, int slen)
91 {
92         int i;
93         int len = 0;
94
95 #define hex(x) \
96         (((x) <= '9') ? ((x) - '0') : \
97                 (((x) <= 'F') ? ((x) - 'A' + 10) : \
98                         ((x) - 'a' + 10)))
99
100         for (i = 0; (i < slen) && (len < blen); i++)
101         {
102                 if (src[i] != '%') {
103                         buf[len++] = src[i];
104                         continue;
105                 }
106
107                 if (i + 2 >= slen || !isxdigit(src[i + 1]) || !isxdigit(src[i + 2]))
108                         return -2;
109
110                 buf[len++] = (char)(16 * hex(src[i+1]) + hex(src[i+2]));
111                 i += 2;
112         }
113         buf[len] = 0;
114
115         return (i == slen) ? len : -1;
116 }
117
118 /* blen is the size of buf; slen is the length of src.  The input-string need
119 ** not be, and the output string will not be, null-terminated.  Returns the
120 ** length of the encoded string, or -1 on error (buffer overflow) */
121 int uh_urlencode(char *buf, int blen, const char *src, int slen)
122 {
123         int i;
124         int len = 0;
125         const char hex[] = "0123456789abcdef";
126
127         for (i = 0; (i < slen) && (len < blen); i++)
128         {
129                 if( isalnum(src[i]) || (src[i] == '-') || (src[i] == '_') ||
130                     (src[i] == '.') || (src[i] == '~') )
131                 {
132                         buf[len++] = src[i];
133                 }
134                 else if ((len+3) <= blen)
135                 {
136                         buf[len++] = '%';
137                         buf[len++] = hex[(src[i] >> 4) & 15];
138                         buf[len++] = hex[ src[i]       & 15];
139                 }
140                 else
141                 {
142                         len = -1;
143                         break;
144                 }
145         }
146
147         return (i == slen) ? len : -1;
148 }
149
150 int uh_b64decode(char *buf, int blen, const unsigned char *src, int slen)
151 {
152         int i = 0;
153         int len = 0;
154
155         unsigned int cin  = 0;
156         unsigned int cout = 0;
157
158
159         for (i = 0; (i <= slen) && (src[i] != 0); i++)
160         {
161                 cin = src[i];
162
163                 if ((cin >= '0') && (cin <= '9'))
164                         cin = cin - '0' + 52;
165                 else if ((cin >= 'A') && (cin <= 'Z'))
166                         cin = cin - 'A';
167                 else if ((cin >= 'a') && (cin <= 'z'))
168                         cin = cin - 'a' + 26;
169                 else if (cin == '+')
170                         cin = 62;
171                 else if (cin == '/')
172                         cin = 63;
173                 else if (cin == '=')
174                         cin = 0;
175                 else
176                         continue;
177
178                 cout = (cout << 6) | cin;
179
180                 if ((i % 4) == 3)
181                 {
182                         if ((len + 3) < blen)
183                         {
184                                 buf[len++] = (char)(cout >> 16);
185                                 buf[len++] = (char)(cout >> 8);
186                                 buf[len++] = (char)(cout);
187                         }
188                         else
189                         {
190                                 break;
191                         }
192                 }
193         }
194
195         buf[len++] = 0;
196         return len;
197 }