One Level Up Top Level

src/http/modules/ngx_http_memcached_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>


  13. typedef struct {
  14.     ngx_http_upstream_conf_t   upstream;
  15.     ngx_int_t                  index;
  16.     ngx_uint_t                 gzip_flag;
  17. ‌} ngx_http_memcached_loc_conf_t;


  20. typedef struct {
  21.     size_t                     rest;
  22.     ngx_http_request_t        *request;
  23.     ngx_str_t                  key;
  24. ‌} ngx_http_memcached_ctx_t;


  27. static ngx_int_t ngx_http_memcached_create_request(ngx_http_request_t *r);
  28. static ngx_int_t ngx_http_memcached_reinit_request(ngx_http_request_t *r);
  29. static ngx_int_t ngx_http_memcached_process_header(ngx_http_request_t *r);
  30. static ngx_int_t ngx_http_memcached_filter_init(void *data);
  31. static ngx_int_t ngx_http_memcached_filter(void *data, ssize_t bytes);
  32. static void ngx_http_memcached_abort_request(ngx_http_request_t *r);
  33. static void ngx_http_memcached_finalize_request(ngx_http_request_t *r,
  34.     ngx_int_t rc);

  36. static void *ngx_http_memcached_create_loc_conf(ngx_conf_t *cf);
  37. static char *ngx_http_memcached_merge_loc_conf(ngx_conf_t *cf,
  38.     void *parent, void *child);

  40. static char *ngx_http_memcached_pass(ngx_conf_t *cf, ngx_command_t *cmd,
  41.     void *conf);


  44. ‌static ngx_conf_bitmask_t  ngx_http_memcached_next_upstream_masks[] = {
  45.     { ngx_string("error"), NGX_HTTP_UPSTREAM_FT_ERROR },
  46.     { ngx_string("timeout"), NGX_HTTP_UPSTREAM_FT_TIMEOUT },
  47.     { ngx_string("invalid_response"), NGX_HTTP_UPSTREAM_FT_INVALID_HEADER },
  48.     { ngx_string("not_found"), NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  49.     { ngx_string("off"), NGX_HTTP_UPSTREAM_FT_OFF },
  50.     { ngx_null_string, 0 }
  51. };


  54. ‌static ngx_command_t  ngx_http_memcached_commands[] = {

  56.     { ngx_string("memcached_pass"),
  57.       NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
  58.       ngx_http_memcached_pass,
  59.       NGX_HTTP_LOC_CONF_OFFSET,
  60.       0,
  61.       NULL },

  63.     { ngx_string("memcached_bind"),
  64.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  65.       ngx_http_upstream_bind_set_slot,
  66.       NGX_HTTP_LOC_CONF_OFFSET,
  67.       offsetof(ngx_http_memcached_loc_conf_t, upstream.local),
  68.       NULL },

  70.     { ngx_string("memcached_connect_timeout"),
  71.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  72.       ngx_conf_set_msec_slot,
  73.       NGX_HTTP_LOC_CONF_OFFSET,
  74.       offsetof(ngx_http_memcached_loc_conf_t, upstream.connect_timeout),
  75.       NULL },

  77.     { ngx_string("memcached_send_timeout"),
  78.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  79.       ngx_conf_set_msec_slot,
  80.       NGX_HTTP_LOC_CONF_OFFSET,
  81.       offsetof(ngx_http_memcached_loc_conf_t, upstream.send_timeout),
  82.       NULL },

  84.     { ngx_string("memcached_buffer_size"),
  85.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  86.       ngx_conf_set_size_slot,
  87.       NGX_HTTP_LOC_CONF_OFFSET,
  88.       offsetof(ngx_http_memcached_loc_conf_t, upstream.buffer_size),
  89.       NULL },

  91.     { ngx_string("memcached_read_timeout"),
  92.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  93.       ngx_conf_set_msec_slot,
  94.       NGX_HTTP_LOC_CONF_OFFSET,
  95.       offsetof(ngx_http_memcached_loc_conf_t, upstream.read_timeout),
  96.       NULL },

  98.     { ngx_string("memcached_next_upstream"),
  99.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  100.       ngx_conf_set_bitmask_slot,
  101.       NGX_HTTP_LOC_CONF_OFFSET,
  102.       offsetof(ngx_http_memcached_loc_conf_t, upstream.next_upstream),
  103.       &ngx_http_memcached_next_upstream_masks },

  105.     { ngx_string("memcached_next_upstream_tries"),
  106.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  107.       ngx_conf_set_num_slot,
  108.       NGX_HTTP_LOC_CONF_OFFSET,
  109.       offsetof(ngx_http_memcached_loc_conf_t, upstream.next_upstream_tries),
  110.       NULL },

  112.     { ngx_string("memcached_next_upstream_timeout"),
  113.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  114.       ngx_conf_set_msec_slot,
  115.       NGX_HTTP_LOC_CONF_OFFSET,
  116.       offsetof(ngx_http_memcached_loc_conf_t, upstream.next_upstream_timeout),
  117.       NULL },

  119.     { ngx_string("memcached_gzip_flag"),
  120.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  121.       ngx_conf_set_num_slot,
  122.       NGX_HTTP_LOC_CONF_OFFSET,
  123.       offsetof(ngx_http_memcached_loc_conf_t, gzip_flag),
  124.       NULL },

  126.       ngx_null_command
  127. };


  130. ‌static ngx_http_module_t  ngx_http_memcached_module_ctx = {
  131.     NULL,                                  /* preconfiguration */
  132.     NULL,                                  /* postconfiguration */

  134.     NULL,                                  /* create main configuration */
  135.     NULL,                                  /* init main configuration */

  137.     NULL,                                  /* create server configuration */
  138.     NULL,                                  /* merge server configuration */

  140.     ngx_http_memcached_create_loc_conf,    /* create location configuration */
  141.     ngx_http_memcached_merge_loc_conf      /* merge location configuration */
  142. };


  145. ‌ngx_module_t  ngx_http_memcached_module = {
  146.     NGX_MODULE_V1,
  147.     &ngx_http_memcached_module_ctx,        /* module context */
  148.     ngx_http_memcached_commands,           /* module directives */
  149.     NGX_HTTP_MODULE,                       /* module type */
  150.     NULL,                                  /* init master */
  151.     NULL,                                  /* init module */
  152.     NULL,                                  /* init process */
  153.     NULL,                                  /* init thread */
  154.     NULL,                                  /* exit thread */
  155.     NULL,                                  /* exit process */
  156.     NULL,                                  /* exit master */
  157.     NGX_MODULE_V1_PADDING
  158. };


  161. ‌static ngx_str_t  ngx_http_memcached_key = ngx_string("memcached_key");


  164. ‌#define NGX_HTTP_MEMCACHED_END   (sizeof(ngx_http_memcached_end) - 1)
  165. ‌static u_char  ngx_http_memcached_end[] = CRLF "END" CRLF;


  168. static ngx_int_t
  169. ‌ngx_http_memcached_handler(ngx_http_request_t *r)
  170. {
  171.     ngx_int_t                       rc;
  172.     ngx_http_upstream_t            *u;
  173.     ngx_http_memcached_ctx_t       *ctx;
  174.     ngx_http_memcached_loc_conf_t  *mlcf;

  176.     if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD))) {
  177.         return NGX_HTTP_NOT_ALLOWED;
  178.     }

  180.     rc = ngx_http_discard_request_body(r);

  182.     if (rc != NGX_OK) {
  183.         return rc;
  184.     }

  186.     if (ngx_http_set_content_type(r) != NGX_OK) {
  187.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  188.     }

  190.     if (ngx_http_upstream_create(r) != NGX_OK) {
  191.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  192.     }

  194.     u = r->upstream;

  196.     ngx_str_set(&u->schema, "memcached://");
  197.     u->output.tag = (ngx_buf_tag_t) &ngx_http_memcached_module;

  199.     mlcf = ngx_http_get_module_loc_conf(r, ngx_http_memcached_module);

  201.     u->conf = &mlcf->upstream;

  203.     u->create_request = ngx_http_memcached_create_request;
  204.     u->reinit_request = ngx_http_memcached_reinit_request;
  205.     u->process_header = ngx_http_memcached_process_header;
  206.     u->abort_request = ngx_http_memcached_abort_request;
  207.     u->finalize_request = ngx_http_memcached_finalize_request;

  209.     ctx = ngx_palloc(r->pool, sizeof(ngx_http_memcached_ctx_t));
  210.     if (ctx == NULL) {
  211.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  212.     }

  214.     ctx->request = r;

  216.     ngx_http_set_ctx(r, ctx, ngx_http_memcached_module);

  218.     u->input_filter_init = ngx_http_memcached_filter_init;
  219.     u->input_filter = ngx_http_memcached_filter;
  220.     u->input_filter_ctx = ctx;

  222.     r->main->count++;

  224.     ngx_http_upstream_init(r);

  226.     return NGX_DONE;
  227. }


  230. static ngx_int_t
  231. ‌ngx_http_memcached_create_request(ngx_http_request_t *r)
  232. {
  233.     size_t                          len;
  234.     uintptr_t                       escape;
  235.     ngx_buf_t                      *b;
  236.     ngx_chain_t                    *cl;
  237.     ngx_http_memcached_ctx_t       *ctx;
  238.     ngx_http_variable_value_t      *vv;
  239.     ngx_http_memcached_loc_conf_t  *mlcf;

  241.     mlcf = ngx_http_get_module_loc_conf(r, ngx_http_memcached_module);

  243.     vv = ngx_http_get_indexed_variable(r, mlcf->index);

  245.     if (vv == NULL || vv->not_found || vv->len == 0) {
  246.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  247.                       "the \"$memcached_key\" variable is not set");
  248.         return NGX_ERROR;
  249.     }

  251.     escape = 2 * ngx_escape_uri(NULL, vv->data, vv->len, NGX_ESCAPE_MEMCACHED);

  253.     len = sizeof("get ") - 1 + vv->len + escape + sizeof(CRLF) - 1;

  255.     b = ngx_create_temp_buf(r->pool, len);
  256.     if (b == NULL) {
  257.         return NGX_ERROR;
  258.     }

  260.     cl = ngx_alloc_chain_link(r->pool);
  261.     if (cl == NULL) {
  262.         return NGX_ERROR;
  263.     }

  265.     cl->buf = b;
  266.     cl->next = NULL;

  268.     r->upstream->request_bufs = cl;

  270.     *b->last++ = 'g'; *b->last++ = 'e'; *b->last++ = 't'; *b->last++ = ' ';

  272.     ctx = ngx_http_get_module_ctx(r, ngx_http_memcached_module);

  274.     ctx->key.data = b->last;

  276.     if (escape == 0) {
  277.         b->last = ngx_copy(b->last, vv->data, vv->len);

  279.     } else {
  280.         b->last = (u_char *) ngx_escape_uri(b->last, vv->data, vv->len,
  281.                                             NGX_ESCAPE_MEMCACHED);
  282.     }

  284.     ctx->key.len = b->last - ctx->key.data;

  286.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  287.                    "http memcached request: \"%V\"", &ctx->key);

  289.     *b->last++ = CR; *b->last++ = LF;

  291.     return NGX_OK;
  292. }


  295. static ngx_int_t
  296. ‌ngx_http_memcached_reinit_request(ngx_http_request_t *r)
  297. {
  298.     return NGX_OK;
  299. }


  302. static ngx_int_t
  303. ‌ngx_http_memcached_process_header(ngx_http_request_t *r)
  304. {
  305.     u_char                         *p, *start;
  306.     ngx_str_t                       line;
  307.     ngx_uint_t                      flags;
  308.     ngx_table_elt_t                *h;
  309.     ngx_http_upstream_t            *u;
  310.     ngx_http_memcached_ctx_t       *ctx;
  311.     ngx_http_memcached_loc_conf_t  *mlcf;

  313.     u = r->upstream;

  315.     for (p = u->buffer.pos; p < u->buffer.last; p++) {
  316.         if (*p == LF) {
  317.             goto found;
  318.         }
  319.     }

  321.     return NGX_AGAIN;

  323. found:

  325.     line.data = u->buffer.pos;
  326.     line.len = p - u->buffer.pos;

  328.     if (line.len == 0 || *(p - 1) != CR) {
  329.         goto no_valid;
  330.     }

  332.     *p = '\0';
  333.     line.len--;

  335.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  336.                    "memcached: \"%V\"", &line);

  338.     p = u->buffer.pos;

  340.     ctx = ngx_http_get_module_ctx(r, ngx_http_memcached_module);
  341.     mlcf = ngx_http_get_module_loc_conf(r, ngx_http_memcached_module);

  343.     if (ngx_strncmp(p, "VALUE ", sizeof("VALUE ") - 1) == 0) {

  345.         p += sizeof("VALUE ") - 1;

  347.         if (ngx_strncmp(p, ctx->key.data, ctx->key.len) != 0) {
  348.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  349.                           "memcached sent invalid key in response \"%V\" "
  350.                           "for key \"%V\"",
  351.                           &line, &ctx->key);

  353.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  354.         }

  356.         p += ctx->key.len;

  358.         if (*p++ != ' ') {
  359.             goto no_valid;
  360.         }

  362.         /* flags */

  364.         start = p;

  366.         while (*p) {
  367.             if (*p++ == ' ') {
  368.                 if (mlcf->gzip_flag) {
  369.                     goto flags;
  370.                 } else {
  371.                     goto length;
  372.                 }
  373.             }
  374.         }

  376.         goto no_valid;

  378.     flags:

  380.         flags = ngx_atoi(start, p - start - 1);

  382.         if (flags == (ngx_uint_t) NGX_ERROR) {
  383.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  384.                           "memcached sent invalid flags in response \"%V\" "
  385.                           "for key \"%V\"",
  386.                           &line, &ctx->key);
  387.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  388.         }

  390.         if (flags & mlcf->gzip_flag) {
  391.             h = ngx_list_push(&r->headers_out.headers);
  392.             if (h == NULL) {
  393.                 return NGX_ERROR;
  394.             }

  396.             h->hash = 1;
  397.             ngx_str_set(&h->key, "Content-Encoding");
  398.             ngx_str_set(&h->value, "gzip");
  399.             r->headers_out.content_encoding = h;
  400.         }

  402.     length:

  404.         start = p;
  405.         p = line.data + line.len;

  407.         u->headers_in.content_length_n = ngx_atoof(start, p - start);
  408.         if (u->headers_in.content_length_n == NGX_ERROR) {
  409.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  410.                           "memcached sent invalid length in response \"%V\" "
  411.                           "for key \"%V\"",
  412.                           &line, &ctx->key);
  413.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  414.         }

  416.         u->headers_in.status_n = 200;
  417.         u->state->status = 200;
  418.         u->buffer.pos = p + sizeof(CRLF) - 1;

  420.         return NGX_OK;
  421.     }

  423.     if (ngx_strcmp(p, "END\x0d") == 0) {
  424.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  425.                       "key: \"%V\" was not found by memcached", &ctx->key);

  427.         u->headers_in.content_length_n = 0;
  428.         u->headers_in.status_n = 404;
  429.         u->state->status = 404;
  430.         u->buffer.pos = p + sizeof("END" CRLF) - 1;
  431.         u->keepalive = 1;

  433.         return NGX_OK;
  434.     }

  436. no_valid:

  438.     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  439.                   "memcached sent invalid response: \"%V\"", &line);

  441.     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  442. }


  445. static ngx_int_t
  446. ‌ngx_http_memcached_filter_init(void *data)
  447. {
  448.     ngx_http_memcached_ctx_t  *ctx = data;

  450.     ngx_http_upstream_t  *u;

  452.     u = ctx->request->upstream;

  454.     if (u->headers_in.status_n != 404) {
  455.         u->length = u->headers_in.content_length_n + NGX_HTTP_MEMCACHED_END;
  456.         ctx->rest = NGX_HTTP_MEMCACHED_END;

  458.     } else {
  459.         u->length = 0;
  460.     }

  462.     return NGX_OK;
  463. }


  466. static ngx_int_t
  467. ‌ngx_http_memcached_filter(void *data, ssize_t bytes)
  468. {
  469.     ngx_http_memcached_ctx_t  *ctx = data;

  471.     u_char               *last;
  472.     ngx_buf_t            *b;
  473.     ngx_chain_t          *cl, **ll;
  474.     ngx_http_upstream_t  *u;

  476.     u = ctx->request->upstream;
  477.     b = &u->buffer;

  479.     if (u->length == (ssize_t) ctx->rest) {

  481.         if (ngx_strncmp(b->last,
  482.                    ngx_http_memcached_end + NGX_HTTP_MEMCACHED_END - ctx->rest,
  483.                    bytes)
  484.             != 0)
  485.         {
  486.             ngx_log_error(NGX_LOG_ERR, ctx->request->connection->log, 0,
  487.                           "memcached sent invalid trailer");

  489.             u->length = 0;
  490.             ctx->rest = 0;

  492.             return NGX_OK;
  493.         }

  495.         u->length -= bytes;
  496.         ctx->rest -= bytes;

  498.         if (u->length == 0) {
  499.             u->keepalive = 1;
  500.         }

  502.         return NGX_OK;
  503.     }

  505.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  506.         ll = &cl->next;
  507.     }

  509.     cl = ngx_chain_get_free_buf(ctx->request->pool, &u->free_bufs);
  510.     if (cl == NULL) {
  511.         return NGX_ERROR;
  512.     }

  514.     cl->buf->flush = 1;
  515.     cl->buf->memory = 1;

  517.     *ll = cl;

  519.     last = b->last;
  520.     cl->buf->pos = last;
  521.     b->last += bytes;
  522.     cl->buf->last = b->last;
  523.     cl->buf->tag = u->output.tag;

  525.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, ctx->request->connection->log, 0,
  526.                    "memcached filter bytes:%z size:%z length:%z rest:%z",
  527.                    bytes, b->last - b->pos, u->length, ctx->rest);

  529.     if (bytes <= (ssize_t) (u->length - NGX_HTTP_MEMCACHED_END)) {
  530.         u->length -= bytes;
  531.         return NGX_OK;
  532.     }

  534.     last += (size_t) (u->length - NGX_HTTP_MEMCACHED_END);

  536.     if (ngx_strncmp(last, ngx_http_memcached_end, b->last - last) != 0) {
  537.         ngx_log_error(NGX_LOG_ERR, ctx->request->connection->log, 0,
  538.                       "memcached sent invalid trailer");

  540.         b->last = last;
  541.         cl->buf->last = last;
  542.         u->length = 0;
  543.         ctx->rest = 0;

  545.         return NGX_OK;
  546.     }

  548.     ctx->rest -= b->last - last;
  549.     b->last = last;
  550.     cl->buf->last = last;
  551.     u->length = ctx->rest;

  553.     if (u->length == 0) {
  554.         u->keepalive = 1;
  555.     }

  557.     return NGX_OK;
  558. }


  561. static void
  562. ‌ngx_http_memcached_abort_request(ngx_http_request_t *r)
  563. {
  564.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  565.                    "abort http memcached request");
  566.     return;
  567. }


  570. static void
  571. ‌ngx_http_memcached_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  572. {
  573.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  574.                    "finalize http memcached request");
  575.     return;
  576. }


  579. static void *
  580. ‌ngx_http_memcached_create_loc_conf(ngx_conf_t *cf)
  581. {
  582.     ngx_http_memcached_loc_conf_t  *conf;

  584.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_memcached_loc_conf_t));
  585.     if (conf == NULL) {
  586.         return NULL;
  587.     }

  589.     /*
  590.      * set by ngx_pcalloc():
  591.      *
  592.      *     conf->upstream.bufs.num = 0;
  593.      *     conf->upstream.next_upstream = 0;
  594.      *     conf->upstream.temp_path = NULL;
  595.      *     conf->upstream.uri = { 0, NULL };
  596.      *     conf->upstream.location = NULL;
  597.      */

  599.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  600.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  601.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  602.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  603.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  604.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  606.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;

  608.     /* the hardcoded values */
  609.     conf->upstream.cyclic_temp_file = 0;
  610.     conf->upstream.buffering = 0;
  611.     conf->upstream.ignore_client_abort = 0;
  612.     conf->upstream.send_lowat = 0;
  613.     conf->upstream.bufs.num = 0;
  614.     conf->upstream.busy_buffers_size = 0;
  615.     conf->upstream.max_temp_file_size = 0;
  616.     conf->upstream.temp_file_write_size = 0;
  617.     conf->upstream.intercept_errors = 1;
  618.     conf->upstream.intercept_404 = 1;
  619.     conf->upstream.pass_request_headers = 0;
  620.     conf->upstream.pass_request_body = 0;

  622.     conf->index = NGX_CONF_UNSET;
  623.     conf->gzip_flag = NGX_CONF_UNSET_UINT;

  625.     return conf;
  626. }


  629. static char *
  630. ‌ngx_http_memcached_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  631. {
  632.     ngx_http_memcached_loc_conf_t *prev = parent;
  633.     ngx_http_memcached_loc_conf_t *conf = child;

  635.     ngx_conf_merge_ptr_value(conf->upstream.local,
  636.                               prev->upstream.local, NULL);

  638.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  639.                               prev->upstream.next_upstream_tries, 0);

  641.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  642.                               prev->upstream.connect_timeout, 60000);

  644.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  645.                               prev->upstream.send_timeout, 60000);

  647.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  648.                               prev->upstream.read_timeout, 60000);

  650.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  651.                               prev->upstream.next_upstream_timeout, 0);

  653.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  654.                               prev->upstream.buffer_size,
  655.                               (size_t) ngx_pagesize);

  657.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  658.                               prev->upstream.next_upstream,
  659.                               (NGX_CONF_BITMASK_SET
  660.                                |NGX_HTTP_UPSTREAM_FT_ERROR
  661.                                |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  663.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  664.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  665.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  666.     }

  668.     if (conf->upstream.upstream == NULL) {
  669.         conf->upstream.upstream = prev->upstream.upstream;
  670.     }

  672.     if (conf->index == NGX_CONF_UNSET) {
  673.         conf->index = prev->index;
  674.     }

  676.     ngx_conf_merge_uint_value(conf->gzip_flag, prev->gzip_flag, 0);

  678.     return NGX_CONF_OK;
  679. }


  682. static char *
  683. ‌ngx_http_memcached_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  684. {
  685.     ngx_http_memcached_loc_conf_t *mlcf = conf;

  687.     ngx_str_t                 *value;
  688.     ngx_url_t                  u;
  689.     ngx_http_core_loc_conf_t  *clcf;

  691.     if (mlcf->upstream.upstream) {
  692.         return "is duplicate";
  693.     }

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

  697.     ngx_memzero(&u, sizeof(ngx_url_t));

  699.     u.url = value[1];
  700.     u.no_resolve = 1;

  702.     mlcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  703.     if (mlcf->upstream.upstream == NULL) {
  704.         return NGX_CONF_ERROR;
  705.     }

  707.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  709.     clcf->handler = ngx_http_memcached_handler;

  711.     if (clcf->name.data[clcf->name.len - 1] == '/') {
  712.         clcf->auto_redirect = 1;
  713.     }

  715.     mlcf->index = ngx_http_get_variable_index(cf, &ngx_http_memcached_key);

  717.     if (mlcf->index == NGX_ERROR) {
  718.         return NGX_CONF_ERROR;
  719.     }

  721.     return NGX_CONF_OK;
  722. }

One Level Up Top Level