cygwin fixes
[fw/openocd] / src / server / httpd.c
1 /***************************************************************************
2  *   Copyright (C) 2007,2008 Ã˜yvind Harboe                                 *
3  *   oyvind.harboe@zylin.com                                               *
4  *                                                                         *
5  *   Copyright (C) 2008 Free Software Foundation
6  *                                                                         *
7  *   This program is free software; you can redistribute it and/or modify  *
8  *   it under the terms of the GNU General Public License as published by  *
9  *   the Free Software Foundation; either version 2 of the License, or     *
10  *   (at your option) any later version.                                   *
11  *                                                                         *
12  *   This program is distributed in the hope that it will be useful,       *
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
15  *   GNU General Public License for more details.                          *
16  *                                                                         *
17  *   You should have received a copy of the GNU General Public License     *
18  *   along with this program; if not, write to the                         *
19  *   Free Software Foundation, Inc.,                                       *
20  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
21  ***************************************************************************/
22
23 /* some bits were copied from ahttpd which is under eCos license and
24  * copyright to FSF
25  */
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #include "replacements.h"
31
32 #include "server.h"
33
34 #include "log.h"
35 #include "telnet_server.h"
36 #include "target.h"
37
38 #include <command.h>
39 #include <string.h>
40 #include <stdlib.h>
41 #include <errno.h>
42 #include <unistd.h>
43 #include <sys/types.h>
44 #include <fcntl.h>
45 #include <signal.h>
46
47 #include <sys/types.h>
48 #include <sys/select.h>
49 #include <sys/socket.h>
50 #include <microhttpd.h>
51 #include <stdlib.h>
52 #include <string.h>
53 #include <stdio.h>
54
55 #define PAGE_NOT_FOUND "<html><head><title>File not found</title></head><body>File not found</body></html>"
56
57 static const char *appendf(const char *prev, const char *format, ...)
58 {
59         va_list ap;
60         va_start(ap, format);
61         char *string = alloc_vprintf(format, ap);
62         va_end(ap);
63         char *string2 = NULL;
64
65         if (string != NULL)
66         {
67                 string2 = alloc_printf("%s%s", (prev == NULL) ? "" : prev, string);
68         }
69
70         if (prev != NULL)
71         {
72                 free((void *)prev);
73         }
74
75         if (string == NULL)
76                 free(string);
77
78         return string2;
79 }
80
81 static const char *httpd_exec_cgi_tcl_error(Jim_Interp *interp)
82 {
83         int len, i;
84
85         const char *t = NULL;
86         t = appendf(t, "<html><body>\n");
87
88         t = appendf(t, "Runtime error, file \"%s\", line %d:<br>",
89                         interp->errorFileName, interp->errorLine);
90         t = appendf(t, "    %s<br>", Jim_GetString(interp->result, NULL));
91         Jim_ListLength(interp, interp->stackTrace, &len);
92         for (i = 0; i < len; i += 3)
93         {
94                 Jim_Obj *objPtr;
95                 const char *proc, *file, *line;
96
97                 Jim_ListIndex(interp, interp->stackTrace, i, &objPtr, JIM_NONE);
98                 proc = Jim_GetString(objPtr, NULL);
99                 Jim_ListIndex(interp, interp->stackTrace, i + 1, &objPtr, JIM_NONE);
100                 file = Jim_GetString(objPtr, NULL);
101                 Jim_ListIndex(interp, interp->stackTrace, i + 2, &objPtr, JIM_NONE);
102                 line = Jim_GetString(objPtr, NULL);
103                 t = appendf(t, "In procedure '%s' called at file \"%s\", line %s<br>",
104                                 proc, file, line);
105         }
106         t = appendf(t, "</html></body>\n");
107
108         return t;
109 }
110
111 static int httpd_Jim_Command_writeform(Jim_Interp *interp, int argc,
112                 Jim_Obj * const *argv)
113 {
114         if (argc != 3)
115         {
116                 Jim_WrongNumArgs(interp, 1, argv, "method ?args ...?");
117                 return JIM_ERR;
118         }
119         char *name = (char*) Jim_GetString(argv[1], NULL);
120         char *file = (char*) Jim_GetString(argv[2], NULL);
121
122         // Find length
123         const char *data;
124         int actual;
125
126         int retcode;
127
128         const char *script = alloc_printf("set dummy_val $httppostdata(%s); set dummy_val",
129                         name);
130         retcode = Jim_Eval_Named(interp, script, "httpd.c", __LINE__ );
131         free((void *) script);
132         if (retcode != JIM_OK)
133                 return retcode;
134
135         data = Jim_GetString(Jim_GetResult(interp), &actual);
136
137         FILE *f;
138         f = fopen(file, "wb");
139         if (f != NULL)
140         {
141                 int ok;
142                 ok = fwrite(data, 1, actual, f) == actual;
143                 fclose(f);
144
145                 if (!ok)
146                 {
147                         Jim_SetResultString(interp, "Could not write to file", -1);
148                         return JIM_ERR;
149                 }
150         }
151         else
152         {
153                 Jim_SetResultString(interp, "Could not create file", -1);
154                 return JIM_ERR;
155         }
156         return JIM_OK;
157 }
158
159
160 int
161 httpd_Jim_Command_formfetch(Jim_Interp *interp,
162                                    int argc,
163                                    Jim_Obj *const *argv)
164 {
165     if (argc!=2)
166     {
167         Jim_WrongNumArgs(interp, 1, argv, "method ?args ...?");
168         return JIM_ERR;
169     }
170     char *name = (char*)Jim_GetString(argv[1], NULL);
171
172
173     const char *script = alloc_printf("set dummy_val $httppostdata(%s); set dummy_val",
174                         name);
175         int retcode = Jim_Eval_Named(interp, script, "httpd.c", __LINE__ );
176         free((void *) script);
177         if (retcode != JIM_OK)
178         {
179             Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
180         } else
181         {
182             Jim_SetResult(interp, Jim_GetResult(interp));
183         }
184
185     return JIM_OK;
186 }
187
188 struct httpd_request
189 {
190         int post;
191         struct MHD_PostProcessor *postprocessor;
192
193         //Jim_Obj *dict;
194
195         int complete; /* did we receive the entire post ? */
196
197 };
198
199 static void request_completed(void *cls, struct MHD_Connection *connection,
200                 void **con_cls, enum MHD_RequestTerminationCode toe)
201 {
202         struct httpd_request *r = (struct httpd_request*) *con_cls;
203
204         if (NULL == r)
205                 return;
206
207         if (r->postprocessor)
208         {
209                 MHD_destroy_post_processor(r->postprocessor);
210         }
211
212         free(r);
213         *con_cls = NULL;
214 }
215
216 /* append to said key in dictonary */
217 static void append_key(struct httpd_request *r, const char *key,
218                 const char *data, size_t off, size_t size)
219 {
220         Jim_Obj *keyObj = Jim_NewStringObj(interp, key, -1);
221         Jim_Obj *value = NULL;
222
223         Jim_Obj *dict = Jim_GetVariableStr(interp, "httppostdata", 0);
224
225         if (dict!=NULL)
226         {
227                 if (Jim_DictKey(interp, dict, keyObj, &value, 0) != JIM_OK)
228                 {
229                          value = NULL;
230                 }
231         }
232         if (value == NULL)
233                 value = Jim_NewStringObj(interp, "", -1);
234
235         /* create a new object we append to and insert into this location */
236         Jim_Obj *newObj = Jim_NewStringObj(interp, "", -1);
237         Jim_AppendObj(interp, newObj, value);
238         Jim_AppendString(interp, newObj, data, size);
239         /* uhh... use name here of dictionary */
240         Jim_SetDictKeysVector(interp, Jim_NewStringObj(interp, "httppostdata", -1), &keyObj, 1, newObj);
241 }
242
243 /* append data to each key */
244 static int iterate_post(void *con_cls, enum MHD_ValueKind kind,
245                 const char *key, const char *filename, const char *content_type,
246                 const char *transfer_encoding, const char *data, size_t off,
247                 size_t size)
248 {
249         struct httpd_request *r = (struct httpd_request*) con_cls;
250
251         append_key(r, key, data, off, size);
252
253         return MHD_YES;
254 }
255
256 static int record_arg(void *cls, enum MHD_ValueKind kind, const char *key,
257                 const char *value)
258 {
259         struct httpd_request *r = (struct httpd_request*) cls;
260         append_key(r, key, value, 0, strlen(value));
261         return MHD_YES;
262 }
263
264 static int ahc_echo(void * cls, struct MHD_Connection * connection,
265                 const char * url, const char * method, const char * version,
266                 const char * upload_data, unsigned int * upload_data_size, void ** ptr)
267 {
268         struct MHD_Response * response;
269         int ret;
270
271         int post = 0;
272
273         if (0 == strcmp(method, "POST"))
274         {
275                 post = 1;
276         }
277         else if (0 == strcmp(method, "GET"))
278         {
279         }
280         else
281         {
282                 return MHD_NO; /* unexpected method */
283         }
284
285         struct httpd_request *r;
286         if (*ptr == NULL)
287         {
288                 /* The first time only the headers are valid,
289                  do not respond in the first round... */
290
291                 *ptr = malloc(sizeof(struct httpd_request));
292                 if (*ptr == NULL)
293                         return MHD_NO;
294                 memset(*ptr, 0, sizeof(struct httpd_request));
295
296                 r = (struct httpd_request *) *ptr;
297
298                 r->post = post;
299                 Jim_SetVariableStr(interp, "httppostdata", Jim_NewDictObj(interp, NULL, 0));
300
301                 /* fill in url query strings in dictonary */
302                 MHD_get_connection_values(connection, MHD_GET_ARGUMENT_KIND,
303                                 record_arg, r);
304
305                 if (r->post)
306                 {
307                         r->postprocessor = MHD_create_post_processor(connection, 2048
308                                         * 1024, iterate_post, r);
309                 }
310
311                 return MHD_YES;
312         }
313
314         r = (struct httpd_request *) *ptr;
315
316         if (r->post)
317         {
318                 /* consume post data */
319                 if (*upload_data_size)
320                 {
321                         MHD_post_process(r->postprocessor, upload_data, *upload_data_size);
322                         *upload_data_size = 0;
323                         return MHD_YES;
324                 }
325                 else
326                 {
327                 }
328         } else
329         {
330         }
331
332         /* hand over to request who will be using it. */
333         //      r->dict = NULL;
334
335
336         /* FIX!!!! we need more advanced handling of url's to avoid them
337          * being subverted to evil purposes
338          */
339
340         url++; /* skip '/' */
341
342         const char *suffix;
343         suffix = strrchr(url, '.');
344         if ((suffix != NULL) && (strcmp(suffix, ".tcl") == 0))
345         {
346                 printf("Run tcl %s\n", url);
347
348                 int retcode;
349
350                 const char *script = alloc_printf(
351                                 "global httpdata; source {%s}; set httpdata", url);
352                 retcode = Jim_Eval_Named(interp, script, "httpd.c", __LINE__ );
353                 free((void *) script);
354
355                 if (retcode == JIM_ERR)
356                 {
357                         printf("Tcl failed\n");
358                         const char *t = httpd_exec_cgi_tcl_error(interp);
359                         if (t == NULL)
360                                 return MHD_NO;
361
362                         response = MHD_create_response_from_data(strlen(t), (void *) t,
363                                         MHD_YES, MHD_NO);
364                         ret = MHD_queue_response(connection,
365                                         MHD_HTTP_INTERNAL_SERVER_ERROR, response);
366                         MHD_destroy_response(response);
367                         return ret;
368                 }
369                 else
370                 {
371                         printf("Tcl OK\n");
372                         /* FIX!!! how to handle mime types??? */
373                         const char *result;
374                         int reslen;
375                         result = Jim_GetString(Jim_GetResult(interp), &reslen);
376
377                         response = MHD_create_response_from_data(reslen, (void *) result,
378                                         MHD_NO, MHD_YES);
379                         ret = MHD_queue_response(connection,
380                                         MHD_HTTP_INTERNAL_SERVER_ERROR, response);
381                         MHD_destroy_response(response);
382                         return ret;
383                 }
384         }
385         else
386         {
387                 void *data;
388                 int len;
389
390                 int retval = loadFile(url, &data, &len);
391                 if (retval != ERROR_OK)
392                 {
393                         printf("Did not find %s\n", url);
394
395                         response = MHD_create_response_from_data(strlen(PAGE_NOT_FOUND),
396                                         (void *) PAGE_NOT_FOUND, MHD_NO, MHD_NO);
397                         ret = MHD_queue_response(connection, MHD_HTTP_NOT_FOUND, response);
398                         MHD_destroy_response(response);
399                         return ret;
400                 }
401
402                 printf("Serving %s length=%d\n", url, len);
403                 /* serve file directly */
404                 response = MHD_create_response_from_data(len, data, MHD_YES, MHD_NO);
405                 MHD_add_response_header(response, "Content-Type", "image/png");
406
407                 ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
408                 MHD_destroy_response(response);
409
410                 //free(data);
411                 return ret;
412         }
413 }
414
415 static struct MHD_Daemon * d;
416
417 int httpd_start(void)
418 {
419
420         int port = 8888;
421         LOG_USER("Launching httpd server on port %d", port);
422         d = MHD_start_daemon(MHD_USE_SELECT_INTERNALLY, port, NULL, NULL,
423                         &ahc_echo, NULL, /* could be data for handler, but we only have a single handler, use global variables instead */
424                         MHD_OPTION_NOTIFY_COMPLETED, request_completed, NULL, /* Closure... what's that??? */
425                         MHD_OPTION_END);
426         if (d == NULL)
427                 return ERROR_FAIL;
428
429         Jim_CreateCommand(interp,
430                                                   "formfetch",
431                                                   httpd_Jim_Command_formfetch,
432                                                   NULL,
433                                                   NULL);
434
435     Jim_CreateCommand(interp,
436                       "writeform",
437                       httpd_Jim_Command_writeform,
438                       NULL,
439                       NULL);
440
441
442         return ERROR_OK;
443 }
444
445 void httpd_stop(void)
446 {
447         MHD_stop_daemon(d);
448 }
449
450 void openocd_sleep_prelude(void)
451 {
452         /* FIX!!!! add locking here!!!! */
453 }
454
455 void openocd_sleep_postlude(void)
456 {
457         /* FIX!!!! add locking here!!!! */
458 }
459