← Back to branch summary

~ubuntu-branches/ubuntu/feisty/lighttpd/feisty

« back to all changes in this revision

Viewing changes to src/mod_cml.c

  • Committer: Bazaar Package Importer
  • Author(s): Krzysztof Krzyzaniak (eloy)
  • Date: 2006-01-16 20:06:39 UTC
  • mto: This revision was merged to the branch mainline in revision 6.
  • Revision ID: james.westby@ubuntu.com-20060116200639-nejjwyvlkgjhzasa
Tags: upstream-1.4.9
Import upstream version 1.4.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mod_cml.c
47
47
                        buffer_free(s->ext);
48
48
                        
49
49
                        buffer_free(s->mc_namespace);
 
50
                        buffer_free(s->power_magnet);
50
51
                        array_free(s->mc_hosts);
51
52
                        
52
53
#if defined(HAVE_MEMCACHE_H)
78
79
                { "cml.extension",              NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },       /* 0 */
79
80
                { "cml.memcache-hosts",         NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION },        /* 1 */
80
81
                { "cml.memcache-namespace",     NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },       /* 2 */
 
82
                { "cml.power-magnet",           NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },       /* 3 */
81
83
                { NULL,                         NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
82
84
        };
83
85
        
92
94
                s->ext    = buffer_init();
93
95
                s->mc_hosts       = array_init();
94
96
                s->mc_namespace   = buffer_init();
 
97
                s->power_magnet   = buffer_init();
95
98
#if defined(HAVE_MEMCACHE_H)
96
99
                s->mc = NULL;
97
100
#endif
99
102
                cv[0].destination = s->ext;
100
103
                cv[1].destination = s->mc_hosts;
101
104
                cv[2].destination = s->mc_namespace;
 
105
                cv[3].destination = s->power_magnet;
102
106
                
103
107
                p->config_storage[i] = s;
104
108
        
144
148
        PATCH(mc);
145
149
#endif
146
150
        PATCH(mc_namespace);
 
151
        PATCH(power_magnet);
147
152
        
148
153
        /* skip the first, the global context */
149
154
        for (i = 1; i < srv->config_context->used; i++) {
165
170
#endif
166
171
                        } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cml.memcache-namespace"))) {
167
172
                                PATCH(mc_namespace);
 
173
                        } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cml.power-magnet"))) {
 
174
                                PATCH(power_magnet);
168
175
                        }
169
176
                }
170
177
        }
289
296
        
290
297
}
291
298
 
292
 
 
293
 
URIHANDLER_FUNC(mod_cml_is_handled) {
294
 
        int ct_len, s_len;
 
299
int cache_call_lua(server *srv, connection *con, plugin_data *p, buffer *cml_file) {
295
300
        buffer *b;
296
301
        char *c;
297
 
        buffer *fn = con->physical.path;
298
 
        plugin_data *p = p_d;
299
302
        int ret;
300
 
        
301
 
        if (fn->used == 0) return HANDLER_ERROR;
302
 
        
303
 
        mod_cml_patch_connection(srv, con, p);
304
 
        
305
 
        buffer_reset(p->basedir);
306
 
        buffer_reset(p->baseurl);
307
 
        buffer_reset(p->session_id);
308
 
        buffer_reset(p->trigger_handler);
309
 
        
310
 
        if (buffer_is_empty(p->conf.ext)) return HANDLER_GO_ON;
311
 
        
312
 
        ct_len = p->conf.ext->used - 1;
313
 
        s_len = fn->used - 1;
314
 
        
315
 
        if (s_len < ct_len) return HANDLER_GO_ON;
316
 
        
317
 
        if (0 != strncmp(fn->ptr + s_len - ct_len, p->conf.ext->ptr, ct_len)) {
318
 
                /* not my job */
319
 
                return HANDLER_GO_ON;
320
 
        }
321
 
        
 
303
 
322
304
        /* cleanup basedir */
323
305
        b = p->baseurl;
324
306
        buffer_copy_string_buffer(b, con->uri.path);
330
312
        }
331
313
        
332
314
        b = p->basedir;
333
 
        buffer_copy_string_buffer(b, fn);
 
315
        buffer_copy_string_buffer(b, con->physical.path);
334
316
        for (c = b->ptr + b->used - 1; c > b->ptr && *c != '/'; c--);
335
317
        
336
318
        if (*c == '/') {
338
320
                *(c+1) = '\0';
339
321
        }
340
322
        
 
323
 
341
324
        /* prepare variables
342
325
         * - session-id
343
326
         *   - cookie-based
346
329
        
347
330
        cache_get_session_id(srv, con, p);
348
331
        
349
 
        ret = cache_parse_lua(srv, con, p, fn);
350
 
        
351
 
        switch(ret) {
 
332
        return cache_parse_lua(srv, con, p, cml_file);
 
333
        
 
334
}
 
335
 
 
336
URIHANDLER_FUNC(mod_cml_power_magnet) {
 
337
        plugin_data *p = p_d;
 
338
        
 
339
        mod_cml_patch_connection(srv, con, p);
 
340
        
 
341
        buffer_reset(p->basedir);
 
342
        buffer_reset(p->baseurl);
 
343
        buffer_reset(p->session_id);
 
344
        buffer_reset(p->trigger_handler);
 
345
 
 
346
        if (buffer_is_empty(p->conf.power_magnet)) return HANDLER_GO_ON;
 
347
        
 
348
        /* 
 
349
         * power-magnet:
 
350
         * cml.power-magnet = server.docroot + "/rewrite.cml"
 
351
         *
 
352
         * is called on EACH request, take the original REQUEST_URI and modifies the
 
353
         * request header as neccesary. 
 
354
         *
 
355
         * First use:
 
356
         * if file_exists("/maintainance.html") {
 
357
         *   output_include = ( "/maintainance.html" )
 
358
         *   return CACHE_HIT 
 
359
         * }
 
360
         *
 
361
         * as we only want to rewrite HTML like requests we should cover it in a conditional
 
362
         * 
 
363
         * */
 
364
 
 
365
        switch(cache_call_lua(srv, con, p, p->conf.power_magnet)) {
 
366
        case -1:
 
367
                /* error */
 
368
                if (con->conf.log_request_handling) {
 
369
                        log_error_write(srv, __FILE__, __LINE__, "s", "cache-error");
 
370
                }
 
371
                con->http_status = 500;
 
372
                return HANDLER_COMEBACK;
 
373
        case 0:
 
374
                if (con->conf.log_request_handling) {
 
375
                        log_error_write(srv, __FILE__, __LINE__, "s", "cache-hit");
 
376
                }
 
377
                /* cache-hit */
 
378
                buffer_reset(con->physical.path);
 
379
                return HANDLER_FINISHED;
 
380
        case 1:
 
381
                /* cache miss */
 
382
                return HANDLER_GO_ON;
 
383
        default:
 
384
                con->http_status = 500;
 
385
                return HANDLER_COMEBACK;
 
386
        }
 
387
}
 
388
 
 
389
URIHANDLER_FUNC(mod_cml_is_handled) {
 
390
        plugin_data *p = p_d;
 
391
        
 
392
        if (buffer_is_empty(con->physical.path)) return HANDLER_ERROR;
 
393
        
 
394
        mod_cml_patch_connection(srv, con, p);
 
395
        
 
396
        buffer_reset(p->basedir);
 
397
        buffer_reset(p->baseurl);
 
398
        buffer_reset(p->session_id);
 
399
        buffer_reset(p->trigger_handler);
 
400
 
 
401
        if (buffer_is_empty(p->conf.ext)) return HANDLER_GO_ON;
 
402
        
 
403
        if (!buffer_is_equal_right_len(con->physical.path, p->conf.ext, p->conf.ext->used - 1)) {
 
404
                return HANDLER_GO_ON;
 
405
        } 
 
406
 
 
407
        switch(cache_call_lua(srv, con, p, con->physical.path)) {
352
408
        case -1:
353
409
                /* error */
354
410
                if (con->conf.log_request_handling) {
369
425
                }
370
426
                /* cache miss */
371
427
                return HANDLER_COMEBACK;
 
428
        default:
 
429
                con->http_status = 500;
 
430
                return HANDLER_COMEBACK;
372
431
        }
373
 
        
374
 
        return 0;
375
432
}
376
433
 
377
434
int mod_cml_plugin_init(plugin *p) {
383
440
        p->set_defaults  = mod_cml_set_defaults;
384
441
        
385
442
        p->handle_subrequest_start = mod_cml_is_handled;
 
443
        p->handle_physical         = mod_cml_power_magnet;
386
444
        
387
445
        p->data        = NULL;
388
446