plugins/palm/palm.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2
   3 /*  Monkey HTTP Daemon
   4  *  ------------------
   5  *  Copyright (C) 2001-2010, Eduardo Silva P.
   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 Library 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 Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <sys/stat.h>
  26 #include <unistd.h>
  27
  28 #include "config.h"
  29 #include "plugin.h"
  30 #include "str.h"
  31 #include "palm.h"
  32 #include "http.h"
  33 #include "http_status.h"
  34 #include "monkey.h"
  35 #include "epoll.h"
  36 #include "utils.h"
  37 #include "header.h"
  38
  39 #include "cgi.h"
  40 #include "palm.h"
  41
  42 /* Plugin data for register */
  43 mk_plugin_data_t _shortname = "palm";
  44 mk_plugin_data_t _name = "Palm";
  45 mk_plugin_data_t _version = "0.1";
  46 mk_plugin_stage_t _stages = MK_PLUGIN_STAGE_10 | MK_PLUGIN_STAGE_40;
  47
  48 /* Read database configuration parameters */
  49 int mk_palm_conf(char *confdir)
  50 {
  51     int i, ret = 0;
  52     unsigned long len;
  53     char *conf_path;
  54     struct mk_config *p;
  55     struct mk_palm *new, *r;
  56     struct mk_string_line *line, *lp;
  57
  58     mk_api->str_build(&conf_path, &len, "%s/palm.conf", confdir);
  59
  60     p = conf = mk_api->config_create(conf_path);
  61
  62     r = palms;
  63     while (p) {
  64         /* Validate palm configuration line */
  65         i = 0;
  66         if (strcasecmp(p->key, "Palm") == 0) {
  67             line = mk_api->str_split_line(p->val);
  68             lp = line;
  69
  70             while (lp) {
  71                 i++;
  72                 if (lp->len <= 0) {
  73                     fprintf(stderr, MK_PALM_ERROR_LINE, p->val);
  74                     _exit(1);
  75                 }
  76                 lp = lp->next;
  77             }
  78
  79             if (i != 4) {
  80                 fprintf(stderr, MK_PALM_ERROR_LINE, p->val);
  81                 _exit(1);
  82             }
  83         }
  84         lp = line;
  85
  86         /* Alloc node */
  87         new = mk_api->mem_alloc(sizeof(struct mk_palm));
  88
  89         /* Palm file extensions */
  90         new->extension = lp->val;
  91         lp = lp->next;
  92
  93         /* Palm mime type */
  94         new->mimetype = lp->val;
  95         lp = lp->next;
  96
  97         /* Palm server address */
  98         new->server_addr = lp->val;
  99         lp = lp->next;
 100
 101         /* Palm server TCP port */
 102         new->server_port = atoi(lp->val);
 103         lp = lp->next;
 104
 105         new->next = NULL;
 106
 107         /* Linking node */
 108         if (!palms) {
 109             palms = new;
 110         }
 111         else {
 112             r = palms;
 113             while (r->next) {
 114                 r = r->next;
 115             }
 116             r->next = new;
 117         }
 118         p = p->next;
 119     }
 120
 121     mk_api->mem_free(conf_path);
 122     return ret;
 123 }
 124
 125 struct mk_palm *mk_palm_get_handler(mk_pointer * file)
 126 {
 127     struct mk_palm *p;
 128     int j, len, extlen;
 129
 130     j = len = file->len;
 131
 132     /* looking for extension */
 133     while (file->data[j] != '.' && j >= 0) {
 134         j--;
 135     }
 136
 137     extlen = file->len - j - 1;
 138     if (j == 0) {
 139         return NULL;
 140     }
 141
 142     p = palms;
 143     while (p) {
 144         if (strncasecmp(file->data + j + 1, p->extension, extlen) == 0) {
 145             return p;
 146         }
 147         p = p->next;
 148     }
 149
 150     return NULL;
 151 }
 152
 153 void mk_palm_iov_add_header(struct mk_iov *iov,
 154                             mk_pointer header, mk_pointer value)
 155 {
 156     mk_api->iov_add_entry(iov, header.data, header.len,
 157                           mk_iov_equal, MK_IOV_NOT_FREE_BUF);
 158     mk_api->iov_add_entry(iov, value.data, value.len,
 159                           mk_iov_crlf, MK_IOV_NOT_FREE_BUF);
 160 }
 161
 162 struct mk_iov *mk_palm_create_env(struct client_request *cr,
 163                                   struct request *sr)
 164 {
 165     struct mk_iov *iov;
 166
 167     iov = mk_api->iov_create(100, 0);
 168
 169     mk_api->iov_add_entry(iov, sr->real_path.data,
 170                           sr->real_path.len, mk_iov_crlf, MK_IOV_NOT_FREE_BUF);
 171
 172     mk_api->iov_add_entry(iov, mk_cgi_document_root.data,
 173                           mk_cgi_document_root.len,
 174                           mk_iov_equal, MK_IOV_NOT_FREE_BUF);
 175
 176     mk_api->iov_add_entry(iov, sr->host_conf->documentroot.data,
 177                           sr->host_conf->documentroot.len, mk_iov_crlf,
 178                           MK_IOV_NOT_FREE_BUF);
 179
 180
 181     if (sr->method == HTTP_METHOD_POST && sr->content_length > 0) {
 182         /* FIX Content length:
 183            mk_palm_iov_add_header(iov, mk_cgi_content_length,
 184            sr->content_length);
 185          */
 186         mk_palm_iov_add_header(iov, mk_cgi_content_type, sr->content_type);
 187     }
 188
 189
 190     //        mk_palm_iov_add_header(iov, mk_cgi_server_addr, mk_api->config->server_addr);
 191     mk_palm_iov_add_header(iov, mk_cgi_server_name, sr->host);
 192     mk_palm_iov_add_header(iov, mk_cgi_server_protocol, mk_monkey_protocol);
 193     mk_palm_iov_add_header(iov, mk_cgi_server_software,
 194                            mk_api->config->server_software);
 195     //mk_palm_iov_add_header(iov, mk_cgi_server_signature, sr->host_conf->host_signature);
 196
 197     if (sr->user_agent.data)
 198         mk_palm_iov_add_header(iov, mk_cgi_http_user_agent, sr->user_agent);
 199
 200     if (sr->accept.data)
 201         mk_palm_iov_add_header(iov, mk_cgi_http_accept, sr->accept);
 202
 203     if (sr->accept_charset.data)
 204         mk_palm_iov_add_header(iov, mk_cgi_http_accept_charset,
 205                                sr->accept_charset);
 206
 207     if (sr->accept_encoding.data)
 208         mk_palm_iov_add_header(iov, mk_cgi_http_accept_encoding,
 209                                sr->accept_encoding);
 210
 211     if (sr->accept_language.data)
 212         mk_palm_iov_add_header(iov, mk_cgi_http_accept_language,
 213                                sr->accept_language);
 214
 215     if (sr->host.data)
 216         mk_palm_iov_add_header(iov, mk_cgi_http_host, sr->host);
 217
 218     if (sr->cookies.data)
 219         mk_palm_iov_add_header(iov, mk_cgi_http_cookie, sr->cookies);
 220
 221     if (sr->referer.data)
 222         mk_palm_iov_add_header(iov, mk_cgi_http_referer, sr->referer);
 223
 224     //        mk_palm_iov_add_header(iov, mk_cgi_server_port, mk_monkey_port);
 225     mk_palm_iov_add_header(iov, mk_cgi_gateway_interface, mk_cgi_version);
 226     //mk_palm_iov_add_header(iov, mk_cgi_remote_addr, cr->ip);
 227     mk_palm_iov_add_header(iov, mk_cgi_request_uri, sr->uri);
 228     //mk_palm_iov_add_header(iov, mk_cgi_request_method, sr->method);
 229     mk_palm_iov_add_header(iov, mk_cgi_script_name, sr->uri);
 230
 231
 232     /* real path is not an mk_pointer */
 233     mk_palm_iov_add_header(iov, mk_cgi_script_filename, sr->real_path);
 234     //mk_palm_iov_add_header(iov, mk_cgi_remote_port, cr->port);
 235     mk_palm_iov_add_header(iov, mk_cgi_query_string, sr->query_string);
 236     //mk_palm_iov_add_header(iov, mk_cgi_post_vars, sr->post_variables);
 237
 238     /* CRLF */
 239     mk_api->iov_add_entry(iov, mk_iov_crlf.data, mk_iov_crlf.len,
 240                           mk_iov_none, MK_IOV_NOT_FREE_BUF);
 241     mk_api->iov_add_entry(iov, mk_iov_crlf.data, mk_iov_crlf.len,
 242                           mk_iov_none, MK_IOV_NOT_FREE_BUF);
 243     mk_api->iov_add_entry(iov, mk_iov_crlf.data, mk_iov_crlf.len,
 244                           mk_iov_none, MK_IOV_NOT_FREE_BUF);
 245     return iov;
 246 }
 247
 248 /*
 249 int mk_palm_send_response(struct client_request *cr, struct request *sr,
 250                           char *buf)
 251 {
 252     int len;
 253     int i;
 254     long n;
 255     char *s;
 256     char *status_msg = "Status: ";
 257
 258     len = 8;
 259     if (strncasecmp(buf, status_msg, len) == 0) {
 260         i = (int) mk_api->str_search(buf + len, " ");
 261         s = mk_api->str_copy_substr(buf, len, len + i);
 262         sr->headers->status = atoi(s);
 263         i = (int) mk_api->str_search(buf, mk_crlf.data) + mk_crlf.len;
 264     }
 265     else {
 266         i = 0;
 267         sr->headers->status = M_HTTP_OK;
 268     }
 269
 270     sr->headers->cgi = SH_CGI;
 271     sr->headers->content_length = 0;
 272
 273     mk_api->socket_cork_flag(cr->socket, TCP_CORK_ON);
 274     mk_api->header_send(cr->socket, cr, sr, sr->log);
 275     n = write(cr->socket, buf + i, strlen(buf + i));
 276     return 0;
 277 }
 278 */
 279
 280 int mk_palm_send_headers(struct client_request *cr, struct request *sr)
 281 {
 282     int n;
 283
 284     sr->headers->status = M_HTTP_OK;
 285     sr->headers->cgi = SH_CGI;
 286
 287     /* Chunked transfer encoding */
 288     if (sr->protocol >= HTTP_PROTOCOL_11) {
 289         sr->headers->transfer_encoding = MK_HEADER_TE_TYPE_CHUNKED;
 290     }
 291
 292     /* Send just headers from buffer */
 293     PLUGIN_TRACE("Sending headers to FD %i", cr->socket);
 294
 295     n = (int) mk_api->header_send(cr->socket, cr, sr, sr->log);
 296
 297     PLUGIN_TRACE("Send headers returned %i", n);
 298     return n;
 299
 300     //mk_api->socket_cork_flag(cr->socket, TCP_CORK_OFF);
 301 }
 302
 303
 304 int _mk_plugin_init(void **api, char *confdir)
 305 {
 306     mk_api = *api;
 307     palms = 0;
 308
 309     /* Init some pointers */
 310     mk_api->pointer_set(&mk_monkey_protocol, HTTP_PROTOCOL_11_STR);
 311     mk_api->pointer_set(&mk_iov_crlf, MK_IOV_CRLF);
 312     mk_api->pointer_set(&mk_iov_equal, MK_IOV_EQUAL);
 313
 314     /* Read configuration */
 315     mk_palm_conf(confdir);
 316     return 0;
 317 }
 318
 319 int _mk_plugin_stage_10(struct server_config *config)
 320 {
 321     mk_cgi_env();
 322     return 0;
 323 }
 324
 325 int _mk_plugin_stage_40(struct plugin *plugin, struct client_request *cr, struct request *sr)
 326 {
 327     struct mk_palm *palm;
 328     struct mk_palm_request *pr;
 329
 330     PLUGIN_TRACE("PALM STAGE 40, requesting '%s'", sr->real_path.data);
 331
 332     palm = mk_palm_get_handler(&sr->uri);
 333     if (!palm) {
 334         PLUGIN_TRACE("PALM NOT ME");
 335         return MK_PLUGIN_RET_NOT_ME;
 336     }
 337
 338     /* Connect to server */
 339     pr = mk_palm_do_instance(palm, cr, sr);
 340
 341     if (!pr) {
 342         PLUGIN_TRACE("return %i (MK_PLUGIN_RET_END)", MK_PLUGIN_RET_END);
 343         return MK_PLUGIN_RET_END;
 344     }
 345
 346     mk_palm_send_headers(cr, sr);
 347
 348     /* Register Palm instance */
 349     mk_palm_request_add(pr);
 350
 351     /* Register socket with thread Epoll interface */
 352     mk_api->event_add(pr->palm_fd, plugin, cr, sr);
 353     PLUGIN_TRACE("Palm: Event registered / client=%i / palm_socket=%i",
 354                  pr->client_fd, pr->palm_fd);
 355
 356     PLUGIN_TRACE("return %i (MK_PLUGIN_RET_CONTINUE)", MK_PLUGIN_RET_CONTINUE);
 357     return MK_PLUGIN_RET_CONTINUE;
 358 }
 359
 360 struct mk_palm_request *mk_palm_request_create(int client_fd,
 361                                                int palm_fd,
 362                                                struct client_request *cr,
 363                                                struct request *sr,
 364                                                struct mk_palm *palm)
 365 {
 366     struct mk_palm_request *new;
 367
 368     new = mk_api->mem_alloc(sizeof(struct mk_palm_request));
 369     new->client_fd = client_fd;
 370     new->palm_fd = palm_fd;
 371     new->palm = palm;
 372     new->bytes_sent = 0;
 373     new->bytes_read = 0;
 374     new->headers_sent = VAR_OFF;
 375     new->cr = cr;
 376     new->sr = sr;
 377     new->next = NULL;
 378
 379     return new;
 380 }
 381
 382 struct mk_palm_request *mk_palm_do_instance(struct mk_palm *palm,
 383                                             struct client_request *cr, struct request *sr)
 384 {
 385     int ret;
 386     int palm_socket;
 387
 388     /* Get Palm handler */
 389     palm = mk_palm_get_handler(&sr->uri);
 390
 391     /* Connecting to Palm Server */
 392     palm_socket = (int) mk_api->socket_create();
 393     ret = (int) mk_api->socket_connect(palm_socket,
 394                                        palm->server_addr,
 395                                        palm->server_port);
 396
 397     if (ret < 0) {
 398         fprintf(stderr, "\nPalm: Cannot connect to %s on port %i",
 399                 palm->server_addr, palm->server_port);
 400         return NULL;
 401     }
 402     /* Set palm socket to non-blocking */
 403     mk_api->socket_set_nonblocking(palm_socket);
 404
 405     /* Return instance */
 406     return mk_palm_request_create(cr->socket, palm_socket, cr, sr, palm);
 407 }
 408
 409 void mk_palm_request_add(struct mk_palm_request *pr)
 410 {
 411     struct mk_palm_request *pr_list, *aux;
 412
 413     /* Get thread data */
 414     pr_list = pthread_getspecific(_mk_plugin_data);
 415
 416     /* No connection previously was found */
 417     if(!pr_list) {
 418         pthread_setspecific(_mk_plugin_data, pr);
 419         return;
 420     }
 421
 422     /* Add Node */
 423     aux = pr_list;
 424     while(aux->next){
 425         aux = aux->next;
 426     }
 427
 428     aux->next = pr;
 429     pthread_setspecific(_mk_plugin_data, pr_list);
 430 }
 431
 432 /* It register the request and connection data, if it doesn't
 433  * exists it will be create it, otherwise will return the pointer
 434  * to the mk_palm_request struct node
 435  */
 436 struct mk_palm_request *mk_palm_request_get(int socket)
 437 {
 438     struct mk_palm_request *pr, *aux;
 439
 440     /* Get thread data */
 441     pr = pthread_getspecific(_mk_plugin_data);
 442
 443     /* No connection previously was found */
 444     if(!pr) {
 445         return NULL;
 446     }
 447
 448     /* Look for node */
 449     aux = pr;
 450     while(aux){
 451         if(aux->client_fd == socket){
 452             return aux;
 453         }
 454         aux = aux->next;
 455     }
 456
 457     return NULL;
 458 }
 459
 460 void mk_palm_request_update(int socket, struct mk_palm_request  *pr)
 461 {
 462     struct mk_palm_request *aux, *list;
 463
 464     list = pthread_getspecific(_mk_plugin_data);
 465
 466     if (!list) {
 467         return;
 468     }
 469
 470     aux = list;
 471     while (aux) {
 472         if (aux->client_fd == socket) {
 473             aux->bytes_sent = pr->bytes_sent;
 474             aux->bytes_read = pr->bytes_read;
 475             aux->headers_sent = pr->headers_sent;
 476
 477             /* Update data */
 478             pthread_setspecific(_mk_plugin_data, list);
 479             return;
 480         }
 481         aux = aux->next;
 482     }
 483 }
 484
 485 void _mk_plugin_stage_40_event_write(struct client_request *cr, struct request *sr)
 486 {
 487     int n;
 488     ssize_t bytes_iov=-1;
 489     struct mk_iov *iov;
 490     struct mk_palm_request *pr;
 491
 492     PLUGIN_TRACE("Handling write event");
 493
 494     pr = mk_palm_request_get(cr->socket);
 495     if (pr) {
 496         if (pr->bytes_sent == 0) {
 497
 498             PLUGIN_TRACE("Palm request: '%s'", sr->real_path.data);
 499
 500             /* Palm environment vars */
 501             iov = mk_palm_create_env(cr, sr);
 502
 503             /* Setup Palm socket */
 504             mk_api->socket_set_tcp_nodelay(pr->palm_fd);
 505             /* Write request to palm server */
 506             bytes_iov = (ssize_t )mk_api->iov_send(pr->palm_fd, iov, MK_IOV_SEND_TO_SOCKET);
 507
 508             if (bytes_iov >= 0){
 509                 pr->bytes_sent += bytes_iov;
 510                 n = (long) bytes_iov;
 511             }
 512         }
 513     }
 514
 515     PLUGIN_TRACE("Bytes sent to PALM SERVER: %i", pr->bytes_sent);
 516     mk_api->event_socket_change_mode(pr->palm_fd, MK_EPOLL_READ);
 517 }
 518
 519 int mk_palm_send_chunk(int socket, void *buffer, unsigned int len)
 520 {
 521     int n;
 522     char *chunk_size=0;
 523     unsigned long chunk_len=0;
 524
 525
 526     mk_api->socket_cork_flag(socket, TCP_CORK_ON);
 527
 528     mk_api->str_build(&chunk_size, &chunk_len, "%x%s", len, MK_CRLF);
 529
 530     n = write(socket, chunk_size, chunk_len);
 531     mk_api->mem_free(chunk_size);
 532
 533     if (n < 0) {
 534         PLUGIN_TRACE("Error sending chunked header, write() returned %i", n);
 535         perror("write");
 536         return -1;
 537     }
 538
 539     n = write(socket, buffer, len);
 540     PLUGIN_TRACE("SEND CHUNK: requested %i, sent %i", len, n);
 541
 542     if (n < 0) {
 543         PLUGIN_TRACE("Error sending chunked body, write() returned %i", n);
 544         perror("write");
 545         return -1;
 546     }
 547
 548     write(socket, MK_CRLF, 2);
 549     mk_api->socket_cork_flag(socket, TCP_CORK_OFF);
 550     return n;
 551 }
 552
 553 int _mk_plugin_stage_40_event_read(struct client_request *cr, struct request *sr)
 554 {
 555     int n;
 556     int n_header;
 557     int ret = -1;
 558     int headers_end = -1;
 559     int read_offset = 0;
 560     struct mk_palm_request *pr;
 561
 562     pr = mk_palm_request_get(cr->socket);
 563
 564     if (!pr){
 565         PLUGIN_TRACE("Invalid palm request, not found");
 566         return -1;
 567     }
 568
 569     /* Reset read buffer */
 570     bzero(pr->data_read, MK_PALM_BUFFER_SIZE);
 571
 572     /* Read data */
 573     pr->len_read = read(pr->palm_fd, pr->data_read, (MK_PALM_BUFFER_SIZE - 1));
 574
 575     if (pr->len_read < 0) {
 576         perror("read");
 577     }
 578
 579     PLUGIN_TRACE("Bytes read from FD %i: %i", pr->palm_fd, pr->len_read);
 580
 581     if (pr->len_read >=0) {
 582         if (pr->headers_sent == VAR_OFF) {
 583             headers_end = (int) mk_api->str_search(pr->data_read, MK_IOV_CRLFCRLF);
 584
 585             /* Look for headers end */
 586             while (headers_end == -1) {
 587                 PLUGIN_TRACE("CANNOT FIND HEADERS_END :/");
 588
 589                 n = read(pr->palm_fd,
 590                          pr->data_read + pr->len_read,
 591                          (MK_PALM_BUFFER_SIZE -1) - pr->len_read);
 592
 593                 if (n >=0) {
 594                     pr->len_read += n;
 595                 }
 596                 else{
 597                     PLUGIN_TRACE("***********");
 598                 }
 599
 600                 headers_end = (int) mk_api->str_search(pr->data_read, MK_IOV_CRLFCRLF);
 601             }
 602
 603             if (headers_end > 0) {
 604                 headers_end += 4;
 605             }
 606             else {
 607                 PLUGIN_TRACE("SOMETHING BAD HAPPENS");
 608             }
 609
 610             /* FIXME: What about if this write() wrote partial headers ? ugh! */
 611             n = write(cr->socket, pr->data_read, headers_end);
 612
 613             PLUGIN_TRACE("Headers written: %i", n);
 614
 615             /* Enable headers flag */
 616             pr->headers_sent = VAR_ON;
 617             read_offset = headers_end;
 618
 619             mk_api->socket_cork_flag(cr->socket, TCP_CORK_OFF);
 620         }
 621
 622         int sent = 0;
 623         while (sent != (pr->len_read - read_offset)) {
 624             PLUGIN_TRACE("LOOP");
 625             n = mk_palm_send_chunk(cr->socket,
 626                                    pr->data_read + read_offset + sent,
 627                                    pr->len_read - read_offset - sent);
 628
 629             if (n < 0) {
 630                 PLUGIN_TRACE("WRITE ERROR");
 631                 perror("write");
 632                 return MK_PLUGIN_RET_END;
 633             }
 634             else {
 635                 PLUGIN_TRACE("BYTES SENT: %i", n);
 636
 637                 sent += n;
 638             }
 639         }
 640
 641         mk_palm_request_update(cr->socket, pr);
 642         return MK_PLUGIN_RET_CONTINUE;
 643
 644         /* Turn off TCP_CORK_OFF */
 645         mk_api->socket_cork_flag(cr->socket, TCP_CORK_OFF);
 646         ret = MK_PLUGIN_RET_CONTINUE;
 647     }
 648     else {
 649         PLUGIN_TRACE("BIG ERROR!");
 650     }
 651
 652     /* Update thread node info */
 653     mk_palm_request_update(cr->socket, pr);
 654
 655     return ret;
 656 }