One Level Up Top Level

src/os/unix/ngx_control.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


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


  7. #include <ngx_config.h>
  8. #include <ngx_core.h>
  9. #include <poll.h>


  12. ‌#define NGX_CTRL_MAX_FD          64
  13. ‌#define NGX_CTRL_MAX_REQUEST     1024

  15. ‌#define NGX_CTRL_OK              200
  16. ‌#define NGX_CTRL_BAD_REQUEST     400
  17. ‌#define NGX_CTRL_NOT_FOUND       404
  18. ‌#define NGX_CTRL_NOT_ALLOWED     405
  19. ‌#define NGX_CTRL_UNPROCESSABLE   422
  20. ‌#define NGX_CTRL_INTERNAL_ERROR  500

  22. ‌#define NGX_CTRL_GET             1
  23. ‌#define NGX_CTRL_PATCH           2

  25. ‌#define NGX_CTRL_ENV             "NGINX_CTRL"


  28. ‌typedef struct {
  29.     ngx_fd_t      fd;
  30.     ngx_pool_t   *pool;
  31.     ngx_uint_t    index;
  32.     ngx_uint_t    state;

  34.     ngx_str_t     path;
  35.     ngx_uint_t    method;

  37.     ngx_buf_t    *in;
  38.     ngx_chain_t  *out;

  40.     ngx_uint_t    reloaded;
  41. ‌} ngx_control_request_t;


  44. ‌typedef struct {
  45.     ngx_str_t     name;
  46.     ngx_int_t     pid;
  47.     ngx_uint_t    exiting;
  48. ‌} ngx_control_process_t;


  51. static ngx_int_t ngx_control_inherit(void);
  52. static void ngx_control_close(ngx_control_request_t *r);
  53. static void ngx_control_handle_accept(void);
  54. static ngx_int_t ngx_control_handle_read(ngx_control_request_t *r);
  55. static ngx_int_t ngx_control_content(ngx_control_request_t *r);
  56. static char *ngx_control_status_text(ngx_uint_t code);
  57. static ngx_int_t ngx_control_send_response(ngx_control_request_t *r,
  58.     ngx_uint_t code, ngx_buf_t *body);
  59. static ngx_int_t ngx_control_handle_write(ngx_control_request_t *r);

  61. static ngx_int_t ngx_control_api_endpoints(ngx_control_request_t *r,
  62.     const char **paths, ngx_int_t npaths);
  63. static ngx_int_t ngx_control_show_processes(ngx_control_request_t *r);
  64. static ngx_int_t ngx_control_show_version(ngx_control_request_t *r);
  65. static ngx_int_t ngx_control_reload_config(ngx_control_request_t *r);
  66. static ngx_int_t ngx_control_print_config(ngx_control_request_t *r);
  67. static void ngx_control_log_capture(ngx_log_t *log, ngx_uint_t l,
  68.     u_char *buf, size_t len);

  70. static ngx_int_t ngx_control_parse_request_line(ngx_control_request_t *r);
  71. static ngx_int_t ngx_control_send_json(ngx_control_request_t *r, ngx_int_t code,
  72.     ngx_data_item_t *obj);


  75. ‌static ngx_control_request_t  ngx_control_requests[NGX_CTRL_MAX_FD];
  76. ‌static struct pollfd          ngx_control_pollfd[NGX_CTRL_MAX_FD];
  77. ‌static ngx_uint_t             ngx_control_pollfd_n;
  78. ‌static char                   ngx_control_unix_path[NGX_UNIX_ADDRSTRLEN];
  79. ‌static ngx_uint_t             ngx_control_inherited;
  80. ‌static u_char                *ngx_control_env;
  81. ‌ngx_uint_t                    ngx_control_api_enabled;


  84. static ngx_str_t  ngx_control_version = ngx_string(NGINX_VERSION);

  86. #ifdef NGX_BUILD
  87. static ngx_str_t  ngx_control_build = ngx_string(NGX_BUILD);
  88. #else
  89. ‌static ngx_str_t  ngx_control_build;
  90. #endif

  92. ‌static ngx_data_decl_t  ngx_control_process_fields[] = {

  94.     { ngx_string("name"),
  95.       ngx_data_struct_str_handler,
  96.       offsetof(ngx_control_process_t, name) },

  98.     { ngx_string("pid"),
  99.       ngx_data_struct_int_handler,
  100.       offsetof(ngx_control_process_t, pid) },

  102.     { ngx_string("exiting"),
  103.       ngx_data_struct_boolean_handler,
  104.       offsetof(ngx_control_process_t, exiting) },

  106.       ngx_data_null_decl
  107. };

  109. ‌static ngx_data_decl_t  ngx_control_status_fields[] = {

  111.     { ngx_string("version"),
  112.       ngx_data_string_handler,
  113.       (uintptr_t) &ngx_control_version },

  115.     { ngx_string("build"),
  116.       ngx_data_string_handler,
  117.       (uintptr_t) &ngx_control_build },

  119.       ngx_data_null_decl
  120. };

  122. ‌static ngx_data_decl_t  ngx_control_config_fields[] = {
  123.     { ngx_string("name"),
  124.       ngx_data_struct_str_handler,
  125.       offsetof(ngx_keyval_t, key) },

  127.     { ngx_string("content"),
  128.       ngx_data_struct_str_handler,
  129.       offsetof(ngx_keyval_t, value) },

  131.       ngx_data_null_decl
  132. };


  135. void
  136. ‌ngx_control_preinit(void)
  137. {
  138.     /*
  139.      * the variable is read before ngx_init_cycle(), which may replace
  140.      * the environment while parsing configuration
  141.      */

  143.     ngx_control_env = (u_char *) getenv(NGX_CTRL_ENV);
  144. }


  147. ngx_int_t
  148. ‌ngx_control_init(u_char *addr)
  149. {
  150.     int        value;
  151.     ngx_fd_t   fd;
  152.     ngx_url_t  u;

  154.     if (addr == NULL) {
  155.         return NGX_OK;
  156.     }

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

  160.     u.url.data = addr;
  161.     u.url.len = ngx_strlen(addr);
  162.     u.listen = 1;

  164.     if (ngx_parse_url(ngx_cycle->pool, &u) != NGX_OK) {
  165.         if (u.err) {
  166.             ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, 0,
  167.                           "control: %s in \"%V\"", u.err, &u.url);
  168.         }

  170.         return NGX_ERROR;
  171.     }

  173. #if (NGX_HAVE_UNIX_DOMAIN)
  174.     if (u.family == AF_UNIX) {
  175.         ngx_memcpy(ngx_control_unix_path, u.host.data, u.host.len);

  177.     } else if (u.no_port || u.last_port) {
  178.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, 0,
  179.                       "control: invalid port in \"%V\"", &u.url);
  180.         return NGX_ERROR;
  181.     }
  182. #else
  183.     if (u.no_port || u.last_port) {
  184.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, 0,
  185.                       "control: invalid port in \"%V\"", &u.url);
  186.         return NGX_ERROR;
  187.     }
  188. #endif

  190.     if (ngx_control_inherit() == NGX_OK) {
  191.         ngx_control_inherited = 1;
  192.         return NGX_OK;
  193.     }

  195.     fd = ngx_socket(u.family, SOCK_STREAM, 0);

  197.     if (fd == -1) {
  198.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  199.                       "control: " ngx_socket_n " failed");
  200.         return NGX_ERROR;
  201.     }

  203.     if (ngx_nonblocking(fd) == -1) {
  204.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  205.                       "control: " ngx_nonblocking_n " failed");
  206.         ngx_close_socket(fd);
  207.         return NGX_ERROR;
  208.     }

  210.     value = 1;

  212.     if (ioctl(fd, FIOASYNC, &value) == -1) {
  213.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  214.                       "control: ioctl(FIOASYNC) failed");
  215.         ngx_close_socket(fd);
  216.         return NGX_ERROR;
  217.     }

  219.     if (fcntl(fd, F_SETOWN, ngx_pid) == -1) {
  220.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  221.                       "control: fcntl(F_SETOWN) failed");
  222.         ngx_close_socket(fd);
  223.         return NGX_ERROR;
  224.     }

  226.     value = 1;

  228.     if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
  229.                    (const void *) &value, sizeof(int))
  230.         == -1)
  231.     {
  232.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  233.                       "control: setsockopt(SO_REUSEADDR) failed");
  234.         ngx_close_socket(fd);
  235.         return NGX_ERROR;
  236.     }

  238.     if (bind(fd, &u.sockaddr.sockaddr, u.socklen) == -1) {
  239.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  240.                       "control: bind() failed");
  241.         ngx_close_socket(fd);
  242.         return NGX_ERROR;
  243.     }

  245. #if (NGX_HAVE_UNIX_DOMAIN)
  246.     if (u.family == AF_UNIX) {
  247.         if (chmod(ngx_control_unix_path, S_IRUSR|S_IWUSR) == -1) {
  248.             ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_errno,
  249.                           "control: chmod() failed");
  250.             ngx_close_socket(fd);
  251.             return NGX_ERROR;
  252.         }
  253.     }
  254. #endif

  256.     if (listen(fd, NGX_LISTEN_BACKLOG) == -1) {
  257.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  258.                       "control: listen() failed");
  259.         ngx_close_socket(fd);
  260.         return NGX_ERROR;
  261.     }

  263.     ngx_control_pollfd[0].fd = fd;
  264.     ngx_control_pollfd[0].events = POLLIN;
  265.     ngx_control_pollfd_n = 1;

  267.     return NGX_OK;
  268. }


  271. void
  272. ‌ngx_control_uninit(void)
  273. {
  274.     ngx_control_close_sockets();

  276.     if (ngx_control_unix_path[0] && ngx_new_binary == 0
  277.         && (!ngx_control_inherited || ngx_getppid() != ngx_parent))
  278.     {
  279.         if (ngx_delete_file(ngx_control_unix_path) == NGX_FILE_ERROR) {
  280.             ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_errno,
  281.                          ngx_delete_file_n " %s failed", ngx_control_unix_path);
  282.         }
  283.     }
  284. }


  287. void
  288. ‌ngx_control_close_sockets(void)
  289. {
  290.     ngx_uint_t  i;

  292.     for (i = 0; i < ngx_control_pollfd_n; i++) {
  293.         ngx_close_socket(ngx_control_pollfd[i].fd);
  294.     }
  295. }


  298. char *
  299. ‌ngx_control_handoff(void)
  300. {
  301.     static u_char  env[sizeof(NGX_CTRL_ENV) + NGX_INT32_LEN + 1];

  303.     if (ngx_control_pollfd_n == 0) {
  304.         return NULL;
  305.     }

  307.     ngx_sprintf(env, NGX_CTRL_ENV "=%d%Z", ngx_control_pollfd[0].fd);

  309.     return (char *) env;
  310. }


  313. void
  314. ‌ngx_control_reown(void)
  315. {
  316.     if (ngx_control_pollfd_n == 0) {
  317.         return;
  318.     }

  320.     if (fcntl(ngx_control_pollfd[0].fd, F_SETOWN, ngx_pid) == -1) {
  321.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_socket_errno,
  322.                       "control: fcntl(F_SETOWN) failed");
  323.     }
  324. }


  327. ngx_int_t
  328. ‌ngx_control_handle_events(void)
  329. {
  330.     int                     ready, revents;
  331.     ngx_uint_t              i, reloaded;
  332.     struct pollfd          *pfd;
  333.     ngx_control_request_t  *r;

  335.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
  336.                    "control: handle events");

  338.     ready = poll(ngx_control_pollfd, ngx_control_pollfd_n, 0);

  340.     if (ready <= 0) {
  341.         if (ready == -1 && ngx_errno != NGX_EINTR) {
  342.             ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
  343.                           "control: poll() failed");
  344.             return NGX_ERROR;
  345.         }

  347.         return NGX_OK;
  348.     }

  350.     reloaded = 0;

  352.     for (i = 0; i < ngx_control_pollfd_n; /* void */) {

  354.         r = &ngx_control_requests[i];
  355.         pfd = &ngx_control_pollfd[i];
  356.         revents = pfd->revents;

  358.         ngx_log_debug4(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
  359.                        "control: i:%ui fd:%d e:%d re:%d",
  360.                        i, pfd->fd, pfd->events, pfd->revents);

  362.         if (i) {
  363.             r->pool->log = ngx_cycle->log;
  364.         }

  366.         if ((revents & (POLLERR|POLLHUP|POLLNVAL)) && i != 0) {
  367.             ngx_control_close(r);
  368.             continue;
  369.         }

  371.         if (revents & POLLIN) {
  372.             if (i == 0) {
  373.                 ngx_control_handle_accept();
  374.                 i++;
  375.                 continue;
  376.             }

  378.             if (ngx_control_handle_read(r) != NGX_AGAIN) {
  379.                 reloaded |= r->reloaded;
  380.                 ngx_control_close(r);
  381.                 continue;
  382.             }

  384.             reloaded |= r->reloaded;
  385.         }

  387.         if (revents & POLLOUT) {
  388.             if (ngx_control_handle_write(r) != NGX_AGAIN) {
  389.                 ngx_control_close(r);
  390.                 continue;
  391.             }
  392.         }

  394.         i++;
  395.     }

  397.     return reloaded ? NGX_DONE : NGX_OK;
  398. }


  401. static ngx_int_t
  402. ‌ngx_control_inherit(void)
  403. {
  404.     u_char    *env;
  405.     ngx_fd_t   fd;

  407.     env = ngx_control_env;
  408.     if (env == NULL) {
  409.         return NGX_DECLINED;
  410.     }

  412.     fd = ngx_atoi(env, ngx_strlen(env));
  413.     if (fd == NGX_ERROR) {
  414.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  415.                       "control: invalid " NGX_CTRL_ENV " value \"%s\"", env);
  416.         return NGX_ERROR;
  417.     }

  419.     if (fcntl(fd, F_SETOWN, ngx_pid) == -1) {
  420.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_socket_errno,
  421.                       "control: fcntl(F_SETOWN) failed");
  422.         ngx_close_socket(fd);
  423.         return NGX_ERROR;
  424.     }

  426.     ngx_control_pollfd[0].fd = fd;
  427.     ngx_control_pollfd[0].events = POLLIN;
  428.     ngx_control_pollfd_n = 1;

  430.     return NGX_OK;
  431. }


  434. static void
  435. ‌ngx_control_close(ngx_control_request_t *r)
  436. {
  437.     ngx_uint_t  i;

  439.     i = r->index;

  441.     ngx_close_socket(r->fd);

  443.     ngx_destroy_pool(r->pool);

  445.     if (i + 1 < ngx_control_pollfd_n) {
  446.         ngx_memmove(&ngx_control_pollfd[i], &ngx_control_pollfd[i + 1],
  447.                     (ngx_control_pollfd_n - (i + 1)) * sizeof(struct pollfd));
  448.         ngx_memmove(&ngx_control_requests[i], &ngx_control_requests[i + 1],
  449.             (ngx_control_pollfd_n - (i + 1)) * sizeof(ngx_control_request_t));

  451.         for (/* void */; i < ngx_control_pollfd_n - 1; i++) {
  452.             ngx_control_requests[i].index--;
  453.         }
  454.     }

  456.     ngx_control_pollfd_n--;
  457. }


  460. static void
  461. ‌ngx_control_handle_accept(void)
  462. {
  463.     int                     value;
  464.     ngx_fd_t                fd;
  465.     ngx_err_t               err;
  466.     struct pollfd          *pfd;
  467.     ngx_control_request_t  *r;

  469.     for ( ;; ) {
  470.         fd = accept(ngx_control_pollfd[0].fd, NULL, NULL);

  472.         if (fd == -1) {
  473.             err = ngx_socket_errno;

  475.             if (err == NGX_EAGAIN) {
  476.                 return;
  477.             }

  479.             ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, err,
  480.                           "control: accept() failed");

  482.             if (err == NGX_ECONNABORTED) {
  483.                 continue;
  484.             }

  486.             return;
  487.         }

  489.         if (ngx_control_pollfd_n == NGX_CTRL_MAX_FD) {
  490.             ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0,
  491.                           "control: too many client connections");
  492.             /* close the oldest connection */
  493.             r = &ngx_control_requests[1];
  494.             r->pool->log = ngx_cycle->log;
  495.             ngx_control_close(r);
  496.         }

  498.         r = &ngx_control_requests[ngx_control_pollfd_n];
  499.         ngx_memzero(r, sizeof(ngx_control_request_t));
  500.         r->fd = fd;

  502.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
  503.                        "control accept fd:%d", r->fd);

  505.         if (fcntl(r->fd, F_SETFD, FD_CLOEXEC) == -1) {
  506.             ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, ngx_socket_errno,
  507.                           "control: fcntl(FD_CLOEXEC) failed");
  508.             ngx_close_socket(r->fd);
  509.             continue;
  510.         }

  512.         if (ngx_nonblocking(r->fd) == -1) {
  513.             ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, ngx_socket_errno,
  514.                           "control: " ngx_nonblocking_n " failed");
  515.             ngx_close_socket(r->fd);
  516.             continue;
  517.         }

  519.         value = 1;

  521.         if (ioctl(r->fd, FIOASYNC, &value) == -1) {
  522.             ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, ngx_socket_errno,
  523.                           "control: ioctl(FIOASYNC) failed");
  524.             ngx_close_socket(r->fd);
  525.             continue;
  526.         }

  528.         if (fcntl(r->fd, F_SETOWN, ngx_pid) == -1) {
  529.             ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, ngx_socket_errno,
  530.                           "control: fcntl(F_SETOWN) failed");
  531.             ngx_close_socket(r->fd);
  532.             continue;
  533.         }

  535.         pfd = &ngx_control_pollfd[ngx_control_pollfd_n];
  536.         ngx_memzero(pfd, sizeof(struct pollfd));
  537.         pfd->fd = r->fd;
  538.         pfd->events = POLLIN;
  539.         pfd->revents = POLLIN;

  541.         r->pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, ngx_cycle->log);
  542.         if (r->pool == NULL) {
  543.             ngx_close_socket(r->fd);
  544.             continue;
  545.         }

  547.         r->in = ngx_create_temp_buf(r->pool, NGX_CTRL_MAX_REQUEST);
  548.         if (r->in == NULL) {
  549.             ngx_destroy_pool(r->pool);
  550.             ngx_close_socket(r->fd);
  551.             continue;
  552.         }

  554.         r->index = ngx_control_pollfd_n++;
  555.     }
  556. }


  559. static ngx_int_t
  560. ‌ngx_control_handle_read(ngx_control_request_t *r)
  561. {
  562.     ssize_t     n;
  563.     ngx_buf_t  *b;

  565.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
  566.                    "control: read fd:%d", r->fd);

  568.     b = r->in;

  570.     n = recv(r->fd, b->last, b->end - b->last, 0);

  572.     if (n < 0) {
  573.         if (ngx_errno == NGX_EAGAIN) {
  574.             return NGX_AGAIN;
  575.         }

  577.         ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, ngx_socket_errno,
  578.                       "control: recv() failed");
  579.         return NGX_ERROR;
  580.     }

  582.     if (n == 0) {
  583.         return NGX_DONE;
  584.     }

  586.     b->last += n;

  588.     switch (ngx_control_parse_request_line(r)) {

  590.     case NGX_AGAIN:
  591.         if (b->last == b->end) {
  592.             ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0,
  593.                           "control: request too large");
  594.             ngx_control_pollfd[r->index].events &= ~POLLIN;
  595.             return ngx_control_send_response(r, NGX_CTRL_BAD_REQUEST, NULL);
  596.         }

  598.         return NGX_AGAIN;

  600.     case NGX_DECLINED:
  601.         ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0,
  602.                       "control: failed to parse request");
  603.         ngx_control_pollfd[r->index].events &= ~POLLIN;
  604.         return ngx_control_send_response(r, NGX_CTRL_BAD_REQUEST, NULL);

  606.     case NGX_DONE:
  607.         ngx_control_pollfd[r->index].events &= ~POLLIN;
  608.         return ngx_control_content(r);

  610.     default:
  611.         ngx_control_pollfd[r->index].events &= ~POLLIN;
  612.         return NGX_ERROR;
  613.     }
  614. }


  617. static ngx_int_t
  618. ‌ngx_control_content(ngx_control_request_t *r)
  619. {
  620.     u_char  *p;
  621.     size_t   len;

  623.     static const char  *root_endpoints[] = { "1" };
  624.     static const char  *api_endpoints[] = { "control", "nginx" };
  625.     static const char  *control_endpoints[] = { "processes", "config" };

  627.     p = r->path.data;
  628.     len = r->path.len;

  630.     if (len > 1 && p[len - 1] == '/') {
  631.         r->path.len = --len;
  632.     }

  634.     /* the path always starts with "/" */

  636.     switch (len) {
  637.     case 1:
  638.         if (r->method != NGX_CTRL_GET) {
  639.             return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  640.         }

  642.         return ngx_control_api_endpoints(r, root_endpoints, 1);

  644.     case 2:
  645.         if (ngx_strncmp(p, "/1", len) == 0) {
  646.             if (r->method != NGX_CTRL_GET) {
  647.                 return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  648.             }

  650.             return ngx_control_api_endpoints(r, api_endpoints, 2);
  651.         }

  653.         break;

  655.     case 8:
  656.         if (ngx_strncmp(p, "/1/nginx", len) == 0) {
  657.             if (r->method != NGX_CTRL_GET) {
  658.                 return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  659.             }

  661.             return ngx_control_show_version(r);
  662.         }

  664.         break;

  666.     case 10:
  667.         if (ngx_strncmp(p, "/1/control", len) == 0) {
  668.             if (r->method != NGX_CTRL_GET) {
  669.                 return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  670.             }

  672.             return ngx_control_api_endpoints(r, control_endpoints, 2);
  673.         }

  675.         break;

  677.     case 17:
  678.         if (ngx_strncmp(p, "/1/control/config", len) == 0) {
  679.             if (r->method == NGX_CTRL_PATCH) {
  680.                 return ngx_control_reload_config(r);
  681.             }

  683.             if (r->method == NGX_CTRL_GET) {
  684.                 return ngx_control_print_config(r);
  685.             }

  687.             return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  688.         }

  690.         break;

  692.     case 20:
  693.         if (ngx_strncmp(p, "/1/control/processes", len) == 0) {
  694.             if (r->method != NGX_CTRL_GET) {
  695.                 return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  696.             }

  698.             return ngx_control_show_processes(r);
  699.         }

  701.         break;
  702.     }

  704.     return ngx_control_send_response(r, NGX_CTRL_NOT_FOUND, NULL);
  705. }


  708. static char *
  709. ‌ngx_control_status_text(ngx_uint_t code)
  710. {
  711.     switch (code) {
  712.     case NGX_CTRL_OK:
  713.         return "OK";
  714.     case NGX_CTRL_BAD_REQUEST:
  715.         return "Bad Request";
  716.     case NGX_CTRL_NOT_FOUND:
  717.         return "Not Found";
  718.     case NGX_CTRL_NOT_ALLOWED:
  719.         return "Not Allowed";
  720.     case NGX_CTRL_UNPROCESSABLE:
  721.         return "Unprocessable Entity";
  722.     case NGX_CTRL_INTERNAL_ERROR:
  723.         return "Internal Server Error";
  724.     default:
  725.         return "";
  726.     }
  727. }


  730. static ngx_int_t
  731. ‌ngx_control_send_response(ngx_control_request_t *r, ngx_uint_t code,
  732.     ngx_buf_t *body)
  733. {
  734.     char         *status;
  735.     ngx_uint_t    n;
  736.     ngx_chain_t  *c;

  738.     const char  response_fmt[] =
  739.         "HTTP/1.1 %03ui %s\r\n"
  740.         "Server: " NGINX_VER "\r\n"
  741.         "Connection: close\r\n"
  742.         "Content-Type: application/json\r\n"
  743.         "Content-Length: %ui\r\n"
  744.         "\r\n";

  746.     c = ngx_alloc_chain_link(r->pool);
  747.     if (c == NULL) {
  748.         return NGX_ERROR;
  749.     }

  751.     status = ngx_control_status_text(code);

  753.     c->buf = ngx_create_temp_buf(r->pool,
  754.                 sizeof(response_fmt) + 2 * NGX_INT_T_LEN + ngx_strlen(status));
  755.     if (c->buf == NULL) {
  756.         return NGX_ERROR;
  757.     }

  759.     c->next = NULL;

  761.     n = body ? body->last - body->pos : 0;

  763.     c->buf->last = ngx_sprintf(c->buf->pos, response_fmt, code, status, n);

  765.     if (body) {
  766.         c->next = ngx_alloc_chain_link(r->pool);
  767.         if (c->next == NULL) {
  768.             return NGX_ERROR;
  769.         }

  771.         c->next->buf = body;
  772.         c->next->next = NULL;
  773.     }

  775.     r->out = c;

  777.     return ngx_control_handle_write(r);
  778. }


  781. static ngx_int_t
  782. ‌ngx_control_handle_write(ngx_control_request_t *r)
  783. {
  784.     ssize_t       n;
  785.     ngx_buf_t    *b;
  786.     ngx_chain_t  *c;

  788.     for (c = r->out; c != NULL; c = c->next) {
  789.         b = c->buf;

  791.         while (b && b->pos < b->last) {
  792.             n = send(r->fd, b->pos, b->last - b->pos, 0);

  794.             if (n <= 0) {
  795.                 if (n == -1 && ngx_errno == NGX_EAGAIN) {
  796.                     ngx_control_pollfd[r->index].events |= POLLOUT;
  797.                     return NGX_AGAIN;
  798.                 }

  800.                 ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, ngx_socket_errno,
  801.                               "control: send() failed");
  802.                 return NGX_ERROR;
  803.             }

  805.             b->pos += n;

  807.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
  808.                            "control: wrote %i bytes", n);
  809.         }
  810.     }

  812.     return NGX_DONE;
  813. }


  816. static ngx_int_t
  817. ‌ngx_control_send_json(ngx_control_request_t *r, ngx_int_t code,
  818.     ngx_data_item_t *obj)
  819. {
  820.     ngx_buf_t  *b;

  822.     b = ngx_json_render(r->pool, obj);
  823.     if (b == NULL) {
  824.         return NGX_ERROR;
  825.     }

  827.     return ngx_control_send_response(r, code, b);
  828. }


  831. static ngx_int_t
  832. ‌ngx_control_api_endpoints(ngx_control_request_t *r, const char **paths,
  833.     ngx_int_t npaths)
  834. {
  835.     ngx_int_t         i;
  836.     ngx_str_t         p;
  837.     ngx_data_item_t  *json, *path;

  839.     if (r->method != NGX_CTRL_GET) {
  840.         return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  841.     }

  843.     json = ngx_data_new_list(r->pool);
  844.     if (json == NULL) {
  845.         return NGX_ERROR;
  846.     }

  848.     for (i = 0; i < npaths; i++) {
  849.         p.data = (u_char *) paths[i];
  850.         p.len = ngx_strlen(paths[i]);

  852.         path = ngx_data_string_handler((uintptr_t) &p, r->pool, NULL);
  853.         if (path == NULL) {
  854.             return NGX_ERROR;
  855.         }

  857.         ngx_data_add_item(json, NULL, path);
  858.     }

  860.     return ngx_control_send_json(r, NGX_CTRL_OK, (ngx_data_item_t *) json);
  861. }


  864. static ngx_int_t
  865. ‌ngx_control_show_processes(ngx_control_request_t *r)
  866. {
  867.     ngx_int_t               i;
  868.     ngx_data_item_t        *process_list, *obj;
  869.     ngx_control_process_t   process;

  871.     process_list = ngx_data_new_list(r->pool);
  872.     if (process_list == NULL) {
  873.         return NGX_ERROR;
  874.     }

  876.     for (i = 0; i < ngx_last_process; i++) {
  877.         if (ngx_processes[i].pid == -1) {
  878.             continue;
  879.         }

  881.         process.name.data = (u_char *) ngx_processes[i].name;
  882.         process.name.len = ngx_strlen(process.name.data);
  883.         process.pid = ngx_processes[i].pid;
  884.         process.exiting = ngx_processes[i].exiting;

  886.         obj = ngx_data_obj_handler((uintptr_t) ngx_control_process_fields,
  887.                                    r->pool, &process);
  888.         if (obj == NULL) {
  889.             return NGX_ERROR;
  890.         }

  892.         ngx_data_add_item(process_list, NULL, obj);
  893.     }

  895.     return ngx_control_send_json(r, NGX_CTRL_OK, process_list);
  896. }


  899. static ngx_int_t
  900. ‌ngx_control_show_version(ngx_control_request_t *r)
  901. {
  902.     ngx_data_item_t  *resp;

  904.     resp = ngx_data_obj_handler((uintptr_t) ngx_control_status_fields, r->pool,
  905.                                 NULL);
  906.     if (resp == NULL) {
  907.         return NGX_ERROR;
  908.     }

  910.     return ngx_control_send_json(r, NGX_CTRL_OK, resp);
  911. }


  914. static ngx_int_t
  915. ‌ngx_control_print_config(ngx_control_request_t *r)
  916. {
  917.     ngx_uint_t        i;
  918.     ngx_keyval_t      item;
  919.     ngx_data_item_t  *list, *obj;
  920.     ngx_conf_dump_t  *dump;

  922.     list = ngx_data_new_list(r->pool);
  923.     if (list == NULL) {
  924.         return NGX_ERROR;
  925.     }

  927.     dump = ngx_cycle->config_dump.elts;

  929.     for (i = 0; i < ngx_cycle->config_dump.nelts; i++) {

  931.         item.key = dump[i].name;
  932.         item.value.data = dump[i].buffer->pos;
  933.         item.value.len = dump[i].buffer->last - dump[i].buffer->pos;

  935.         obj = ngx_data_obj_handler((uintptr_t) ngx_control_config_fields,
  936.                                    r->pool, &item);
  937.         if (obj == NULL) {
  938.             return NGX_ERROR;
  939.         }

  941.         ngx_data_add_item(list, NULL, obj);
  942.     }

  944.     return ngx_control_send_json(r, NGX_CTRL_OK, list);
  945. }


  948. static ngx_data_item_t *
  949. ‌ngx_control_json_logs(ngx_array_t *logs)
  950. {
  951.     ngx_str_t        *l;
  952.     ngx_uint_t        i;
  953.     ngx_data_item_t  *obj, *log_list, *log;

  955.     static ngx_str_t  logs_field = ngx_string("logs");

  957.     obj = ngx_data_new_object(logs->pool);
  958.     if (obj == NULL) {
  959.         return NULL;
  960.     }

  962.     log_list = ngx_data_new_list(logs->pool);
  963.     if (log_list == NULL) {
  964.         return NULL;
  965.     }

  967.     l = logs->elts;
  968.     for (i = 0; i < logs->nelts; i++) {
  969.         log = ngx_data_string_handler((uintptr_t) &l[i], logs->pool, NULL);
  970.         if (log == NULL) {
  971.             return NULL;
  972.         }

  974.         ngx_data_add_item(log_list, NULL, log);
  975.     }

  977.     ngx_data_add_item(obj, &logs_field, log_list);

  979.     return obj;
  980. }


  983. static ngx_int_t
  984. ‌ngx_control_reload_config(ngx_control_request_t *r)
  985. {
  986.     ngx_int_t         status;
  987.     ngx_log_t         log, *tmp;
  988.     ngx_cycle_t      *cycle;
  989.     ngx_array_t       log_store;
  990.     ngx_data_item_t  *obj;

  992.     status = NGX_CTRL_OK;

  994.     if (ngx_array_init(&log_store, r->pool, 3, sizeof(ngx_str_t)) != NGX_OK) {
  995.         return NGX_ERROR;
  996.     }

  998.     ngx_memzero(&log, sizeof(ngx_log_t));
  999.     log.wdata = &log_store;
  1000.     log.writer = ngx_control_log_capture;
  1001.     log.log_level = NGX_LOG_DEBUG;

  1003.     tmp = ngx_cycle->log;
  1004.     log.next = tmp;
  1005.     ngx_cycle->log = &log;
  1006.     cycle = ngx_init_cycle((ngx_cycle_t *) ngx_cycle);

  1008.     if (cycle == NULL) {
  1009.         status = NGX_CTRL_UNPROCESSABLE;
  1010.         ngx_cycle->log = tmp;

  1012.     } else {
  1013.         ngx_cycle = cycle;
  1014.         r->reloaded = 1;
  1015.         r->pool->log = ngx_cycle->log;
  1016.     }

  1018.     obj = ngx_control_json_logs(&log_store);
  1019.     if (obj == NULL) {
  1020.         return NGX_ERROR;
  1021.     }

  1023.     return ngx_control_send_json(r, status, obj);
  1024. }


  1027. static void
  1028. ‌ngx_control_log_capture(ngx_log_t *log, ngx_uint_t lvl, u_char *buf, size_t len)
  1029. {
  1030.     u_char       *log_data;
  1031.     ngx_str_t    *log_str;
  1032.     ngx_array_t  *store;

  1034.     if (lvl > NGX_LOG_WARN) {
  1035.         return;
  1036.     }

  1038.     store = log->wdata;

  1040.     log_data = ngx_pnalloc(store->pool, len);
  1041.     if (log_data == NULL) {
  1042.         return;
  1043.     }

  1045.     log_str = ngx_array_push(store);
  1046.     if (log_str == NULL) {
  1047.         return;
  1048.     }

  1050.     ngx_memcpy(log_data, buf, len);

  1052.     log_str->data = log_data;
  1053.     log_str->len = len;
  1054. }


  1057. static ngx_int_t
  1058. ‌ngx_control_parse_request_line(ngx_control_request_t *r)
  1059. {
  1060.     static uint32_t  usual[] = {
  1061.         0x00000000, /* 0000 0000 0000 0000  0000 0000 0000 0000 */
  1062.                     /* ?>=< ;:98 7654 3210  /.-, +*)( '&%$ #"!  */
  1063.         0x7fff37d6, /* 0111 1111 1111 1111  0011 0111 1101 0110 */
  1064.                     /* _^]\ [ZYX WVUT SRQP  ONML KJIH GFED CBA@ */
  1065.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  1066.                     /*  ~}| {zyx wvut srqp  onml kjih gfed cba` */
  1067.         0x7fffffff, /* 0111 1111 1111 1111  1111 1111 1111 1111 */
  1068.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  1069.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  1070.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  1071.         0xffffffff  /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  1072.     };

  1074.     u_char      c, ch, *p;
  1075.     ngx_buf_t  *b;
  1076. ‌    enum {
  1077.         sw_start = 0,
  1078.         sw_method,
  1079.         sw_spaces_before_uri,
  1080.         sw_schema,
  1081.         sw_schema_slash,
  1082.         sw_schema_slash_slash,
  1083.         sw_spaces_before_host,
  1084.         sw_host_start,
  1085.         sw_host,
  1086.         sw_host_end,
  1087.         sw_host_ip_literal,
  1088.         sw_port_start,
  1089.         sw_port,
  1090.         sw_uri,
  1091.         sw_http_,
  1092.         sw_http_H,
  1093.         sw_http_HT,
  1094.         sw_http_HTT,
  1095.         sw_http_HTTP,
  1096.         sw_first_major_digit,
  1097.         sw_major_digit,
  1098.         sw_first_minor_digit,
  1099.         sw_minor_digit,
  1100.         sw_almost_done
  1101.     } state;

  1103.     b = r->in;
  1104.     state = r->state;

  1106.     for (p = b->pos; p < b->last; p++) {
  1107.         ch = *p;

  1109.         switch (state) {
  1110.         /* HTTP methods: GET, PATCH */
  1111.         case sw_start:
  1112.             if ((ch < 'A' || ch > 'Z') && ch != '_' && ch != '-') {
  1113.                 return NGX_DECLINED;
  1114.             }

  1116.             state = sw_method;

  1118.             break;

  1120.         case sw_method:
  1121.             if (ch == ' ') {
  1122.                 state = sw_spaces_before_uri;

  1124.                 switch (p - b->start) {
  1125.                 case 3:
  1126.                     if (ngx_strncmp(b->start, "GET", 3) == 0) {
  1127.                         r->method = NGX_CTRL_GET;
  1128.                         break;
  1129.                     }
  1130.                     break;

  1132.                 case 5:
  1133.                     if (ngx_strncmp(b->start, "PATCH", 5) == 0) {
  1134.                         r->method = NGX_CTRL_PATCH;
  1135.                         break;
  1136.                     }
  1137.                     break;
  1138.                 }

  1140.                 break;
  1141.             }

  1143.             if ((ch < 'A' || ch > 'Z') && ch != '_' && ch != '-') {
  1144.                 return NGX_DECLINED;
  1145.             }

  1147.             break;

  1149.         /* space* before URI */
  1150.         case sw_spaces_before_uri:
  1151.             if (ch == '/') {
  1152.                 r->path.data = p;
  1153.                 state = sw_uri;
  1154.                 break;
  1155.             }

  1157.             c = (u_char) (ch | 0x20);
  1158.             if (c >= 'a' && c <= 'z') {
  1159.                 state = sw_schema;
  1160.                 break;
  1161.             }

  1163.             if (ch != ' ') {
  1164.                 return NGX_DECLINED;
  1165.             }

  1167.             break;

  1169.         case sw_schema:
  1170.             c = (u_char) (ch | 0x20);
  1171.             if (c >= 'a' && c <= 'z') {
  1172.                 break;
  1173.             }

  1175.             if ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')
  1176.             {
  1177.                 break;
  1178.             }

  1180.             if (ch != ':') {
  1181.                 return NGX_DECLINED;
  1182.             }

  1184.             state = sw_schema_slash;
  1185.             break;

  1187.         case sw_schema_slash:
  1188.             if (ch != '/') {
  1189.                 return NGX_DECLINED;
  1190.             }

  1192.             state = sw_schema_slash_slash;
  1193.             break;

  1195.         case sw_schema_slash_slash:
  1196.             if (ch != '/') {
  1197.                 return NGX_DECLINED;
  1198.             }

  1200.             state = sw_host_start;
  1201.             break;

  1203.         case sw_spaces_before_host:
  1204.             if (ch == ' ') {
  1205.                 break;
  1206.             }
  1207.             /* fall through */

  1209.         case sw_host_start:
  1210.             if (ch == '[') {
  1211.                 state = sw_host_ip_literal;
  1212.                 break;
  1213.             }

  1215.             state = sw_host;
  1216.             /* fall through */

  1218.         case sw_host:
  1219.             c = (u_char) (ch | 0x20);
  1220.             if (c >= 'a' && c <= 'z') {
  1221.                 break;
  1222.             }

  1224.             if ((ch >= '0' && ch <= '9') || ch == '.' || ch == '-') {
  1225.                 break;
  1226.             }
  1227.             /* fall through */

  1229.         case sw_host_end:
  1230.             if (ch == ':') {
  1231.                 state = sw_port_start;
  1232.                 break;
  1233.             }

  1235.             /* if we supported CONNECT verb we would need to decline here */

  1237.             switch (ch) {
  1238.             case '/':
  1239.                 r->path.data = p;
  1240.                 state = sw_uri;
  1241.                 break;
  1242.             /* empty path cases */
  1243.             case '?':
  1244.                 ngx_str_set(&r->path, "/");
  1245.                 state = sw_uri;
  1246.                 break;
  1247.             case ' ':
  1248.                 ngx_str_set(&r->path, "/");
  1249.                 state = sw_http_;
  1250.                 break;
  1251.             }
  1252.             break;

  1254.         case sw_host_ip_literal:
  1255.             if (ch >= '0' && ch <= '9') {
  1256.                 break;
  1257.             }

  1259.             c = (u_char) (ch | 0x20);
  1260.             if (c >= 'a' && c <= 'z') {
  1261.                 break;
  1262.             }

  1264.             switch (ch) {
  1265.             case ':':
  1266.                 break;
  1267.             case ']':
  1268.                 state = sw_host_end;
  1269.                 break;
  1270.             case '-':
  1271.             case '.':
  1272.             case '_':
  1273.             case '~':
  1274.                 /* unreserved */
  1275.                 break;
  1276.             case '!':
  1277.             case '$':
  1278.             case '&':
  1279.             case '\'':
  1280.             case '(':
  1281.             case ')':
  1282.             case '*':
  1283.             case '+':
  1284.             case ',':
  1285.             case ';':
  1286.             case '=':
  1287.                 /* sub-delims */
  1288.                 break;
  1289.             default:
  1290.                 return NGX_DECLINED;
  1291.             }
  1292.             break;

  1294.         case sw_port_start:
  1295.             state = sw_port;

  1297.             if (ch >= '0' && ch <= '9') {
  1298.                 break;
  1299.             }

  1301.             /* if we supported CONNECT verb we would need to decline here */

  1303.             /* fall through */

  1305.         case sw_port:
  1306.             if (ch >= '0' && ch <= '9') {
  1307.                 break;
  1308.             }

  1310.             switch (ch) {
  1311.             case '/':
  1312.                 r->path.data = p;
  1313.                 state = sw_uri;
  1314.                 break;
  1315.             /* empty path cases */
  1316.             case '?':
  1317.                 ngx_str_set(&r->path, "/");
  1318.                 state = sw_uri;
  1319.                 break;
  1320.             case ' ':
  1321.                 ngx_str_set(&r->path, "/");
  1322.                 state = sw_http_;
  1323.                 break;
  1324.             default:
  1325.                 return NGX_DECLINED;
  1326.             }
  1327.             break;

  1329.         /* URI */
  1330.         case sw_uri:
  1331.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1332.                 break;
  1333.             }

  1335.             switch (ch) {
  1336.             case ' ':
  1337.                 state = sw_http_;
  1338.                 /* fall through */
  1339.             case '?':
  1340.                 if (r->path.len == 0) {
  1341.                     r->path.len = p - r->path.data;
  1342.                 }
  1343.                 break;

  1345.             case '.':
  1346.             case '%':
  1347.             case '#':
  1348.             case '+':
  1349.             case 0x7f:
  1350.                 return NGX_DECLINED;
  1351.             default:
  1352.                 if (ch < 0x20) {
  1353.                     return NGX_DECLINED;
  1354.                 }
  1355.                 break;
  1356.             }
  1357.             break;

  1359.         /* space+ after URI */
  1360.         case sw_http_:
  1361.             switch (ch) {
  1362.             case ' ':
  1363.                 break;
  1364.             case 'H':
  1365.                 state = sw_http_H;
  1366.                 break;
  1367.             default:
  1368.                 return NGX_DECLINED;
  1369.             }
  1370.             break;

  1372.         case sw_http_H:
  1373.             switch (ch) {
  1374.             case 'T':
  1375.                 state = sw_http_HT;
  1376.                 break;
  1377.             default:
  1378.                 return NGX_DECLINED;
  1379.             }
  1380.             break;

  1382.         case sw_http_HT:
  1383.             switch (ch) {
  1384.             case 'T':
  1385.                 state = sw_http_HTT;
  1386.                 break;
  1387.             default:
  1388.                 return NGX_DECLINED;
  1389.             }
  1390.             break;

  1392.         case sw_http_HTT:
  1393.             switch (ch) {
  1394.             case 'P':
  1395.                 state = sw_http_HTTP;
  1396.                 break;
  1397.             default:
  1398.                 return NGX_DECLINED;
  1399.             }
  1400.             break;

  1402.         case sw_http_HTTP:
  1403.             switch (ch) {
  1404.             case '/':
  1405.                 state = sw_first_major_digit;
  1406.                 break;
  1407.             default:
  1408.                 return NGX_DECLINED;
  1409.             }
  1410.             break;

  1412.         /* first digit of major HTTP version */
  1413.         case sw_first_major_digit:
  1414.             if (ch != '1') {
  1415.                 return NGX_DECLINED;
  1416.             }

  1418.             state = sw_major_digit;
  1419.             break;

  1421.         /* major HTTP version or dot */
  1422.         case sw_major_digit:
  1423.             if (ch == '.') {
  1424.                 state = sw_first_minor_digit;
  1425.                 break;
  1426.             } else {
  1427.                 /* major versions other than 1 are not supported */
  1428.                 return NGX_DECLINED;
  1429.             }

  1431.         /* first digit of minor HTTP version */
  1432.         case sw_first_minor_digit:
  1433.             if (ch != '0' && ch != '1') {
  1434.                 return NGX_DECLINED;
  1435.             }

  1437.             state = sw_minor_digit;
  1438.             break;

  1440.         /* minor HTTP version or end of request line */
  1441.         case sw_minor_digit:
  1442.             if (ch == CR) {
  1443.                 state = sw_almost_done;
  1444.                 break;

  1446.             } else if (ch == LF) {
  1447.                 goto done;

  1449.             } else {
  1450.                 /* support only 1.1 or 1.0 */
  1451.                 return NGX_DECLINED;
  1452.             }

  1454.         /* end of request line */
  1455.         case sw_almost_done:
  1456.             switch (ch) {
  1457.             case LF:
  1458.                 goto done;
  1459.             default:
  1460.                 return NGX_DECLINED;
  1461.             }
  1462.         }
  1463.     }

  1465.     b->pos = p;
  1466.     r->state = state;

  1468.     return NGX_AGAIN;

  1470. done:
  1471.     b->pos = p + 1;
  1472.     r->state = sw_start;

  1474.     return NGX_DONE;
  1475. }

One Level Up Top Level