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 "http.h"
  32 #include "http_status.h"
  33 #include "monkey.h"
  34 #include "epoll.h"
  35 #include "utils.h"
  36 #include "header.h"
  37
  38 #include "cgi.h"
  39 #include "palm.h"
  40 #include "request.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.2";
  46 mk_plugin_hook_t _hooks = 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     PLUGIN_TRACE( "Create env");
 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     PLUGIN_TRACE( "%s\n", sr->real_path.data );
 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 int mk_palm_send_headers(struct client_request *cr, struct request *sr)
 249 {
 250     int n;
 251
 252     sr->headers->status = M_HTTP_OK;
 253     sr->headers->cgi = SH_CGI;
 254
 255     /* Chunked transfer encoding */
 256     if (sr->protocol >= HTTP_PROTOCOL_11) {
 257         sr->headers->transfer_encoding = MK_HEADER_TE_TYPE_CHUNKED;
 258     }
 259
 260     /* Send just headers from buffer */
 261     PLUGIN_TRACE("Sending headers to FD %i", cr->socket);
 262
 263     n = (int) mk_api->header_send(cr->socket, cr, sr, sr->log);
 264
 265     PLUGIN_TRACE("Send headers returned %i", n);
 266     return n;
 267
 268     //mk_api->socket_cork_flag(cr->socket, TCP_CORK_OFF);
 269 }
 270
 271
 272 int _mkp_init(void **api, char *confdir)
 273 {
 274     mk_api = *api;
 275     palms = 0;
 276
 277     /* Init some pointers */
 278     mk_api->pointer_set(&mk_monkey_protocol, HTTP_PROTOCOL_11_STR);
 279     mk_api->pointer_set(&mk_iov_crlf, MK_IOV_CRLF);
 280     mk_api->pointer_set(&mk_iov_equal, MK_IOV_EQUAL);
 281
 282     /* Read configuration */
 283     mk_palm_conf(confdir);
 284     return 0;
 285 }
 286
 287 int _mkp_stage_10(struct server_config *config)
 288 {
 289     mk_cgi_env();
 290     return 0;
 291 }
 292
 293 int _mkp_stage_40(struct plugin *plugin, struct client_request *cr, struct request *sr)
 294 {
 295     struct mk_palm *palm;
 296     struct mk_palm_request *pr;
 297
 298     PLUGIN_TRACE("PALM STAGE 40, requesting '%s'", sr->real_path.data);
 299
 300     palm = mk_palm_get_handler(&sr->uri);
 301     if (!palm) {
 302         PLUGIN_TRACE("PALM NOT ME");
 303         return MK_PLUGIN_RET_NOT_ME;
 304     }
 305
 306     /* Connect to server */
 307     pr = mk_palm_do_instance(palm, cr, sr);
 308
 309     if (!pr) {
 310         PLUGIN_TRACE("return %i (MK_PLUGIN_RET_END)", MK_PLUGIN_RET_END);
 311         return MK_PLUGIN_RET_END;
 312     }
 313
 314     mk_palm_send_headers(cr, sr);
 315
 316     /* Register Palm instance */
 317     mk_palm_request_add(pr);
 318
 319     /* Register socket with thread Epoll interface */
 320     mk_api->event_add(pr->palm_fd, MK_EPOLL_READ, plugin, cr, sr);
 321     PLUGIN_TRACE("Palm: Event registered / client=%i / palm_socket=%i",
 322                  pr->client_fd, pr->palm_fd);
 323
 324     mk_palm_send_request(cr, sr);
 325
 326     PLUGIN_TRACE("return %i (MK_PLUGIN_RET_CONTINUE)", MK_PLUGIN_RET_CONTINUE);
 327
 328     return MK_PLUGIN_RET_CONTINUE;
 329 }
 330
 331
 332
 333 struct mk_palm_request *mk_palm_do_instance(struct mk_palm *palm,
 334                                             struct client_request *cr,
 335                                             struct request *sr)
 336 {
 337     int ret;
 338     int palm_socket;
 339
 340     /* Get Palm handler */
 341     //   palm = mk_palm_get_handler(&sr->uri);
 342
 343     /* Connecting to Palm Server */
 344     palm_socket = mk_api->socket_create();
 345     ret = mk_api->socket_connect(palm_socket,
 346                                        palm->server_addr,
 347                                        palm->server_port);
 348
 349     if (ret < 0) {
 350         fprintf(stderr, "\nPalm: Cannot connect to %s on port %i",
 351                 palm->server_addr, palm->server_port);
 352         return NULL;
 353     }
 354
 355     /* Return instance */
 356     return mk_palm_request_create(cr->socket, palm_socket, cr, sr, palm);
 357 }
 358
 359 void mk_palm_send_request(struct client_request *cr, struct request *sr)
 360 {
 361     int n;
 362     ssize_t bytes_iov=-1;
 363     struct mk_iov *iov;
 364     struct mk_palm_request *pr;
 365
 366     PLUGIN_TRACE("Handling write event");
 367
 368     pr = mk_palm_request_get(cr->socket);
 369     if (pr) {
 370         if (pr->bytes_sent == 0) {
 371
 372             PLUGIN_TRACE("Palm request: '%s'", sr->real_path.data);
 373
 374             /* Palm environment vars */
 375             iov = mk_palm_create_env(cr, sr);
 376
 377             /* Write request to palm server */
 378             mk_api->event_socket_change_mode(pr->palm_fd, MK_EPOLL_READ);
 379             bytes_iov = (ssize_t )mk_api->iov_send(pr->palm_fd, iov, MK_IOV_SEND_TO_SOCKET);
 380
 381             if (bytes_iov >= 0){
 382                 pr->bytes_sent += bytes_iov;
 383                 n = (long) bytes_iov;
 384             }
 385
 386             /* Socket stuff */
 387             mk_api->socket_set_tcp_nodelay(pr->palm_fd);
 388             mk_api->socket_set_nonblocking(pr->palm_fd);
 389         }
 390     }
 391
 392     PLUGIN_TRACE("Bytes sent to PALM SERVER: %i", pr->bytes_sent);
 393 }
 394
 395 int mk_palm_send_chunk(int socket, void *buffer, unsigned int len)
 396 {
 397     int n;
 398     char *chunk_size=0;
 399     unsigned long chunk_len=0;
 400
 401
 402     mk_api->socket_cork_flag(socket, TCP_CORK_ON);
 403     mk_api->str_build(&chunk_size, &chunk_len, "%x%s", len, MK_CRLF);
 404     n = mk_api->socket_send(socket, chunk_size, chunk_len);
 405     mk_api->mem_free(chunk_size);
 406
 407     if (n < 0) {
 408         PLUGIN_TRACE("Error sending chunked header, socket_send() returned %i", n);
 409         perror("socket_send");
 410         return -1;
 411     }
 412
 413     n = mk_api->socket_send(socket, buffer, len);
 414     PLUGIN_TRACE("SEND CHUNK: requested %i, sent %i", len, n);
 415
 416     if (n < 0) {
 417         PLUGIN_TRACE("Error sending chunked body, socket_send() returned %i", n);
 418         perror("socket_send");
 419         return -1;
 420     }
 421
 422     mk_api->socket_send(socket, MK_CRLF, 2);
 423     mk_api->socket_cork_flag(socket, TCP_CORK_OFF);
 424     return n;
 425 }
 426
 427 int _mkp_event_read(struct client_request *cr, struct request *sr)
 428 {
 429     int n;
 430     int ret = -1;
 431     int headers_end = -1;
 432     int read_offset = 0;
 433     struct mk_palm_request *pr;
 434
 435     pr = mk_palm_request_get(cr->socket);
 436
 437     if (!pr){
 438         PLUGIN_TRACE("Invalid palm request, not found");
 439         return -1;
 440     }
 441
 442     /* Reset read buffer */
 443     bzero(pr->data_read, MK_PALM_BUFFER_SIZE);
 444
 445     /* Read data */
 446     pr->len_read = mk_api->socket_read(pr->palm_fd,
 447                                        pr->data_read,
 448                                        (MK_PALM_BUFFER_SIZE - 1));
 449
 450     if (pr->len_read <= 0) {
 451         PLUGIN_TRACE("Ending connection: read() = %i", pr->len_read);
 452         return MK_PLUGIN_RET_END;
 453     }
 454     else if (pr->len_read > 0) {
 455         if (pr->headers_sent == VAR_OFF) {
 456             headers_end = (int) mk_api->str_search(pr->data_read,
 457                                                    MK_IOV_CRLFCRLF);
 458             /* Look for headers end */
 459             while (headers_end == -1) {
 460                 PLUGIN_TRACE("CANNOT FIND HEADERS_END :/");
 461
 462                 n = mk_api->socket_read(pr->palm_fd,
 463                                         pr->data_read + pr->len_read,
 464                                         (MK_PALM_BUFFER_SIZE -1) - pr->len_read);
 465
 466                 if (n >=0) {
 467                     pr->len_read += n;
 468                 }
 469                 else{
 470                     PLUGIN_TRACE("***********");
 471                 }
 472
 473                 headers_end = (int) mk_api->str_search(pr->data_read,
 474                                                        MK_IOV_CRLFCRLF);
 475             }
 476
 477             if (headers_end > 0) {
 478                 headers_end += 4;
 479             }
 480             else {
 481                 PLUGIN_TRACE("SOMETHING BAD HAPPENS");
 482             }
 483
 484             /* FIXME: What about if this socket_send wrote partial headers ? ugh! */
 485             n = mk_api->socket_send(cr->socket, pr->data_read, headers_end);
 486
 487             PLUGIN_TRACE("Headers written: %i", n);
 488
 489             /* Enable headers flag */
 490             pr->headers_sent = VAR_ON;
 491             read_offset = headers_end;
 492
 493             mk_api->socket_cork_flag(cr->socket, TCP_CORK_OFF);
 494         }
 495
 496         int sent = 0;
 497         while (sent != (pr->len_read - read_offset)) {
 498             PLUGIN_TRACE("LOOP");
 499             n = mk_palm_send_chunk(cr->socket,
 500                                    pr->data_read + read_offset + sent,
 501                                    pr->len_read - read_offset - sent);
 502
 503             if (n < 0) {
 504                 PLUGIN_TRACE("WRITE ERROR");
 505                 perror("socket_send");
 506                 return MK_PLUGIN_RET_END;
 507             }
 508             else {
 509                 PLUGIN_TRACE("BYTES SENT: %i", n);
 510
 511                 sent += n;
 512             }
 513         }
 514
 515         mk_palm_request_update(cr->socket, pr);
 516         return MK_PLUGIN_RET_CONTINUE;
 517
 518         /* Turn off TCP_CORK_OFF */
 519         mk_api->socket_cork_flag(cr->socket, TCP_CORK_OFF);
 520         ret = MK_PLUGIN_RET_CONTINUE;
 521     }
 522     else {
 523         PLUGIN_TRACE("BIG ERROR!");
 524     }
 525
 526     /* Update thread node info */
 527     mk_palm_request_update(cr->socket, pr);
 528
 529     return ret;
 530 }
 531
 532 void _mkp_event_close(struct client_request *cr, struct request *sr)
 533 {
 534     PLUGIN_TRACE("Closing socket to Palm server");
 535     mk_api->socket_close(cr->socket);
 536 }
 537
 538 void _mkp_event_error(struct client_request *cr, struct request *sr)
 539 {
 540     PLUGIN_TRACE( " ERROR ERROR " );
 541 }