One Level Up Top Level

src/http/modules/ngx_http_realip_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. ‌#define NGX_HTTP_REALIP_XREALIP  0
  14. ‌#define NGX_HTTP_REALIP_XFWD     1
  15. ‌#define NGX_HTTP_REALIP_HEADER   2
  16. ‌#define NGX_HTTP_REALIP_PROXY    3


  19. typedef struct {
  20.     ngx_array_t       *from;     /* array of ngx_cidr_t */
  21.     ngx_uint_t         type;
  22.     ngx_uint_t         hash;
  23.     ngx_str_t          header;
  24.     ngx_flag_t         recursive;
  25. ‌} ngx_http_realip_loc_conf_t;


  28. typedef struct {
  29.     ngx_connection_t  *connection;
  30.     struct sockaddr   *sockaddr;
  31.     socklen_t          socklen;
  32.     ngx_str_t          addr_text;
  33. ‌} ngx_http_realip_ctx_t;


  36. static ngx_int_t ngx_http_realip_handler(ngx_http_request_t *r);
  37. static ngx_int_t ngx_http_realip_set_addr(ngx_http_request_t *r,
  38.     ngx_addr_t *addr);
  39. static void ngx_http_realip_cleanup(void *data);
  40. static char *ngx_http_realip_from(ngx_conf_t *cf, ngx_command_t *cmd,
  41.     void *conf);
  42. static char *ngx_http_realip(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  43. static void *ngx_http_realip_create_loc_conf(ngx_conf_t *cf);
  44. static char *ngx_http_realip_merge_loc_conf(ngx_conf_t *cf,
  45.     void *parent, void *child);
  46. static ngx_int_t ngx_http_realip_init(ngx_conf_t *cf);


  49. ‌static ngx_command_t  ngx_http_realip_commands[] = {

  51.     { ngx_string("set_real_ip_from"),
  52.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  53.       ngx_http_realip_from,
  54.       NGX_HTTP_LOC_CONF_OFFSET,
  55.       0,
  56.       NULL },

  58.     { ngx_string("real_ip_header"),
  59.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  60.       ngx_http_realip,
  61.       NGX_HTTP_LOC_CONF_OFFSET,
  62.       0,
  63.       NULL },

  65.     { ngx_string("real_ip_recursive"),
  66.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  67.       ngx_conf_set_flag_slot,
  68.       NGX_HTTP_LOC_CONF_OFFSET,
  69.       offsetof(ngx_http_realip_loc_conf_t, recursive),
  70.       NULL },

  72.       ngx_null_command
  73. };



  77. ‌static ngx_http_module_t  ngx_http_realip_module_ctx = {
  78.     NULL,                                  /* preconfiguration */
  79.     ngx_http_realip_init,                  /* postconfiguration */

  81.     NULL,                                  /* create main configuration */
  82.     NULL,                                  /* init main configuration */

  84.     NULL,                                  /* create server configuration */
  85.     NULL,                                  /* merge server configuration */

  87.     ngx_http_realip_create_loc_conf,       /* create location configuration */
  88.     ngx_http_realip_merge_loc_conf         /* merge location configuration */
  89. };


  92. ‌ngx_module_t  ngx_http_realip_module = {
  93.     NGX_MODULE_V1,
  94.     &ngx_http_realip_module_ctx,           /* module context */
  95.     ngx_http_realip_commands,              /* module directives */
  96.     NGX_HTTP_MODULE,                       /* module type */
  97.     NULL,                                  /* init master */
  98.     NULL,                                  /* init module */
  99.     NULL,                                  /* init process */
  100.     NULL,                                  /* init thread */
  101.     NULL,                                  /* exit thread */
  102.     NULL,                                  /* exit process */
  103.     NULL,                                  /* exit master */
  104.     NGX_MODULE_V1_PADDING
  105. };


  108. static ngx_int_t
  109. ‌ngx_http_realip_handler(ngx_http_request_t *r)
  110. {
  111.     u_char                      *p;
  112.     size_t                       len;
  113.     ngx_str_t                   *value;
  114.     ngx_uint_t                   i, hash;
  115.     ngx_addr_t                   addr;
  116.     ngx_array_t                 *xfwd;
  117.     ngx_list_part_t             *part;
  118.     ngx_table_elt_t             *header;
  119.     ngx_connection_t            *c;
  120.     ngx_http_realip_ctx_t       *ctx;
  121.     ngx_http_realip_loc_conf_t  *rlcf;

  123.     ctx = ngx_http_get_module_ctx(r, ngx_http_realip_module);

  125.     if (ctx) {
  126.         return NGX_DECLINED;
  127.     }

  129.     rlcf = ngx_http_get_module_loc_conf(r, ngx_http_realip_module);

  131.     if (rlcf->from == NULL) {
  132.         return NGX_DECLINED;
  133.     }

  135.     switch (rlcf->type) {

  137.     case NGX_HTTP_REALIP_XREALIP:

  139.         if (r->headers_in.x_real_ip == NULL) {
  140.             return NGX_DECLINED;
  141.         }

  143.         value = &r->headers_in.x_real_ip->value;
  144.         xfwd = NULL;

  146.         break;

  148.     case NGX_HTTP_REALIP_XFWD:

  150.         xfwd = &r->headers_in.x_forwarded_for;

  152.         if (xfwd->elts == NULL) {
  153.             return NGX_DECLINED;
  154.         }

  156.         value = NULL;

  158.         break;

  160.     case NGX_HTTP_REALIP_PROXY:

  162.         value = &r->connection->proxy_protocol_addr;

  164.         if (value->len == 0) {
  165.             return NGX_DECLINED;
  166.         }

  168.         xfwd = NULL;

  170.         break;

  172.     default: /* NGX_HTTP_REALIP_HEADER */

  174.         part = &r->headers_in.headers.part;
  175.         header = part->elts;

  177.         hash = rlcf->hash;
  178.         len = rlcf->header.len;
  179.         p = rlcf->header.data;

  181.         for (i = 0; /* void */ ; i++) {

  183.             if (i >= part->nelts) {
  184.                 if (part->next == NULL) {
  185.                     break;
  186.                 }

  188.                 part = part->next;
  189.                 header = part->elts;
  190.                 i = 0;
  191.             }

  193.             if (hash == header[i].hash
  194.                 && len == header[i].key.len
  195.                 && ngx_strncmp(p, header[i].lowcase_key, len) == 0)
  196.             {
  197.                 value = &header[i].value;
  198.                 xfwd = NULL;

  200.                 goto found;
  201.             }
  202.         }

  204.         return NGX_DECLINED;
  205.     }

  207. found:

  209.     c = r->connection;

  211.     addr.sockaddr = c->sockaddr;
  212.     addr.socklen = c->socklen;
  213.     /* addr.name = c->addr_text; */

  215.     if (ngx_http_get_forwarded_addr(r, &addr, xfwd, value, rlcf->from,
  216.                                     rlcf->recursive)
  217.         != NGX_DECLINED)
  218.     {
  219.         return ngx_http_realip_set_addr(r, &addr);
  220.     }

  222.     return NGX_DECLINED;
  223. }


  226. static ngx_int_t
  227. ‌ngx_http_realip_set_addr(ngx_http_request_t *r, ngx_addr_t *addr)
  228. {
  229.     size_t                  len;
  230.     u_char                 *p;
  231.     u_char                  text[NGX_SOCKADDR_STRLEN];
  232.     ngx_connection_t       *c;
  233.     ngx_pool_cleanup_t     *cln;
  234.     ngx_http_realip_ctx_t  *ctx;

  236.     cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_http_realip_ctx_t));
  237.     if (cln == NULL) {
  238.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  239.     }

  241.     ctx = cln->data;
  242.     ngx_http_set_ctx(r, ctx, ngx_http_realip_module);

  244.     c = r->connection;

  246.     len = ngx_sock_ntop(addr->sockaddr, addr->socklen, text,
  247.                         NGX_SOCKADDR_STRLEN, 0);
  248.     if (len == 0) {
  249.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  250.     }

  252.     p = ngx_pnalloc(c->pool, len);
  253.     if (p == NULL) {
  254.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  255.     }

  257.     ngx_memcpy(p, text, len);

  259.     cln->handler = ngx_http_realip_cleanup;

  261.     ctx->connection = c;
  262.     ctx->sockaddr = c->sockaddr;
  263.     ctx->socklen = c->socklen;
  264.     ctx->addr_text = c->addr_text;

  266.     c->sockaddr = addr->sockaddr;
  267.     c->socklen = addr->socklen;
  268.     c->addr_text.len = len;
  269.     c->addr_text.data = p;

  271.     return NGX_DECLINED;
  272. }


  275. static void
  276. ‌ngx_http_realip_cleanup(void *data)
  277. {
  278.     ngx_http_realip_ctx_t *ctx = data;

  280.     ngx_connection_t  *c;

  282.     c = ctx->connection;

  284.     c->sockaddr = ctx->sockaddr;
  285.     c->socklen = ctx->socklen;
  286.     c->addr_text = ctx->addr_text;
  287. }


  290. static char *
  291. ‌ngx_http_realip_from(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  292. {
  293.     ngx_http_realip_loc_conf_t *rlcf = conf;

  295.     ngx_int_t                rc;
  296.     ngx_str_t               *value;
  297.     ngx_cidr_t              *cidr;

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

  301.     if (rlcf->from == NULL) {
  302.         rlcf->from = ngx_array_create(cf->pool, 2,
  303.                                       sizeof(ngx_cidr_t));
  304.         if (rlcf->from == NULL) {
  305.             return NGX_CONF_ERROR;
  306.         }
  307.     }

  309.     cidr = ngx_array_push(rlcf->from);
  310.     if (cidr == NULL) {
  311.         return NGX_CONF_ERROR;
  312.     }

  314. #if (NGX_HAVE_UNIX_DOMAIN)

  316.     if (ngx_strcmp(value[1].data, "unix:") == 0) {
  317.          cidr->family = AF_UNIX;
  318.          return NGX_CONF_OK;
  319.     }

  321. #endif

  323.     rc = ngx_ptocidr(&value[1], cidr);

  325.     if (rc == NGX_ERROR) {
  326.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameter \"%V\"",
  327.                            &value[1]);
  328.         return NGX_CONF_ERROR;
  329.     }

  331.     if (rc == NGX_DONE) {
  332.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  333.                            "low address bits of %V are meaningless", &value[1]);
  334.     }

  336.     return NGX_CONF_OK;
  337. }


  340. static char *
  341. ‌ngx_http_realip(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  342. {
  343.     ngx_http_realip_loc_conf_t *rlcf = conf;

  345.     ngx_str_t  *value;

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

  349.     if (ngx_strcmp(value[1].data, "X-Real-IP") == 0) {
  350.         rlcf->type = NGX_HTTP_REALIP_XREALIP;
  351.         return NGX_CONF_OK;
  352.     }

  354.     if (ngx_strcmp(value[1].data, "X-Forwarded-For") == 0) {
  355.         rlcf->type = NGX_HTTP_REALIP_XFWD;
  356.         return NGX_CONF_OK;
  357.     }

  359.     if (ngx_strcmp(value[1].data, "proxy_protocol") == 0) {
  360.         rlcf->type = NGX_HTTP_REALIP_PROXY;
  361.         return NGX_CONF_OK;
  362.     }

  364.     rlcf->type = NGX_HTTP_REALIP_HEADER;
  365.     rlcf->hash = ngx_hash_strlow(value[1].data, value[1].data, value[1].len);
  366.     rlcf->header = value[1];

  368.     return NGX_CONF_OK;
  369. }


  372. static void *
  373. ‌ngx_http_realip_create_loc_conf(ngx_conf_t *cf)
  374. {
  375.     ngx_http_realip_loc_conf_t  *conf;

  377.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_realip_loc_conf_t));
  378.     if (conf == NULL) {
  379.         return NULL;
  380.     }

  382.     /*
  383.      * set by ngx_pcalloc():
  384.      *
  385.      *     conf->from = NULL;
  386.      *     conf->hash = 0;
  387.      *     conf->header = { 0, NULL };
  388.      */

  390.     conf->type = NGX_CONF_UNSET_UINT;
  391.     conf->recursive = NGX_CONF_UNSET;

  393.     return conf;
  394. }


  397. static char *
  398. ‌ngx_http_realip_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  399. {
  400.     ngx_http_realip_loc_conf_t  *prev = parent;
  401.     ngx_http_realip_loc_conf_t  *conf = child;

  403.     if (conf->from == NULL) {
  404.         conf->from = prev->from;
  405.     }

  407.     ngx_conf_merge_uint_value(conf->type, prev->type, NGX_HTTP_REALIP_XREALIP);
  408.     ngx_conf_merge_value(conf->recursive, prev->recursive, 0);

  410.     if (conf->header.len == 0) {
  411.         conf->hash = prev->hash;
  412.         conf->header = prev->header;
  413.     }

  415.     return NGX_CONF_OK;
  416. }


  419. static ngx_int_t
  420. ‌ngx_http_realip_init(ngx_conf_t *cf)
  421. {
  422.     ngx_http_handler_pt        *h;
  423.     ngx_http_core_main_conf_t  *cmcf;

  425.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  427.     h = ngx_array_push(&cmcf->phases[NGX_HTTP_POST_READ_PHASE].handlers);
  428.     if (h == NULL) {
  429.         return NGX_ERROR;
  430.     }

  432.     *h = ngx_http_realip_handler;

  434.     h = ngx_array_push(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers);
  435.     if (h == NULL) {
  436.         return NGX_ERROR;
  437.     }

  439.     *h = ngx_http_realip_handler;

  441.     return NGX_OK;
  442. }

One Level Up Top Level