sup_kilt.c

00001 /*
00002  * Copyright (c) 2005-2012 by KoanLogic s.r.l. <http://www.koanlogic.com>
00003  * All rights reserved.
00004  *
00005  * This file is part of KLone, and as such it is subject to the license stated
00006  * in the LICENSE file which you have received as part of this distribution.
00007  *
00008  * $Id: sup_kilt.c,v 1.1 2008/10/27 21:28:04 tat Exp $
00009  */
00010 
00011 #include "klone_conf.h"
00012 #include <sys/stat.h>
00013 #include <sys/types.h>
00014 #include <unistd.h>
00015 #include <fcntl.h>
00016 #include <regex.h>
00017 #include <klone/supplier.h>
00018 #include <klone/io.h>
00019 #include <klone/utils.h>
00020 #include <klone/request.h>
00021 #include <klone/response.h>
00022 #include <klone/session.h>
00023 #include <klone/kilt.h>
00024 #include <klone/kilt_urls.h>
00025 #include <klone/emb.h>
00026 
00027 typedef struct url_to_ku_s
00028 {
00029     regex_t re;
00030     kilt_url_t *ku;
00031 } url_to_ku_t;
00032 
00033 static url_to_ku_t *url_to_ku = NULL;
00034 
00035 void kilt_run_script(dypage_args_t *args) 
00036 { 
00037     embpage_t *e;
00038     const char *script;
00039 
00040     script = dypage_get_param(args, "script");
00041     crit_err_ifm(script == NULL, "missing 'script' param");
00042 
00043     crit_err_ifm(emb_lookup(script, (embres_t**)&e), 
00044             "script %s not found", script);
00045 
00046     args->fun = e->fun;
00047 
00048     /* run the page code */
00049     e->fun(args);
00050 
00051     return; 
00052 err:
00053     response_set_status(args->rs, HTTP_STATUS_NOT_FOUND); 
00054     return;
00055 }
00056 
00057 void kilt_show_params(dypage_args_t *args) 
00058 { 
00059     io_t *out = response_io(args->rs);
00060     int i;
00061 
00062     io_printf(out, "argc: %u<br>", args->argc);
00063     for(i = 0; i < args->argc; ++i)
00064         io_printf(out, "argv[%d]: %s<br>", i, args->argv[i]);
00065 
00066     io_printf(out, "<p>");
00067 
00068     io_printf(out, "nparams: %u<br>", args->nparams);
00069     for(i = 0; i < args->nparams; ++i)
00070         io_printf(out, "param['%s']: %s<br>", args->params[i].key, 
00071                 args->params[i].val);
00072 
00073     return; 
00074 }
00075 
00076 static int kilt_is_valid_uri(http_t *h, request_t *rq, const char *uri, 
00077         size_t len, void **handle, time_t *mtime)
00078 {
00079     url_to_ku_t *utk;
00080     char url[U_FILENAME_MAX];
00081     int i;
00082 
00083     u_unused_args(h, rq);
00084 
00085     dbg_return_if (uri == NULL, 0);
00086     dbg_return_if (mtime == NULL, 0);
00087     dbg_return_if (len + 1 > U_FILENAME_MAX, 0);
00088     dbg_return_if (url_to_ku == NULL, 0);
00089 
00090     memcpy(url, uri, len);
00091     url[len] = '\0';
00092 
00093     for(i = 0; i < kilt_nurls; ++i)
00094     {
00095         utk = &url_to_ku[i];
00096 
00097         if(regexec(&utk->re, url, 0, NULL, 0) == 0)
00098         {
00099             *handle = (void*)utk;
00100             *mtime = 0;
00101             return 1; /* found */
00102         }
00103     }
00104 
00105     return 0; 
00106 }
00107 
00108 static int kilt_serve(request_t *rq, response_t *rs)
00109 {
00110     url_to_ku_t *utk;
00111     dypage_args_t args;
00112     regmatch_t subs[DYPAGE_MAX_PARAMS + 1];
00113     const char *file_name;
00114     char *argv[DYPAGE_MAX_PARAMS + 1];
00115     int i, argc;
00116     void *handle;
00117 
00118     /* get cached utk pointer (avoid running all regex's on this url again) */
00119     request_get_sup_info(rq, NULL, &handle, NULL);
00120     dbg_err_if(handle == NULL);
00121 
00122     utk = handle;
00123 
00124     file_name = request_get_filename(rq);
00125     dbg_err_if(file_name == NULL);
00126 
00127     dbg_err_if(regexec(&utk->re, file_name, DYPAGE_MAX_PARAMS, subs, 0));
00128 
00129     for(i = 0, argc = 0; subs[i].rm_so != subs[i].rm_eo; ++i, ++argc)
00130     {
00131         argv[i] = u_strndup(file_name + subs[i].rm_so, 
00132                         subs[i].rm_eo - subs[i].rm_so);
00133         dbg_err_if(argv[i] == NULL);
00134     }
00135 
00136     /* set dypage args first */
00137     args.rq = rq;
00138     args.rs = rs;
00139     args.ss = NULL; /* set by dypage_serve */
00140     args.fun = utk->ku->fun;
00141     args.opaque = NULL;
00142 
00143     /* kilt args */
00144 
00145     /* regex submatches */
00146     args.argc = argc;
00147     args.argv = argv;
00148 
00149     /* user provided named arguments */
00150     args.params = utk->ku->params;
00151     for(args.nparams  = 0; args.params[args.nparams].key; ++args.nparams)
00152         continue;
00153 
00154     /* run the function! */
00155     dypage_serve((dypage_args_t*)&args);
00156 
00157     for(i = 0; i < argc; ++i)
00158         u_free(argv[i]);
00159 
00160     return 0;
00161 err:
00162     return ~0;
00163 }
00164 
00165 static int kilt_init(void)
00166 {
00167     kilt_url_t *u;
00168     url_to_ku_t *utk;
00169     int i;
00170 
00171     url_to_ku = u_zalloc( (kilt_nurls + 1) * sizeof(url_to_ku_t));
00172     dbg_err_if(url_to_ku == NULL);
00173 
00174     for(u = kilt_urls, i = 0; i < kilt_nurls; ++u, ++i)
00175     {
00176         utk = &url_to_ku[i];
00177 
00178         /* save the compiled regex in utk.re */
00179         dbg_err_if(regcomp(&utk->re, u->pattern, REG_EXTENDED));
00180 
00181         /* save the ptr to the kilt_url object */
00182         utk->ku = u;
00183 
00184         dbg_err_if(utk->re.re_nsub > DYPAGE_MAX_PARAMS);
00185     }
00186 
00187     return 0;
00188 err:
00189     return ~0;
00190 }
00191 
00192 static void kilt_term(void)
00193 {
00194     url_to_ku_t *utk;
00195     int i;
00196 
00197     if(url_to_ku)
00198     {
00199         for(i = 0; i < kilt_nurls; ++i)
00200         {
00201             utk = &url_to_ku[i];
00202             regfree(&utk->re);
00203         }
00204         u_free(url_to_ku); url_to_ku = NULL;
00205     }
00206 
00207     return;
00208 }
00209 
00210 supplier_t sup_kilt = {
00211     "kilt supplier",
00212     kilt_init,
00213     kilt_term,
00214     kilt_is_valid_uri,
00215     kilt_serve
00216 };
00217 

←Products
Copyright © 2005-2012 - KoanLogic S.r.l. - All rights reserved