src/plugin.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
   2
   3 /*  Monkey HTTP Daemon
   4  *  ------------------
   5  *  Copyright (C) 2001-2008, 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 <string.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <unistd.h>
  28 #include <dlfcn.h>
  29 #include <err.h>
  30
  31 #include "config.h"
  32 #include "plugin.h"
  33 #include "monkey.h"
  34 #include "request.h"
  35 #include "scheduler.h"
  36 #include "utils.h"
  37 #include "str.h"
  38 #include "file.h"
  39 #include "header.h"
  40 #include "memory.h"
  41 #include "iov.h"
  42
  43 void *mk_plugin_load(char *path)
  44 {
  45         void *handle;
  46
  47         handle = dlopen(path, RTLD_LAZY);
  48         if(!handle){
  49                 fprintf(stderr, "Error during dlopen(): %s\n", dlerror());
  50                 exit(1);
  51         }
  52         return handle;
  53 }
  54
  55 void *mk_plugin_load_symbol(void *handler, const char *symbol)
  56 {
  57         char *err;
  58         void *s;
  59
  60         dlerror();
  61         s = dlsym(handler, symbol);
  62         if((err = dlerror()) != NULL){
  63                 return NULL;
  64         }
  65
  66         return s;
  67 }
  68
  69 void mk_plugin_register_add_to_stage(struct plugin **st, struct plugin *p)
  70 {
  71         struct plugin *list;
  72
  73         if(!*st){
  74                 *st = p;
  75                 return;
  76         }
  77
  78         list = *st;
  79
  80         while(list->next){
  81                 list = list->next;
  82         }
  83
  84         list->next = p;
  85 }
  86
  87 void mk_plugin_register_stages(struct plugin *p)
  88 {
  89         struct plugin_list *new, *list;
  90
  91         /* Main plugin list */
  92         new = mk_mem_malloc(sizeof(struct plugin_list));
  93         new->p = p;
  94         new->next = NULL;
  95
  96         if(!plg_list){
  97                 plg_list = new;
  98         }
  99         else{
 100                 list = plg_list;
 101                 while(list->next){
 102                         list = list->next;
 103                 }
 104                 list->next = new;
 105         }
 106
 107         /* Assign plugin to stages */
 108         if(*p->stages & MK_PLUGIN_STAGE_00){
 109                 mk_plugin_register_add_to_stage(&config->plugins->stage_00, p);
 110         }
 111
 112         if(*p->stages & MK_PLUGIN_STAGE_10){
 113                 mk_plugin_register_add_to_stage(&config->plugins->stage_10, p);
 114         }
 115
 116         if(*p->stages & MK_PLUGIN_STAGE_20){
 117                 mk_plugin_register_add_to_stage(&config->plugins->stage_20, p);
 118         }
 119
 120         if(*p->stages & MK_PLUGIN_STAGE_30){
 121                 mk_plugin_register_add_to_stage(&config->plugins->stage_30, p);
 122         }
 123
 124         if(*p->stages & MK_PLUGIN_STAGE_40){
 125                 mk_plugin_register_add_to_stage(&config->plugins->stage_40, p);
 126         }
 127
 128         if(*p->stages & MK_PLUGIN_STAGE_50){
 129                 mk_plugin_register_add_to_stage(&config->plugins->stage_50, p);
 130         }
 131
 132         if(*p->stages & MK_PLUGIN_STAGE_60){
 133                 mk_plugin_register_add_to_stage(&config->plugins->stage_60, p);
 134         }
 135 }
 136
 137 void *mk_plugin_register(void *handler, char *path)
 138 {
 139         struct plugin *p;
 140
 141         p = mk_mem_malloc_z(sizeof(struct plugin));
 142         p->name = mk_plugin_load_symbol(handler, "_name");
 143         p->version = mk_plugin_load_symbol(handler, "_version");
 144         p->path = mk_string_dup(path);
 145         p->handler = handler;
 146         p->stages = (mk_plugin_stage_t *) mk_plugin_load_symbol(handler, "_stages");
 147
 148         /* Plugin external function */
 149         p->call_init = (int (*)()) mk_plugin_load_symbol(handler,
 150                                                          "_mk_plugin_init");
 151
 152         p->call_worker_init = (int (*)()) mk_plugin_load_symbol(handler,
 153                                                                 "_mk_plugin_worker_init");
 154
 155         p->call_stage_10 = (int (*)())
 156                 mk_plugin_load_symbol(handler, "_mk_plugin_stage_00");
 157
 158         p->call_stage_10 = (int (*)())
 159                 mk_plugin_load_symbol(handler, "_mk_plugin_stage_10");
 160
 161         p->call_stage_20 = (int (*)())
 162                 mk_plugin_load_symbol(handler, "_mk_plugin_stage_20");
 163
 164         p->call_stage_30 = (int (*)())
 165                 mk_plugin_load_symbol(handler, "_mk_plugin_stage_30");
 166
 167         p->call_stage_40 = (int (*)())
 168                 mk_plugin_load_symbol(handler, "_mk_plugin_stage_40");
 169
 170         p->next = NULL;
 171
 172         if(!p->name || !p->version || !p->stages){
 173                 mk_mem_free(p);
 174                 return NULL;
 175         }
 176
 177         mk_plugin_register_stages(p);
 178         return p;
 179 }
 180
 181 void mk_plugin_init()
 182 {
 183         char *path;
 184         void *handle;
 185         struct plugin *p;
 186         struct plugin_api *api;
 187         struct mk_config *cnf;
 188
 189         api = mk_mem_malloc_z(sizeof(struct plugin_api));
 190
 191         /* Setup and connections list */
 192         api->config = config;
 193         api->sched_list = &sched_list;
 194
 195         /* API plugins funcions */
 196         api->mem_alloc = (void *) mk_mem_malloc;
 197         api->mem_alloc_z = (void *) mk_mem_malloc_z;
 198         api->mem_free = (void *) mk_mem_free;
 199         api->str_build = (void *) m_build_buffer;
 200         api->str_dup = (void *) mk_string_dup;
 201         api->str_search = (void *) mk_string_search;
 202         api->str_search_n = (void *) mk_string_search_n;
 203         api->str_copy_substr = (void *) mk_string_copy_substr;
 204         api->str_split_line = (void *) mk_string_split_line;
 205         api->file_to_buffer = (void *) mk_file_to_buffer;
 206         api->file_get_info = (void *) mk_file_get_info;
 207         api->header_send = (void *) mk_header_send;
 208         api->iov_create = (void *) mk_iov_create;
 209         api->iov_free = (void *) mk_iov_free;
 210         api->iov_add_entry = (void *) mk_iov_add_entry;
 211         api->iov_set_entry = (void *) mk_iov_set_entry;
 212         api->iov_send = (void *) mk_iov_send;
 213         api->iov_print = (void *) mk_iov_print;
 214         api->pointer_set = (void *) mk_pointer_set;
 215         api->pointer_print = (void *) mk_pointer_print;
 216         api->socket_cork_flag = (void *) mk_socket_set_cork_flag;
 217         api->socket_connect = (void *) mk_socket_connect;
 218         api->socket_set_tcp_nodelay = (void *) mk_socket_set_tcp_nodelay;
 219         api->socket_create = (void *) mk_socket_create;
 220         api->config_create = (void *) mk_config_create;
 221         api->config_free = (void *) mk_config_free;
 222         api->config_getval = (void *) mk_config_getval;
 223         api->sched_get_connection = (void *) mk_sched_get_connection;
 224
 225         path = mk_mem_malloc_z(1024);
 226         snprintf(path, 1024, "%s/%s", config->serverconf, MK_PLUGIN_LOAD);
 227
 228         /* Read configuration file */
 229         cnf = mk_config_create(path);
 230
 231         while(cnf) {
 232                 if(strcasecmp(cnf->key, "LoadPlugin") == 0){
 233                         handle = mk_plugin_load(cnf->val);
 234                         p = mk_plugin_register(handle, cnf->val);
 235                         if(!p){
 236                                 fprintf(stderr, "Plugin error: %s", cnf->val);
 237                                 dlclose(handle);
 238                         }
 239                         else{
 240                                 p->call_init(&api);
 241                         }
 242                 }
 243                 cnf = cnf->next;
 244         }
 245
 246         api->plugins = plg_list;
 247         mk_mem_free(path);
 248 }
 249
 250 int mk_plugin_stage_run(mk_plugin_stage_t stage,
 251                         unsigned int socket,
 252                         struct sched_connection *conx,
 253                         struct client_request *cr,
 254                         struct request *sr)
 255 {
 256         int ret;
 257         struct plugin *p;
 258
 259         if(stage & MK_PLUGIN_STAGE_10){
 260                 p = config->plugins->stage_10;
 261                 while(p){
 262                         p->call_stage_10();
 263                         p = p->next;
 264                 }
 265         }
 266         if(stage & MK_PLUGIN_STAGE_20){
 267                 p = config->plugins->stage_20;
 268                 while(p){
 269                         ret = p->call_stage_20(socket, conx, cr);
 270                         switch(ret){
 271                                 case MK_PLUGIN_RET_CLOSE_CONX:
 272                                         return MK_PLUGIN_RET_CLOSE_CONX;
 273                         }
 274
 275                         p = p->next;
 276                 }
 277         }
 278
 279         if(stage & MK_PLUGIN_STAGE_30){
 280                 p = config->plugins->stage_30;
 281                 while(p){
 282                         ret = p->call_stage_30(cr, sr);
 283                         switch(ret){
 284                                 case MK_PLUGIN_RET_CLOSE_CONX:
 285                                         return MK_PLUGIN_RET_CLOSE_CONX;
 286                         }
 287
 288                         p = p->next;
 289                 }
 290         }
 291
 292         if(stage & MK_PLUGIN_STAGE_40){
 293                 p = config->plugins->stage_40;
 294                 while(p){
 295                         ret = p->call_stage_40(cr, sr);
 296                         if(ret == 0){
 297                                 return 0;
 298                         }
 299                         p = p->next;
 300                 }
 301         }
 302
 303         return -1;
 304 }
 305
 306 /* This function is called by every created worker
 307  * for plugins which need to set some data under a thread
 308  * context
 309  */
 310 void mk_plugin_worker_startup()
 311 {
 312         struct plugin_list *plg;
 313
 314         plg = plg_list;
 315
 316         while(plg){
 317                 if(plg->p->call_worker_init){
 318                         plg->p->call_worker_init();
 319                 }
 320                 plg = plg->next;
 321         }
 322 }