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 *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(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         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 }
 453
 454 void openocd_sleep_postlude(void)
 455 {
 456 }
 457