One Level Up Top Level

src/http/modules/perl/ngx_http_perl_module.c - nginx-1.7.10

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>
  11. #include <ngx_http_perl_module.h>


  14. typedef struct {
  15.     PerlInterpreter   *perl;
  16.     HV                *nginx;
  17.     ngx_array_t       *modules;
  18.     ngx_array_t       *requires;
  19. ‌} ngx_http_perl_main_conf_t;


  22. typedef struct {
  23.     SV                *sub;
  24.     ngx_str_t          handler;
  25. ‌} ngx_http_perl_loc_conf_t;


  28. typedef struct {
  29.     SV                *sub;
  30.     ngx_str_t          handler;
  31. ‌} ngx_http_perl_variable_t;


  34. #if (NGX_HTTP_SSI)
  35. static ngx_int_t ngx_http_perl_ssi(ngx_http_request_t *r,
  36.     ngx_http_ssi_ctx_t *ssi_ctx, ngx_str_t **params);
  37. #endif

  39. static char *ngx_http_perl_init_interpreter(ngx_conf_t *cf,
  40.     ngx_http_perl_main_conf_t *pmcf);
  41. static PerlInterpreter *ngx_http_perl_create_interpreter(ngx_conf_t *cf,
  42.     ngx_http_perl_main_conf_t *pmcf);
  43. static ngx_int_t ngx_http_perl_run_requires(pTHX_ ngx_array_t *requires,
  44.     ngx_log_t *log);
  45. static ngx_int_t ngx_http_perl_call_handler(pTHX_ ngx_http_request_t *r,
  46.     HV *nginx, SV *sub, SV **args, ngx_str_t *handler, ngx_str_t *rv);
  47. static void ngx_http_perl_eval_anon_sub(pTHX_ ngx_str_t *handler, SV **sv);

  49. static ngx_int_t ngx_http_perl_preconfiguration(ngx_conf_t *cf);
  50. static void *ngx_http_perl_create_main_conf(ngx_conf_t *cf);
  51. static char *ngx_http_perl_init_main_conf(ngx_conf_t *cf, void *conf);
  52. static void *ngx_http_perl_create_loc_conf(ngx_conf_t *cf);
  53. static char *ngx_http_perl_merge_loc_conf(ngx_conf_t *cf, void *parent,
  54.     void *child);
  55. static char *ngx_http_perl(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  56. static char *ngx_http_perl_set(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);

  58. #if (NGX_HAVE_PERL_MULTIPLICITY)
  59. static void ngx_http_perl_cleanup_perl(void *data);
  60. #endif

  62. static ngx_int_t ngx_http_perl_init_worker(ngx_cycle_t *cycle);
  63. static void ngx_http_perl_exit(ngx_cycle_t *cycle);


  66. ‌static ngx_command_t  ngx_http_perl_commands[] = {

  68.     { ngx_string("perl_modules"),
  69.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  70.       ngx_conf_set_str_array_slot,
  71.       NGX_HTTP_MAIN_CONF_OFFSET,
  72.       offsetof(ngx_http_perl_main_conf_t, modules),
  73.       NULL },

  75.     { ngx_string("perl_require"),
  76.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  77.       ngx_conf_set_str_array_slot,
  78.       NGX_HTTP_MAIN_CONF_OFFSET,
  79.       offsetof(ngx_http_perl_main_conf_t, requires),
  80.       NULL },

  82.     { ngx_string("perl"),
  83.       NGX_HTTP_LOC_CONF|NGX_HTTP_LMT_CONF|NGX_CONF_TAKE1,
  84.       ngx_http_perl,
  85.       NGX_HTTP_LOC_CONF_OFFSET,
  86.       0,
  87.       NULL },

  89.     { ngx_string("perl_set"),
  90.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE2,
  91.       ngx_http_perl_set,
  92.       NGX_HTTP_LOC_CONF_OFFSET,
  93.       0,
  94.       NULL },

  96.       ngx_null_command
  97. };


  100. ‌static ngx_http_module_t  ngx_http_perl_module_ctx = {
  101.     ngx_http_perl_preconfiguration,        /* preconfiguration */
  102.     NULL,                                  /* postconfiguration */

  104.     ngx_http_perl_create_main_conf,        /* create main configuration */
  105.     ngx_http_perl_init_main_conf,          /* init main configuration */

  107.     NULL,                                  /* create server configuration */
  108.     NULL,                                  /* merge server configuration */

  110.     ngx_http_perl_create_loc_conf,         /* create location configuration */
  111.     ngx_http_perl_merge_loc_conf           /* merge location configuration */
  112. };


  115. ‌ngx_module_t  ngx_http_perl_module = {
  116.     NGX_MODULE_V1,
  117.     &ngx_http_perl_module_ctx,             /* module context */
  118.     ngx_http_perl_commands,                /* module directives */
  119.     NGX_HTTP_MODULE,                       /* module type */
  120.     NULL,                                  /* init master */
  121.     NULL,                                  /* init module */
  122.     ngx_http_perl_init_worker,             /* init process */
  123.     NULL,                                  /* init thread */
  124.     NULL,                                  /* exit thread */
  125.     NULL,                                  /* exit process */
  126.     ngx_http_perl_exit,                    /* exit master */
  127.     NGX_MODULE_V1_PADDING
  128. };


  131. #if (NGX_HTTP_SSI)

  133. ‌#define NGX_HTTP_PERL_SSI_SUB  0
  134. ‌#define NGX_HTTP_PERL_SSI_ARG  1


  137. ‌static ngx_http_ssi_param_t  ngx_http_perl_ssi_params[] = {
  138.     { ngx_string("sub"), NGX_HTTP_PERL_SSI_SUB, 1, 0 },
  139.     { ngx_string("arg"), NGX_HTTP_PERL_SSI_ARG, 0, 1 },
  140.     { ngx_null_string, 0, 0, 0 }
  141. };

  143. ‌static ngx_http_ssi_command_t  ngx_http_perl_ssi_command = {
  144.     ngx_string("perl"), ngx_http_perl_ssi, ngx_http_perl_ssi_params, 0, 0, 1
  145. };

  147. #endif


  150. ‌static ngx_str_t         ngx_null_name = ngx_null_string;
  151. ‌static HV               *nginx_stash;

  153. #if (NGX_HAVE_PERL_MULTIPLICITY)
  154. ‌static ngx_uint_t        ngx_perl_term;
  155. #else
  156. ‌static PerlInterpreter  *perl;
  157. #endif


  160. static void
  161. ‌ngx_http_perl_xs_init(pTHX)
  162. {
  163.     newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, __FILE__);

  165.     nginx_stash = gv_stashpv("nginx", TRUE);
  166. }


  169. static ngx_int_t
  170. ‌ngx_http_perl_handler(ngx_http_request_t *r)
  171. {
  172.     r->main->count++;

  174.     ngx_http_perl_handle_request(r);

  176.     return NGX_DONE;
  177. }


  180. void
  181. ‌ngx_http_perl_handle_request(ngx_http_request_t *r)
  182. {
  183.     SV                         *sub;
  184.     ngx_int_t                   rc;
  185.     ngx_str_t                   uri, args, *handler;
  186.     ngx_http_perl_ctx_t        *ctx;
  187.     ngx_http_perl_loc_conf_t   *plcf;
  188.     ngx_http_perl_main_conf_t  *pmcf;

  190.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "perl handler");

  192.     ctx = ngx_http_get_module_ctx(r, ngx_http_perl_module);

  194.     if (ctx == NULL) {
  195.         ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_perl_ctx_t));
  196.         if (ctx == NULL) {
  197.             ngx_http_finalize_request(r, NGX_ERROR);
  198.             return;
  199.         }

  201.         ngx_http_set_ctx(r, ctx, ngx_http_perl_module);
  202.     }

  204.     pmcf = ngx_http_get_module_main_conf(r, ngx_http_perl_module);

  206.     {

  208.     dTHXa(pmcf->perl);
  209.     PERL_SET_CONTEXT(pmcf->perl);

  211.     if (ctx->next == NULL) {
  212.         plcf = ngx_http_get_module_loc_conf(r, ngx_http_perl_module);
  213.         sub = plcf->sub;
  214.         handler = &plcf->handler;

  216.     } else {
  217.         sub = ctx->next;
  218.         handler = &ngx_null_name;
  219.         ctx->next = NULL;
  220.     }

  222.     rc = ngx_http_perl_call_handler(aTHX_ r, pmcf->nginx, sub, NULL, handler,
  223.                                     NULL);

  225.     }

  227.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  228.                    "perl handler done: %i", rc);

  230.     if (rc == NGX_DONE) {
  231.         ngx_http_finalize_request(r, rc);
  232.         return;
  233.     }

  235.     if (rc > 600) {
  236.         rc = NGX_OK;
  237.     }

  239.     if (ctx->redirect_uri.len) {
  240.         uri = ctx->redirect_uri;
  241.         args = ctx->redirect_args;

  243.     } else {
  244.         uri.len = 0;
  245.     }

  247.     ctx->filename.data = NULL;
  248.     ctx->redirect_uri.len = 0;

  250.     if (ctx->done || ctx->next) {
  251.         ngx_http_finalize_request(r, NGX_DONE);
  252.         return;
  253.     }

  255.     if (uri.len) {
  256.         ngx_http_internal_redirect(r, &uri, &args);
  257.         ngx_http_finalize_request(r, NGX_DONE);
  258.         return;
  259.     }

  261.     if (rc == NGX_OK || rc == NGX_HTTP_OK) {
  262.         ngx_http_send_special(r, NGX_HTTP_LAST);
  263.         ctx->done = 1;
  264.     }

  266.     ngx_http_finalize_request(r, rc);
  267. }


  270. void
  271. ‌ngx_http_perl_sleep_handler(ngx_http_request_t *r)
  272. {
  273.     ngx_event_t  *wev;

  275.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  276.                    "perl sleep handler");

  278.     wev = r->connection->write;

  280.     if (wev->timedout) {
  281.         wev->timedout = 0;
  282.         ngx_http_perl_handle_request(r);
  283.         return;
  284.     }

  286.     if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  287.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  288.     }
  289. }


  292. static ngx_int_t
  293. ‌ngx_http_perl_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  294.     uintptr_t data)
  295. {
  296.     ngx_http_perl_variable_t *pv = (ngx_http_perl_variable_t *) data;

  298.     ngx_int_t                   rc;
  299.     ngx_str_t                   value;
  300.     ngx_http_perl_ctx_t        *ctx;
  301.     ngx_http_perl_main_conf_t  *pmcf;

  303.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  304.                    "perl variable handler");

  306.     ctx = ngx_http_get_module_ctx(r, ngx_http_perl_module);

  308.     if (ctx == NULL) {
  309.         ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_perl_ctx_t));
  310.         if (ctx == NULL) {
  311.             return NGX_ERROR;
  312.         }

  314.         ngx_http_set_ctx(r, ctx, ngx_http_perl_module);
  315.     }

  317.     pmcf = ngx_http_get_module_main_conf(r, ngx_http_perl_module);

  319.     value.data = NULL;

  321.     {

  323.     dTHXa(pmcf->perl);
  324.     PERL_SET_CONTEXT(pmcf->perl);

  326.     rc = ngx_http_perl_call_handler(aTHX_ r, pmcf->nginx, pv->sub, NULL,
  327.                                     &pv->handler, &value);

  329.     }

  331.     if (value.data) {
  332.         v->len = value.len;
  333.         v->valid = 1;
  334.         v->no_cacheable = 0;
  335.         v->not_found = 0;
  336.         v->data = value.data;

  338.     } else {
  339.         v->not_found = 1;
  340.     }

  342.     ctx->filename.data = NULL;
  343.     ctx->redirect_uri.len = 0;

  345.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  346.                    "perl variable done");

  348.     return rc;
  349. }


  352. #if (NGX_HTTP_SSI)

  354. static ngx_int_t
  355. ‌ngx_http_perl_ssi(ngx_http_request_t *r, ngx_http_ssi_ctx_t *ssi_ctx,
  356.     ngx_str_t **params)
  357. {
  358.     SV                         *sv, **asv;
  359.     ngx_int_t                   rc;
  360.     ngx_str_t                  *handler, **args;
  361.     ngx_uint_t                  i;
  362.     ngx_http_perl_ctx_t        *ctx;
  363.     ngx_http_perl_main_conf_t  *pmcf;

  365.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  366.                    "perl ssi handler");

  368.     ctx = ngx_http_get_module_ctx(r, ngx_http_perl_module);

  370.     if (ctx == NULL) {
  371.         ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_perl_ctx_t));
  372.         if (ctx == NULL) {
  373.             return NGX_ERROR;
  374.         }

  376.         ngx_http_set_ctx(r, ctx, ngx_http_perl_module);
  377.     }

  379.     pmcf = ngx_http_get_module_main_conf(r, ngx_http_perl_module);

  381.     ctx->ssi = ssi_ctx;

  383.     handler = params[NGX_HTTP_PERL_SSI_SUB];
  384.     handler->data[handler->len] = '\0';

  386.     {

  388.     dTHXa(pmcf->perl);
  389.     PERL_SET_CONTEXT(pmcf->perl);

  391. #if 0

  393.     /* the code is disabled to force the precompiled perl code using only */

  395.     ngx_http_perl_eval_anon_sub(aTHX_ handler, &sv);

  397.     if (sv == &PL_sv_undef) {
  398.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  399.                       "eval_pv(\"%V\") failed", handler);
  400.         return NGX_ERROR;
  401.     }

  403.     if (sv == NULL) {
  404.         sv = newSVpvn((char *) handler->data, handler->len);
  405.     }

  407. #endif

  409.     sv = newSVpvn((char *) handler->data, handler->len);

  411.     args = &params[NGX_HTTP_PERL_SSI_ARG];

  413.     if (args) {

  415.         for (i = 0; args[i]; i++) { /* void */ }

  417.         asv = ngx_pcalloc(r->pool, (i + 1) * sizeof(SV *));

  419.         if (asv == NULL) {
  420.             SvREFCNT_dec(sv);
  421.             return NGX_ERROR;
  422.         }

  424.         asv[0] = (SV *) (uintptr_t) i;

  426.         for (i = 0; args[i]; i++) {
  427.             asv[i + 1] = newSVpvn((char *) args[i]->data, args[i]->len);
  428.         }

  430.     } else {
  431.         asv = NULL;
  432.     }

  434.     rc = ngx_http_perl_call_handler(aTHX_ r, pmcf->nginx, sv, asv, handler,
  435.                                     NULL);

  437.     SvREFCNT_dec(sv);

  439.     }

  441.     ctx->filename.data = NULL;
  442.     ctx->redirect_uri.len = 0;
  443.     ctx->ssi = NULL;

  445.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "perl ssi done");

  447.     return rc;
  448. }

  450. #endif


  453. static char *
  454. ‌ngx_http_perl_init_interpreter(ngx_conf_t *cf, ngx_http_perl_main_conf_t *pmcf)
  455. {
  456.     ngx_str_t           *m;
  457.     ngx_uint_t           i;
  458. #if (NGX_HAVE_PERL_MULTIPLICITY)
  459.     ngx_pool_cleanup_t  *cln;

  461.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  462.     if (cln == NULL) {
  463.         return NGX_CONF_ERROR;
  464.     }

  466. #endif

  468. #ifdef NGX_PERL_MODULES
  469.     if (pmcf->modules == NGX_CONF_UNSET_PTR) {

  471.         pmcf->modules = ngx_array_create(cf->pool, 1, sizeof(ngx_str_t));
  472.         if (pmcf->modules == NULL) {
  473.             return NGX_CONF_ERROR;
  474.         }

  476.         m = ngx_array_push(pmcf->modules);
  477.         if (m == NULL) {
  478.             return NGX_CONF_ERROR;
  479.         }

  481.         ngx_str_set(m, NGX_PERL_MODULES);
  482.     }
  483. #endif

  485.     if (pmcf->modules != NGX_CONF_UNSET_PTR) {
  486.         m = pmcf->modules->elts;
  487.         for (i = 0; i < pmcf->modules->nelts; i++) {
  488.             if (ngx_conf_full_name(cf->cycle, &m[i], 0) != NGX_OK) {
  489.                 return NGX_CONF_ERROR;
  490.             }
  491.         }
  492.     }

  494. #if !(NGX_HAVE_PERL_MULTIPLICITY)

  496.     if (perl) {

  498.         if (ngx_set_environment(cf->cycle, NULL) == NULL) {
  499.             return NGX_CONF_ERROR;
  500.         }

  502.         if (ngx_http_perl_run_requires(aTHX_ pmcf->requires, cf->log)
  503.             != NGX_OK)
  504.         {
  505.             return NGX_CONF_ERROR;
  506.         }

  508.         pmcf->perl = perl;
  509.         pmcf->nginx = nginx_stash;

  511.         return NGX_CONF_OK;
  512.     }

  514. #endif

  516.     if (nginx_stash == NULL) {
  517.         PERL_SYS_INIT(&ngx_argc, &ngx_argv);
  518.     }

  520.     pmcf->perl = ngx_http_perl_create_interpreter(cf, pmcf);

  522.     if (pmcf->perl == NULL) {
  523.         return NGX_CONF_ERROR;
  524.     }

  526.     pmcf->nginx = nginx_stash;

  528. #if (NGX_HAVE_PERL_MULTIPLICITY)

  530.     cln->handler = ngx_http_perl_cleanup_perl;
  531.     cln->data = pmcf->perl;

  533. #else

  535.     perl = pmcf->perl;

  537. #endif

  539.     return NGX_CONF_OK;
  540. }


  543. static PerlInterpreter *
  544. ‌ngx_http_perl_create_interpreter(ngx_conf_t *cf,
  545.     ngx_http_perl_main_conf_t *pmcf)
  546. {
  547.     int                n;
  548.     STRLEN             len;
  549.     SV                *sv;
  550.     char              *ver, **embedding;
  551.     ngx_str_t         *m;
  552.     ngx_uint_t         i;
  553.     PerlInterpreter   *perl;

  555.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0, "create perl interpreter");

  557.     if (ngx_set_environment(cf->cycle, NULL) == NULL) {
  558.         return NULL;
  559.     }

  561.     perl = perl_alloc();
  562.     if (perl == NULL) {
  563.         ngx_log_error(NGX_LOG_ALERT, cf->log, 0, "perl_alloc() failed");
  564.         return NULL;
  565.     }

  567.     {

  569.     dTHXa(perl);
  570.     PERL_SET_CONTEXT(perl);

  572.     perl_construct(perl);

  574. #ifdef PERL_EXIT_DESTRUCT_END
  575.     PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
  576. #endif

  578.     n = (pmcf->modules != NGX_CONF_UNSET_PTR) ? pmcf->modules->nelts * 2 : 0;

  580.     embedding = ngx_palloc(cf->pool, (5 + n) * sizeof(char *));
  581.     if (embedding == NULL) {
  582.         goto fail;
  583.     }

  585.     embedding[0] = "";

  587.     if (n++) {
  588.         m = pmcf->modules->elts;
  589.         for (i = 0; i < pmcf->modules->nelts; i++) {
  590.             embedding[2 * i + 1] = "-I";
  591.             embedding[2 * i + 2] = (char *) m[i].data;
  592.         }
  593.     }

  595.     embedding[n++] = "-Mnginx";
  596.     embedding[n++] = "-e";
  597.     embedding[n++] = "0";
  598.     embedding[n] = NULL;

  600.     n = perl_parse(perl, ngx_http_perl_xs_init, n, embedding, NULL);

  602.     if (n != 0) {
  603.         ngx_log_error(NGX_LOG_ALERT, cf->log, 0, "perl_parse() failed: %d", n);
  604.         goto fail;
  605.     }

  607.     sv = get_sv("nginx::VERSION", FALSE);
  608.     ver = SvPV(sv, len);

  610.     if (ngx_strcmp(ver, NGINX_VERSION) != 0) {
  611.         ngx_log_error(NGX_LOG_ALERT, cf->log, 0,
  612.                       "version " NGINX_VERSION " of nginx.pm is required, "
  613.                       "but %s was found", ver);
  614.         goto fail;
  615.     }

  617.     if (ngx_http_perl_run_requires(aTHX_ pmcf->requires, cf->log) != NGX_OK) {
  618.         goto fail;
  619.     }

  621.     }

  623.     return perl;

  625. fail:

  627.     (void) perl_destruct(perl);

  629.     perl_free(perl);

  631.     return NULL;
  632. }


  635. static ngx_int_t
  636. ‌ngx_http_perl_run_requires(pTHX_ ngx_array_t *requires, ngx_log_t *log)
  637. {
  638.     u_char      *err;
  639.     STRLEN       len;
  640.     ngx_str_t   *script;
  641.     ngx_uint_t   i;

  643.     if (requires == NGX_CONF_UNSET_PTR) {
  644.         return NGX_OK;
  645.     }

  647.     script = requires->elts;
  648.     for (i = 0; i < requires->nelts; i++) {

  650.         require_pv((char *) script[i].data);

  652.         if (SvTRUE(ERRSV)) {

  654.             err = (u_char *) SvPV(ERRSV, len);
  655.             while (--len && (err[len] == CR || err[len] == LF)) { /* void */ }

  657.             ngx_log_error(NGX_LOG_EMERG, log, 0,
  658.                           "require_pv(\"%s\") failed: \"%*s\"",
  659.                           script[i].data, len + 1, err);

  661.             return NGX_ERROR;
  662.         }
  663.     }

  665.     return NGX_OK;
  666. }


  669. static ngx_int_t
  670. ‌ngx_http_perl_call_handler(pTHX_ ngx_http_request_t *r, HV *nginx, SV *sub,
  671.     SV **args, ngx_str_t *handler, ngx_str_t *rv)
  672. {
  673.     SV                *sv;
  674.     int                n, status;
  675.     char              *line;
  676.     u_char            *err;
  677.     STRLEN             len, n_a;
  678.     ngx_uint_t         i;
  679.     ngx_connection_t  *c;

  681.     dSP;

  683.     status = 0;

  685.     ENTER;
  686.     SAVETMPS;

  688.     PUSHMARK(sp);

  690.     sv = sv_2mortal(sv_bless(newRV_noinc(newSViv(PTR2IV(r))), nginx));
  691.     XPUSHs(sv);

  693.     if (args) {
  694.         EXTEND(sp, (intptr_t) args[0]);

  696.         for (i = 1; i <= (uintptr_t) args[0]; i++) {
  697.             PUSHs(sv_2mortal(args[i]));
  698.         }
  699.     }

  701.     PUTBACK;

  703.     c = r->connection;

  705.     n = call_sv(sub, G_EVAL);

  707.     SPAGAIN;

  709.     if (n) {
  710.         if (rv == NULL) {
  711.             status = POPi;

  713.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  714.                            "call_sv: %d", status);

  716.         } else {
  717.             line = SvPVx(POPs, n_a);
  718.             rv->len = n_a;

  720.             rv->data = ngx_pnalloc(r->pool, n_a);
  721.             if (rv->data == NULL) {
  722.                 return NGX_ERROR;
  723.             }

  725.             ngx_memcpy(rv->data, line, n_a);
  726.         }
  727.     }

  729.     PUTBACK;

  731.     FREETMPS;
  732.     LEAVE;

  734.     /* check $@ */

  736.     if (SvTRUE(ERRSV)) {

  738.         err = (u_char *) SvPV(ERRSV, len);
  739.         while (--len && (err[len] == CR || err[len] == LF)) { /* void */ }

  741.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  742.                       "call_sv(\"%V\") failed: \"%*s\"", handler, len + 1, err);

  744.         if (rv) {
  745.             return NGX_ERROR;
  746.         }

  748.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  749.     }

  751.     if (n != 1) {
  752.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  753.                       "call_sv(\"%V\") returned %d results", handler, n);
  754.         status = NGX_OK;
  755.     }

  757.     if (rv) {
  758.         return NGX_OK;
  759.     }

  761.     return (ngx_int_t) status;
  762. }


  765. static void
  766. ‌ngx_http_perl_eval_anon_sub(pTHX_ ngx_str_t *handler, SV **sv)
  767. {
  768.     u_char  *p;

  770.     for (p = handler->data; *p; p++) {
  771.         if (*p != ' ' && *p != '\t' && *p != CR && *p != LF) {
  772.             break;
  773.         }
  774.     }

  776.     if (ngx_strncmp(p, "sub ", 4) == 0
  777.         || ngx_strncmp(p, "sub{", 4) == 0
  778.         || ngx_strncmp(p, "use ", 4) == 0)
  779.     {
  780.         *sv = eval_pv((char *) p, FALSE);

  782.         /* eval_pv() does not set ERRSV on failure */

  784.         return;
  785.     }

  787.     *sv = NULL;
  788. }


  791. static void *
  792. ‌ngx_http_perl_create_main_conf(ngx_conf_t *cf)
  793. {
  794.     ngx_http_perl_main_conf_t  *pmcf;

  796.     pmcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_perl_main_conf_t));
  797.     if (pmcf == NULL) {
  798.         return NULL;
  799.     }

  801.     pmcf->modules = NGX_CONF_UNSET_PTR;
  802.     pmcf->requires = NGX_CONF_UNSET_PTR;

  804.     return pmcf;
  805. }


  808. static char *
  809. ‌ngx_http_perl_init_main_conf(ngx_conf_t *cf, void *conf)
  810. {
  811.     ngx_http_perl_main_conf_t *pmcf = conf;

  813.     if (pmcf->perl == NULL) {
  814.         if (ngx_http_perl_init_interpreter(cf, pmcf) != NGX_CONF_OK) {
  815.             return NGX_CONF_ERROR;
  816.         }
  817.     }

  819.     return NGX_CONF_OK;
  820. }


  823. #if (NGX_HAVE_PERL_MULTIPLICITY)

  825. static void
  826. ‌ngx_http_perl_cleanup_perl(void *data)
  827. {
  828.     PerlInterpreter  *perl = data;

  830.     PERL_SET_CONTEXT(perl);

  832.     (void) perl_destruct(perl);

  834.     perl_free(perl);

  836.     if (ngx_perl_term) {
  837.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0, "perl term");

  839.         PERL_SYS_TERM();
  840.     }
  841. }

  843. #endif


  846. static ngx_int_t
  847. ‌ngx_http_perl_preconfiguration(ngx_conf_t *cf)
  848. {
  849. #if (NGX_HTTP_SSI)
  850.     ngx_int_t                  rc;
  851.     ngx_http_ssi_main_conf_t  *smcf;

  853.     smcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_ssi_filter_module);

  855.     rc = ngx_hash_add_key(&smcf->commands, &ngx_http_perl_ssi_command.name,
  856.                           &ngx_http_perl_ssi_command, NGX_HASH_READONLY_KEY);

  858.     if (rc != NGX_OK) {
  859.         if (rc == NGX_BUSY) {
  860.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  861.                                "conflicting SSI command \"%V\"",
  862.                                &ngx_http_perl_ssi_command.name);
  863.         }

  865.         return NGX_ERROR;
  866.     }
  867. #endif

  869.     return NGX_OK;
  870. }


  873. static void *
  874. ‌ngx_http_perl_create_loc_conf(ngx_conf_t *cf)
  875. {
  876.     ngx_http_perl_loc_conf_t *plcf;

  878.     plcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_perl_loc_conf_t));
  879.     if (plcf == NULL) {
  880.         return NULL;
  881.     }

  883.     /*
  884.      * set by ngx_pcalloc():
  885.      *
  886.      *     plcf->handler = { 0, NULL };
  887.      */

  889.     return plcf;
  890. }


  893. static char *
  894. ‌ngx_http_perl_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  895. {
  896.     ngx_http_perl_loc_conf_t *prev = parent;
  897.     ngx_http_perl_loc_conf_t *conf = child;

  899.     if (conf->sub == NULL) {
  900.         conf->sub = prev->sub;
  901.         conf->handler = prev->handler;
  902.     }

  904.     return NGX_CONF_OK;
  905. }


  908. static char *
  909. ‌ngx_http_perl(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  910. {
  911.     ngx_http_perl_loc_conf_t *plcf = conf;

  913.     ngx_str_t                  *value;
  914.     ngx_http_core_loc_conf_t   *clcf;
  915.     ngx_http_perl_main_conf_t  *pmcf;

  917.     value = cf->args->elts;

  919.     if (plcf->handler.data) {
  920.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  921.                            "duplicate perl handler \"%V\"", &value[1]);
  922.         return NGX_CONF_ERROR;
  923.     }

  925.     pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_perl_module);

  927.     if (pmcf->perl == NULL) {
  928.         if (ngx_http_perl_init_interpreter(cf, pmcf) != NGX_CONF_OK) {
  929.             return NGX_CONF_ERROR;
  930.         }
  931.     }

  933.     plcf->handler = value[1];

  935.     {

  937.     dTHXa(pmcf->perl);
  938.     PERL_SET_CONTEXT(pmcf->perl);

  940.     ngx_http_perl_eval_anon_sub(aTHX_ &value[1], &plcf->sub);

  942.     if (plcf->sub == &PL_sv_undef) {
  943.         ngx_conf_log_error(NGX_LOG_ERR, cf, 0,
  944.                            "eval_pv(\"%V\") failed", &value[1]);
  945.         return NGX_CONF_ERROR;
  946.     }

  948.     if (plcf->sub == NULL) {
  949.         plcf->sub = newSVpvn((char *) value[1].data, value[1].len);
  950.     }

  952.     }

  954.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  955.     clcf->handler = ngx_http_perl_handler;

  957.     return NGX_CONF_OK;
  958. }


  961. static char *
  962. ‌ngx_http_perl_set(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  963. {
  964.     ngx_int_t                   index;
  965.     ngx_str_t                  *value;
  966.     ngx_http_variable_t        *v;
  967.     ngx_http_perl_variable_t   *pv;
  968.     ngx_http_perl_main_conf_t  *pmcf;

  970.     value = cf->args->elts;

  972.     if (value[1].data[0] != '$') {
  973.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  974.                            "invalid variable name \"%V\"", &value[1]);
  975.         return NGX_CONF_ERROR;
  976.     }

  978.     value[1].len--;
  979.     value[1].data++;

  981.     v = ngx_http_add_variable(cf, &value[1], NGX_HTTP_VAR_CHANGEABLE);
  982.     if (v == NULL) {
  983.         return NGX_CONF_ERROR;
  984.     }

  986.     pv = ngx_palloc(cf->pool, sizeof(ngx_http_perl_variable_t));
  987.     if (pv == NULL) {
  988.         return NGX_CONF_ERROR;
  989.     }

  991.     index = ngx_http_get_variable_index(cf, &value[1]);
  992.     if (index == NGX_ERROR) {
  993.         return NGX_CONF_ERROR;
  994.     }

  996.     pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_perl_module);

  998.     if (pmcf->perl == NULL) {
  999.         if (ngx_http_perl_init_interpreter(cf, pmcf) != NGX_CONF_OK) {
  1000.             return NGX_CONF_ERROR;
  1001.         }
  1002.     }

  1004.     pv->handler = value[2];

  1006.     {

  1008.     dTHXa(pmcf->perl);
  1009.     PERL_SET_CONTEXT(pmcf->perl);

  1011.     ngx_http_perl_eval_anon_sub(aTHX_ &value[2], &pv->sub);

  1013.     if (pv->sub == &PL_sv_undef) {
  1014.         ngx_conf_log_error(NGX_LOG_ERR, cf, 0,
  1015.                            "eval_pv(\"%V\") failed", &value[2]);
  1016.         return NGX_CONF_ERROR;
  1017.     }

  1019.     if (pv->sub == NULL) {
  1020.         pv->sub = newSVpvn((char *) value[2].data, value[2].len);
  1021.     }

  1023.     }

  1025.     v->get_handler = ngx_http_perl_variable;
  1026.     v->data = (uintptr_t) pv;

  1028.     return NGX_CONF_OK;
  1029. }


  1032. static ngx_int_t
  1033. ‌ngx_http_perl_init_worker(ngx_cycle_t *cycle)
  1034. {
  1035.     ngx_http_perl_main_conf_t  *pmcf;

  1037.     pmcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_perl_module);

  1039.     if (pmcf) {
  1040.         dTHXa(pmcf->perl);
  1041.         PERL_SET_CONTEXT(pmcf->perl);

  1043.         /* set worker's $$ */

  1045.         sv_setiv(GvSV(gv_fetchpv("$", TRUE, SVt_PV)), (I32) ngx_pid);
  1046.     }

  1048.     return NGX_OK;
  1049. }


  1052. static void
  1053. ‌ngx_http_perl_exit(ngx_cycle_t *cycle)
  1054. {
  1055. #if (NGX_HAVE_PERL_MULTIPLICITY)

  1057.     /*
  1058.      * the master exit hook is run before global pool cleanup,
  1059.      * therefore just set flag here
  1060.      */

  1062.     ngx_perl_term = 1;

  1064. #else

  1066.     if (nginx_stash) {
  1067.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cycle->log, 0, "perl term");

  1069.         (void) perl_destruct(perl);

  1071.         perl_free(perl);

  1073.         PERL_SYS_TERM();
  1074.     }

  1076. #endif
  1077. }

One Level Up Top Level