One Level Up Top Level

src/os/unix/ngx_control.c - nginx-1.31.7 nginx/ @ 939334eff

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        reuseaddr;
  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 (fcntl(fd, F_SETFL, O_ASYNC|O_NONBLOCK) == -1) {
  204.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  205.                       "control: fcntl(O_ASYNC|O_NONBLOCK) failed");
  206.         ngx_close_socket(fd);
  207.         return NGX_ERROR;
  208.     }

  210.     if (fcntl(fd, F_SETOWN, ngx_pid) == -1) {
  211.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  212.                       "control: fcntl(F_SETOWN) failed");
  213.         ngx_close_socket(fd);
  214.         return NGX_ERROR;
  215.     }

  217.     reuseaddr = 1;

  219.     if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
  220.                    (const void *) &reuseaddr, sizeof(int))
  221.         == -1)
  222.     {
  223.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  224.                       "control: setsockopt(SO_REUSEADDR) failed");
  225.         ngx_close_socket(fd);
  226.         return NGX_ERROR;
  227.     }

  229.     if (bind(fd, &u.sockaddr.sockaddr, u.socklen) == -1) {
  230.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  231.                       "control: bind() failed");
  232.         ngx_close_socket(fd);
  233.         return NGX_ERROR;
  234.     }

  236. #if (NGX_HAVE_UNIX_DOMAIN)
  237.     if (u.family == AF_UNIX) {
  238.         if (chmod(ngx_control_unix_path, S_IRUSR|S_IWUSR) == -1) {
  239.             ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_errno,
  240.                           "control: chmod() failed");
  241.             ngx_close_socket(fd);
  242.             return NGX_ERROR;
  243.         }
  244.     }
  245. #endif

  247.     if (listen(fd, NGX_LISTEN_BACKLOG) == -1) {
  248.         ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_socket_errno,
  249.                       "control: listen() failed");
  250.         ngx_close_socket(fd);
  251.         return NGX_ERROR;
  252.     }

  254.     ngx_control_pollfd[0].fd = fd;
  255.     ngx_control_pollfd[0].events = POLLIN;
  256.     ngx_control_pollfd_n = 1;

  258.     return NGX_OK;
  259. }


  262. void
  263. ‌ngx_control_uninit(void)
  264. {
  265.     ngx_control_close_sockets();

  267.     if (ngx_control_unix_path[0] && ngx_new_binary == 0
  268.         && (!ngx_control_inherited || ngx_getppid() != ngx_parent))
  269.     {
  270.         if (ngx_delete_file(ngx_control_unix_path) == NGX_FILE_ERROR) {
  271.             ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_errno,
  272.                          ngx_delete_file_n " %s failed", ngx_control_unix_path);
  273.         }
  274.     }
  275. }


  278. void
  279. ‌ngx_control_close_sockets(void)
  280. {
  281.     ngx_uint_t  i;

  283.     for (i = 0; i < ngx_control_pollfd_n; i++) {
  284.         ngx_close_socket(ngx_control_pollfd[i].fd);
  285.     }
  286. }


  289. char *
  290. ‌ngx_control_handoff(void)
  291. {
  292.     static u_char  env[sizeof(NGX_CTRL_ENV) + NGX_INT32_LEN + 1];

  294.     if (ngx_control_pollfd_n == 0) {
  295.         return NULL;
  296.     }

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

  300.     return (char *) env;
  301. }


  304. void
  305. ‌ngx_control_reown(void)
  306. {
  307.     if (ngx_control_pollfd_n == 0) {
  308.         return;
  309.     }

  311.     if (fcntl(ngx_control_pollfd[0].fd, F_SETOWN, ngx_pid) == -1) {
  312.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_socket_errno,
  313.                       "control: fcntl(F_SETOWN) failed");
  314.     }
  315. }


  318. ngx_int_t
  319. ‌ngx_control_handle_events(void)
  320. {
  321.     int                     ready, revents;
  322.     ngx_uint_t              i, reloaded;
  323.     struct pollfd          *pfd;
  324.     ngx_control_request_t  *r;

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

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

  331.     if (ready <= 0) {
  332.         if (ready == -1 && ngx_errno != NGX_EINTR) {
  333.             ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
  334.                           "control: poll() failed");
  335.             return NGX_ERROR;
  336.         }

  338.         return NGX_OK;
  339.     }

  341.     reloaded = 0;

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

  345.         r = &ngx_control_requests[i];
  346.         pfd = &ngx_control_pollfd[i];
  347.         revents = pfd->revents;

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

  353.         if (i) {
  354.             r->pool->log = ngx_cycle->log;
  355.         }

  357.         if ((revents & (POLLERR|POLLHUP|POLLNVAL)) && i != 0) {
  358.             ngx_control_close(r);
  359.             continue;
  360.         }

  362.         if (revents & POLLIN) {
  363.             if (i == 0) {
  364.                 ngx_control_handle_accept();
  365.                 i++;
  366.                 continue;
  367.             }

  369.             if (ngx_control_handle_read(r) != NGX_AGAIN) {
  370.                 reloaded |= r->reloaded;
  371.                 ngx_control_close(r);
  372.                 continue;
  373.             }

  375.             reloaded |= r->reloaded;
  376.         }

  378.         if (revents & POLLOUT) {
  379.             if (ngx_control_handle_write(r) != NGX_AGAIN) {
  380.                 ngx_control_close(r);
  381.                 continue;
  382.             }
  383.         }

  385.         i++;
  386.     }

  388.     return reloaded ? NGX_DONE : NGX_OK;
  389. }


  392. static ngx_int_t
  393. ‌ngx_control_inherit(void)
  394. {
  395.     u_char    *env;
  396.     ngx_fd_t   fd;

  398.     env = ngx_control_env;
  399.     if (env == NULL) {
  400.         return NGX_DECLINED;
  401.     }

  403.     fd = ngx_atoi(env, ngx_strlen(env));
  404.     if (fd == NGX_ERROR) {
  405.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  406.                       "control: invalid " NGX_CTRL_ENV " value \"%s\"", env);
  407.         return NGX_ERROR;
  408.     }

  410.     if (fcntl(fd, F_SETOWN, ngx_pid) == -1) {
  411.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_socket_errno,
  412.                       "control: fcntl(F_SETOWN) failed");
  413.         ngx_close_socket(fd);
  414.         return NGX_ERROR;
  415.     }

  417.     ngx_control_pollfd[0].fd = fd;
  418.     ngx_control_pollfd[0].events = POLLIN;
  419.     ngx_control_pollfd_n = 1;

  421.     return NGX_OK;
  422. }


  425. static void
  426. ‌ngx_control_close(ngx_control_request_t *r)
  427. {
  428.     ngx_uint_t  i;

  430.     i = r->index;

  432.     ngx_close_socket(r->fd);

  434.     ngx_destroy_pool(r->pool);

  436.     if (i + 1 < ngx_control_pollfd_n) {
  437.         ngx_memmove(&ngx_control_pollfd[i], &ngx_control_pollfd[i + 1],
  438.                     (ngx_control_pollfd_n - (i + 1)) * sizeof(struct pollfd));
  439.         ngx_memmove(&ngx_control_requests[i], &ngx_control_requests[i + 1],
  440.             (ngx_control_pollfd_n - (i + 1)) * sizeof(ngx_control_request_t));

  442.         for (/* void */; i < ngx_control_pollfd_n - 1; i++) {
  443.             ngx_control_requests[i].index--;
  444.         }
  445.     }

  447.     ngx_control_pollfd_n--;
  448. }


  451. static void
  452. ‌ngx_control_handle_accept(void)
  453. {
  454.     ngx_fd_t                fd;
  455.     ngx_err_t               err;
  456.     struct pollfd          *pfd;
  457.     ngx_control_request_t  *r;

  459.     for ( ;; ) {
  460.         fd = accept(ngx_control_pollfd[0].fd, NULL, NULL);

  462.         if (fd == -1) {
  463.             err = ngx_socket_errno;

  465.             if (err == NGX_EAGAIN) {
  466.                 return;
  467.             }

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

  472.             if (err == NGX_ECONNABORTED) {
  473.                 continue;
  474.             }

  476.             return;
  477.         }

  479.         if (ngx_control_pollfd_n == NGX_CTRL_MAX_FD) {
  480.             ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0,
  481.                           "control: too many client connections");
  482.             /* close the oldest connection */
  483.             r = &ngx_control_requests[1];
  484.             r->pool->log = ngx_cycle->log;
  485.             ngx_control_close(r);
  486.         }

  488.         r = &ngx_control_requests[ngx_control_pollfd_n];
  489.         ngx_memzero(r, sizeof(ngx_control_request_t));
  490.         r->fd = fd;

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

  495.         if (fcntl(r->fd, F_SETFD, FD_CLOEXEC) == -1) {
  496.             ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0,
  497.                           "control: fcntl(FD_CLOEXEC) failed");
  498.             ngx_close_socket(r->fd);
  499.             continue;
  500.         }

  502.         if (fcntl(r->fd, F_SETFL, O_ASYNC|O_NONBLOCK) == -1) {
  503.             ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0,
  504.                           "control: fcntl(O_ASYNC|O_NONBLOCK) failed");
  505.             ngx_close_socket(r->fd);
  506.             continue;
  507.         }

  509.         if (fcntl(r->fd, F_SETOWN, ngx_pid) == -1) {
  510.             ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0,
  511.                           "control: fcntl(F_SETOWN) failed");
  512.             ngx_close_socket(r->fd);
  513.             continue;
  514.         }

  516.         pfd = &ngx_control_pollfd[ngx_control_pollfd_n];
  517.         ngx_memzero(pfd, sizeof(struct pollfd));
  518.         pfd->fd = r->fd;
  519.         pfd->events = POLLIN;
  520.         pfd->revents = POLLIN;

  522.         r->pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, ngx_cycle->log);
  523.         if (r->pool == NULL) {
  524.             ngx_close_socket(r->fd);
  525.             continue;
  526.         }

  528.         r->in = ngx_create_temp_buf(r->pool, NGX_CTRL_MAX_REQUEST);
  529.         if (r->in == NULL) {
  530.             ngx_destroy_pool(r->pool);
  531.             ngx_close_socket(r->fd);
  532.             continue;
  533.         }

  535.         r->index = ngx_control_pollfd_n++;
  536.     }
  537. }


  540. static ngx_int_t
  541. ‌ngx_control_handle_read(ngx_control_request_t *r)
  542. {
  543.     ssize_t     n;
  544.     ngx_buf_t  *b;

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

  549.     b = r->in;

  551.     if (b->last == b->end) {
  552.         ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0,
  553.                       "control: request too large");
  554.         return NGX_ERROR;
  555.     }

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

  559.     if (n < 0) {
  560.         if (ngx_errno == NGX_EAGAIN) {
  561.             return NGX_AGAIN;
  562.         }

  564.         ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, ngx_socket_errno,
  565.                       "control: recv() failed");
  566.         return NGX_ERROR;
  567.     }

  569.     if (n == 0) {
  570.         return NGX_DONE;
  571.     }

  573.     b->last += n;

  575.     switch (ngx_control_parse_request_line(r)) {

  577.     case NGX_AGAIN:
  578.         return NGX_AGAIN;

  580.     case NGX_DECLINED:
  581.         ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0,
  582.                       "control: failed to parse request");
  583.         ngx_control_pollfd[r->index].events &= ~POLLIN;
  584.         return ngx_control_send_response(r, NGX_CTRL_BAD_REQUEST, NULL);

  586.     case NGX_DONE:
  587.         ngx_control_pollfd[r->index].events &= ~POLLIN;
  588.         return ngx_control_content(r);

  590.     default:
  591.         ngx_control_pollfd[r->index].events &= ~POLLIN;
  592.         return NGX_ERROR;
  593.     }
  594. }


  597. static ngx_int_t
  598. ‌ngx_control_content(ngx_control_request_t *r)
  599. {
  600.     u_char  *p;
  601.     size_t   len;

  603.     static const char  *root_endpoints[] = { "1" };
  604.     static const char  *api_endpoints[] = { "control", "nginx" };
  605.     static const char  *control_endpoints[] = { "processes", "config" };

  607.     p = r->path.data;
  608.     len = r->path.len;

  610.     if (len > 1 && p[len - 1] == '/') {
  611.         r->path.len = --len;
  612.     }

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

  616.     switch (len) {
  617.     case 1:
  618.         if (r->method != NGX_CTRL_GET) {
  619.             return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  620.         }

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

  624.     case 2:
  625.         if (ngx_strncmp(p, "/1", len) == 0) {
  626.             if (r->method != NGX_CTRL_GET) {
  627.                 return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  628.             }

  630.             return ngx_control_api_endpoints(r, api_endpoints, 2);
  631.         }

  633.         break;

  635.     case 8:
  636.         if (ngx_strncmp(p, "/1/nginx", len) == 0) {
  637.             if (r->method != NGX_CTRL_GET) {
  638.                 return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  639.             }

  641.             return ngx_control_show_version(r);
  642.         }

  644.         break;

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

  652.             return ngx_control_api_endpoints(r, control_endpoints, 2);
  653.         }

  655.         break;

  657.     case 17:
  658.         if (ngx_strncmp(p, "/1/control/config", len) == 0) {
  659.             if (r->method == NGX_CTRL_PATCH) {
  660.                 return ngx_control_reload_config(r);
  661.             }

  663.             if (r->method == NGX_CTRL_GET) {
  664.                 return ngx_control_print_config(r);
  665.             }

  667.             return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  668.         }

  670.         break;

  672.     case 20:
  673.         if (ngx_strncmp(p, "/1/control/processes", len) == 0) {
  674.             if (r->method != NGX_CTRL_GET) {
  675.                 return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  676.             }

  678.             return ngx_control_show_processes(r);
  679.         }

  681.         break;
  682.     }

  684.     return ngx_control_send_response(r, NGX_CTRL_NOT_FOUND, NULL);
  685. }


  688. static char *
  689. ‌ngx_control_status_text(ngx_uint_t code)
  690. {
  691.     switch (code) {
  692.     case NGX_CTRL_OK:
  693.         return "OK";
  694.     case NGX_CTRL_BAD_REQUEST:
  695.         return "Bad Request";
  696.     case NGX_CTRL_NOT_FOUND:
  697.         return "Not Found";
  698.     case NGX_CTRL_NOT_ALLOWED:
  699.         return "Not Allowed";
  700.     case NGX_CTRL_UNPROCESSABLE:
  701.         return "Unprocessable Entity";
  702.     case NGX_CTRL_INTERNAL_ERROR:
  703.         return "Internal Server Error";
  704.     default:
  705.         return "";
  706.     }
  707. }


  710. static ngx_int_t
  711. ‌ngx_control_send_response(ngx_control_request_t *r, ngx_uint_t code,
  712.     ngx_buf_t *body)
  713. {
  714.     char         *status;
  715.     ngx_uint_t    n;
  716.     ngx_chain_t  *c;

  718.     const char  response_fmt[] =
  719.         "HTTP/1.1 %03ui %s\r\n"
  720.         "Server: " NGINX_VER "\r\n"
  721.         "Connection: close\r\n"
  722.         "Content-Type: application/json\r\n"
  723.         "Content-Length: %ui\r\n"
  724.         "\r\n";

  726.     c = ngx_alloc_chain_link(r->pool);
  727.     if (c == NULL) {
  728.         return NGX_ERROR;
  729.     }

  731.     status = ngx_control_status_text(code);

  733.     c->buf = ngx_create_temp_buf(r->pool,
  734.                 sizeof(response_fmt) + 2 * NGX_INT_T_LEN + ngx_strlen(status));
  735.     if (c->buf == NULL) {
  736.         return NGX_ERROR;
  737.     }

  739.     c->next = NULL;

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

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

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

  751.         c->next->buf = body;
  752.         c->next->next = NULL;
  753.     }

  755.     r->out = c;

  757.     return ngx_control_handle_write(r);
  758. }


  761. static ngx_int_t
  762. ‌ngx_control_handle_write(ngx_control_request_t *r)
  763. {
  764.     ssize_t       n;
  765.     ngx_buf_t    *b;
  766.     ngx_chain_t  *c;

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

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

  774.             if (n <= 0) {
  775.                 if (n == -1 && ngx_errno == NGX_EAGAIN) {
  776.                     ngx_control_pollfd[r->index].events |= POLLOUT;
  777.                     return NGX_AGAIN;
  778.                 }

  780.                 ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, ngx_socket_errno,
  781.                               "control: send() failed");
  782.                 return NGX_ERROR;
  783.             }

  785.             b->pos += n;

  787.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
  788.                            "control: wrote %i bytes", n);
  789.         }
  790.     }

  792.     return NGX_DONE;
  793. }


  796. static ngx_int_t
  797. ‌ngx_control_send_json(ngx_control_request_t *r, ngx_int_t code,
  798.     ngx_data_item_t *obj)
  799. {
  800.     ngx_buf_t  *b;

  802.     b = ngx_json_render(r->pool, obj);
  803.     if (b == NULL) {
  804.         return NGX_ERROR;
  805.     }

  807.     return ngx_control_send_response(r, code, b);
  808. }


  811. static ngx_int_t
  812. ‌ngx_control_api_endpoints(ngx_control_request_t *r, const char **paths,
  813.     ngx_int_t npaths)
  814. {
  815.     ngx_int_t         i;
  816.     ngx_str_t         p;
  817.     ngx_data_item_t  *json, *path;

  819.     if (r->method != NGX_CTRL_GET) {
  820.         return ngx_control_send_response(r, NGX_CTRL_NOT_ALLOWED, NULL);
  821.     }

  823.     json = ngx_data_new_list(r->pool);
  824.     if (json == NULL) {
  825.         return NGX_ERROR;
  826.     }

  828.     for (i = 0; i < npaths; i++) {
  829.         p.data = (u_char *) paths[i];
  830.         p.len = ngx_strlen(paths[i]);

  832.         path = ngx_data_string_handler((uintptr_t) &p, r->pool, NULL);
  833.         if (path == NULL) {
  834.             return NGX_ERROR;
  835.         }

  837.         ngx_data_add_item(json, NULL, path);
  838.     }

  840.     return ngx_control_send_json(r, NGX_CTRL_OK, (ngx_data_item_t *) json);
  841. }


  844. static ngx_int_t
  845. ‌ngx_control_show_processes(ngx_control_request_t *r)
  846. {
  847.     ngx_int_t               i;
  848.     ngx_data_item_t        *process_list, *obj;
  849.     ngx_control_process_t   process;

  851.     process_list = ngx_data_new_list(r->pool);
  852.     if (process_list == NULL) {
  853.         return NGX_ERROR;
  854.     }

  856.     for (i = 0; i < ngx_last_process; i++) {
  857.         if (ngx_processes[i].pid == -1) {
  858.             continue;
  859.         }

  861.         process.name.data = (u_char *) ngx_processes[i].name;
  862.         process.name.len = ngx_strlen(process.name.data);
  863.         process.pid = ngx_processes[i].pid;
  864.         process.exiting = ngx_processes[i].exiting;

  866.         obj = ngx_data_obj_handler((uintptr_t) ngx_control_process_fields,
  867.                                    r->pool, &process);
  868.         if (obj == NULL) {
  869.             return NGX_ERROR;
  870.         }

  872.         ngx_data_add_item(process_list, NULL, obj);
  873.     }

  875.     return ngx_control_send_json(r, NGX_CTRL_OK, process_list);
  876. }


  879. static ngx_int_t
  880. ‌ngx_control_show_version(ngx_control_request_t *r)
  881. {
  882.     ngx_data_item_t  *resp;

  884.     resp = ngx_data_obj_handler((uintptr_t) ngx_control_status_fields, r->pool,
  885.                                 NULL);
  886.     if (resp == NULL) {
  887.         return NGX_ERROR;
  888.     }

  890.     return ngx_control_send_json(r, NGX_CTRL_OK, resp);
  891. }


  894. static ngx_int_t
  895. ‌ngx_control_print_config(ngx_control_request_t *r)
  896. {
  897.     ngx_uint_t        i;
  898.     ngx_keyval_t      item;
  899.     ngx_data_item_t  *list, *obj;
  900.     ngx_conf_dump_t  *dump;

  902.     list = ngx_data_new_list(r->pool);
  903.     if (list == NULL) {
  904.         return NGX_ERROR;
  905.     }

  907.     dump = ngx_cycle->config_dump.elts;

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

  911.         item.key = dump[i].name;
  912.         item.value.data = dump[i].buffer->pos;
  913.         item.value.len = dump[i].buffer->last - dump[i].buffer->pos;

  915.         obj = ngx_data_obj_handler((uintptr_t) ngx_control_config_fields,
  916.                                    r->pool, &item);
  917.         if (obj == NULL) {
  918.             return NGX_ERROR;
  919.         }

  921.         ngx_data_add_item(list, NULL, obj);
  922.     }

  924.     return ngx_control_send_json(r, NGX_CTRL_OK, list);
  925. }


  928. static ngx_data_item_t *
  929. ‌ngx_control_json_logs(ngx_array_t *logs)
  930. {
  931.     ngx_str_t        *l;
  932.     ngx_uint_t        i;
  933.     ngx_data_item_t  *obj, *log_list, *log;

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

  937.     obj = ngx_data_new_object(logs->pool);
  938.     if (obj == NULL) {
  939.         return NULL;
  940.     }

  942.     log_list = ngx_data_new_list(logs->pool);
  943.     if (log_list == NULL) {
  944.         return NULL;
  945.     }

  947.     l = logs->elts;
  948.     for (i = 0; i < logs->nelts; i++) {
  949.         log = ngx_data_string_handler((uintptr_t) &l[i], logs->pool, NULL);
  950.         if (log == NULL) {
  951.             return NULL;
  952.         }

  954.         ngx_data_add_item(log_list, NULL, log);
  955.     }

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

  959.     return obj;
  960. }


  963. static ngx_int_t
  964. ‌ngx_control_reload_config(ngx_control_request_t *r)
  965. {
  966.     ngx_int_t         status;
  967.     ngx_log_t         log, *tmp;
  968.     ngx_cycle_t      *cycle;
  969.     ngx_array_t       log_store;
  970.     ngx_data_item_t  *obj;

  972.     status = NGX_CTRL_OK;

  974.     if (ngx_array_init(&log_store, r->pool, 3, sizeof(ngx_str_t)) != NGX_OK) {
  975.         return NGX_ERROR;
  976.     }

  978.     ngx_memzero(&log, sizeof(ngx_log_t));
  979.     log.wdata = &log_store;
  980.     log.writer = ngx_control_log_capture;
  981.     log.log_level = NGX_LOG_DEBUG;

  983.     tmp = ngx_cycle->log;
  984.     log.next = tmp;
  985.     ngx_cycle->log = &log;
  986.     cycle = ngx_init_cycle((ngx_cycle_t *) ngx_cycle);

  988.     if (cycle == NULL) {
  989.         status = NGX_CTRL_UNPROCESSABLE;
  990.         ngx_cycle->log = tmp;

  992.     } else {
  993.         ngx_cycle = cycle;
  994.         r->reloaded = 1;
  995.         r->pool->log = ngx_cycle->log;
  996.     }

  998.     obj = ngx_control_json_logs(&log_store);
  999.     if (obj == NULL) {
  1000.         return NGX_ERROR;
  1001.     }

  1003.     return ngx_control_send_json(r, status, obj);
  1004. }


  1007. static void
  1008. ‌ngx_control_log_capture(ngx_log_t *log, ngx_uint_t lvl, u_char *buf, size_t len)
  1009. {
  1010.     u_char       *log_data;
  1011.     ngx_str_t    *log_str;
  1012.     ngx_array_t  *store;

  1014.     if (lvl > NGX_LOG_WARN) {
  1015.         return;
  1016.     }

  1018.     store = log->wdata;

  1020.     log_data = ngx_pnalloc(store->pool, len);
  1021.     if (log_data == NULL) {
  1022.         return;
  1023.     }

  1025.     log_str = ngx_array_push(store);
  1026.     if (log_str == NULL) {
  1027.         return;
  1028.     }

  1030.     ngx_memcpy(log_data, buf, len);

  1032.     log_str->data = log_data;
  1033.     log_str->len = len;
  1034. }


  1037. static ngx_int_t
  1038. ‌ngx_control_parse_request_line(ngx_control_request_t *r)
  1039. {
  1040.     static uint32_t  usual[] = {
  1041.         0x00000000, /* 0000 0000 0000 0000  0000 0000 0000 0000 */
  1042.                     /* ?>=< ;:98 7654 3210  /.-, +*)( '&%$ #"!  */
  1043.         0x7fff37d6, /* 0111 1111 1111 1111  0011 0111 1101 0110 */
  1044.                     /* _^]\ [ZYX WVUT SRQP  ONML KJIH GFED CBA@ */
  1045.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  1046.                     /*  ~}| {zyx wvut srqp  onml kjih gfed cba` */
  1047.         0x7fffffff, /* 0111 1111 1111 1111  1111 1111 1111 1111 */
  1048.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  1049.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  1050.         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  1051.         0xffffffff  /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  1052.     };

  1054.     u_char      c, ch, *p;
  1055.     ngx_buf_t  *b;
  1056. ‌    enum {
  1057.         sw_start = 0,
  1058.         sw_method,
  1059.         sw_spaces_before_uri,
  1060.         sw_schema,
  1061.         sw_schema_slash,
  1062.         sw_schema_slash_slash,
  1063.         sw_spaces_before_host,
  1064.         sw_host_start,
  1065.         sw_host,
  1066.         sw_host_end,
  1067.         sw_host_ip_literal,
  1068.         sw_port_start,
  1069.         sw_port,
  1070.         sw_uri,
  1071.         sw_http_,
  1072.         sw_http_H,
  1073.         sw_http_HT,
  1074.         sw_http_HTT,
  1075.         sw_http_HTTP,
  1076.         sw_first_major_digit,
  1077.         sw_major_digit,
  1078.         sw_first_minor_digit,
  1079.         sw_minor_digit,
  1080.         sw_almost_done
  1081.     } state;

  1083.     b = r->in;
  1084.     state = r->state;

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

  1089.         switch (state) {
  1090.         /* HTTP methods: GET, PATCH */
  1091.         case sw_start:
  1092.             if ((ch < 'A' || ch > 'Z') && ch != '_' && ch != '-') {
  1093.                 return NGX_DECLINED;
  1094.             }

  1096.             state = sw_method;

  1098.             break;

  1100.         case sw_method:
  1101.             if (ch == ' ') {
  1102.                 state = sw_spaces_before_uri;

  1104.                 switch (p - b->start) {
  1105.                 case 3:
  1106.                     if (ngx_strncmp(b->start, "GET", 3) == 0) {
  1107.                         r->method = NGX_CTRL_GET;
  1108.                         break;
  1109.                     }
  1110.                     break;

  1112.                 case 5:
  1113.                     if (ngx_strncmp(b->start, "PATCH", 5) == 0) {
  1114.                         r->method = NGX_CTRL_PATCH;
  1115.                         break;
  1116.                     }
  1117.                     break;
  1118.                 }

  1120.                 break;
  1121.             }

  1123.             if ((ch < 'A' || ch > 'Z') && ch != '_' && ch != '-') {
  1124.                 return NGX_DECLINED;
  1125.             }

  1127.             break;

  1129.         /* space* before URI */
  1130.         case sw_spaces_before_uri:
  1131.             if (ch == '/') {
  1132.                 r->path.data = p;
  1133.                 state = sw_uri;
  1134.                 break;
  1135.             }

  1137.             c = (u_char) (ch | 0x20);
  1138.             if (c >= 'a' && c <= 'z') {
  1139.                 state = sw_schema;
  1140.                 break;
  1141.             }

  1143.             if (ch != ' ') {
  1144.                 return NGX_DECLINED;
  1145.             }

  1147.             break;

  1149.         case sw_schema:
  1150.             c = (u_char) (ch | 0x20);
  1151.             if (c >= 'a' && c <= 'z') {
  1152.                 break;
  1153.             }

  1155.             if ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')
  1156.             {
  1157.                 break;
  1158.             }

  1160.             if (ch != ':') {
  1161.                 return NGX_DECLINED;
  1162.             }

  1164.             state = sw_schema_slash;
  1165.             break;

  1167.         case sw_schema_slash:
  1168.             if (ch != '/') {
  1169.                 return NGX_DECLINED;
  1170.             }

  1172.             state = sw_schema_slash_slash;
  1173.             break;

  1175.         case sw_schema_slash_slash:
  1176.             if (ch != '/') {
  1177.                 return NGX_DECLINED;
  1178.             }

  1180.             state = sw_host_start;
  1181.             break;

  1183.         case sw_spaces_before_host:
  1184.             if (ch == ' ') {
  1185.                 break;
  1186.             }
  1187.             /* fall through */

  1189.         case sw_host_start:
  1190.             if (ch == '[') {
  1191.                 state = sw_host_ip_literal;
  1192.                 break;
  1193.             }

  1195.             state = sw_host;
  1196.             /* fall through */

  1198.         case sw_host:
  1199.             c = (u_char) (ch | 0x20);
  1200.             if (c >= 'a' && c <= 'z') {
  1201.                 break;
  1202.             }

  1204.             if ((ch >= '0' && ch <= '9') || ch == '.' || ch == '-') {
  1205.                 break;
  1206.             }
  1207.             /* fall through */

  1209.         case sw_host_end:
  1210.             if (ch == ':') {
  1211.                 state = sw_port_start;
  1212.                 break;
  1213.             }

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

  1217.             switch (ch) {
  1218.             case '/':
  1219.                 r->path.data = p;
  1220.                 state = sw_uri;
  1221.                 break;
  1222.             /* empty path cases */
  1223.             case '?':
  1224.                 ngx_str_set(&r->path, "/");
  1225.                 state = sw_uri;
  1226.                 break;
  1227.             case ' ':
  1228.                 ngx_str_set(&r->path, "/");
  1229.                 state = sw_http_;
  1230.                 break;
  1231.             }
  1232.             break;

  1234.         case sw_host_ip_literal:
  1235.             if (ch >= '0' && ch <= '9') {
  1236.                 break;
  1237.             }

  1239.             c = (u_char) (ch | 0x20);
  1240.             if (c >= 'a' && c <= 'z') {
  1241.                 break;
  1242.             }

  1244.             switch (ch) {
  1245.             case ':':
  1246.                 break;
  1247.             case ']':
  1248.                 state = sw_host_end;
  1249.                 break;
  1250.             case '-':
  1251.             case '.':
  1252.             case '_':
  1253.             case '~':
  1254.                 /* unreserved */
  1255.                 break;
  1256.             case '!':
  1257.             case '$':
  1258.             case '&':
  1259.             case '\'':
  1260.             case '(':
  1261.             case ')':
  1262.             case '*':
  1263.             case '+':
  1264.             case ',':
  1265.             case ';':
  1266.             case '=':
  1267.                 /* sub-delims */
  1268.                 break;
  1269.             default:
  1270.                 return NGX_DECLINED;
  1271.             }
  1272.             break;

  1274.         case sw_port_start:
  1275.             state = sw_port;

  1277.             if (ch >= '0' && ch <= '9') {
  1278.                 break;
  1279.             }

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

  1283.             /* fall through */

  1285.         case sw_port:
  1286.             if (ch >= '0' && ch <= '9') {
  1287.                 break;
  1288.             }

  1290.             switch (ch) {
  1291.             case '/':
  1292.                 r->path.data = p;
  1293.                 state = sw_uri;
  1294.                 break;
  1295.             /* empty path cases */
  1296.             case '?':
  1297.                 ngx_str_set(&r->path, "/");
  1298.                 state = sw_uri;
  1299.                 break;
  1300.             case ' ':
  1301.                 ngx_str_set(&r->path, "/");
  1302.                 state = sw_http_;
  1303.                 break;
  1304.             default:
  1305.                 return NGX_DECLINED;
  1306.             }
  1307.             break;

  1309.         /* URI */
  1310.         case sw_uri:
  1311.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1312.                 break;
  1313.             }

  1315.             switch (ch) {
  1316.             case ' ':
  1317.                 state = sw_http_;
  1318.                 /* fall through */
  1319.             case '?':
  1320.                 if (r->path.len == 0) {
  1321.                     r->path.len = p - r->path.data;
  1322.                 }
  1323.                 break;

  1325.             case '.':
  1326.             case '%':
  1327.             case '#':
  1328.             case '+':
  1329.             case 0x7f:
  1330.                 return NGX_DECLINED;
  1331.             default:
  1332.                 if (ch < 0x20) {
  1333.                     return NGX_DECLINED;
  1334.                 }
  1335.                 break;
  1336.             }
  1337.             break;

  1339.         /* space+ after URI */
  1340.         case sw_http_:
  1341.             switch (ch) {
  1342.             case ' ':
  1343.                 break;
  1344.             case 'H':
  1345.                 state = sw_http_H;
  1346.                 break;
  1347.             default:
  1348.                 return NGX_DECLINED;
  1349.             }
  1350.             break;

  1352.         case sw_http_H:
  1353.             switch (ch) {
  1354.             case 'T':
  1355.                 state = sw_http_HT;
  1356.                 break;
  1357.             default:
  1358.                 return NGX_DECLINED;
  1359.             }
  1360.             break;

  1362.         case sw_http_HT:
  1363.             switch (ch) {
  1364.             case 'T':
  1365.                 state = sw_http_HTT;
  1366.                 break;
  1367.             default:
  1368.                 return NGX_DECLINED;
  1369.             }
  1370.             break;

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

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

  1392.         /* first digit of major HTTP version */
  1393.         case sw_first_major_digit:
  1394.             if (ch != '1') {
  1395.                 return NGX_DECLINED;
  1396.             }

  1398.             state = sw_major_digit;
  1399.             break;

  1401.         /* major HTTP version or dot */
  1402.         case sw_major_digit:
  1403.             if (ch == '.') {
  1404.                 state = sw_first_minor_digit;
  1405.                 break;
  1406.             } else {
  1407.                 /* major versions other than 1 are not supported */
  1408.                 return NGX_DECLINED;
  1409.             }

  1411.         /* first digit of minor HTTP version */
  1412.         case sw_first_minor_digit:
  1413.             if (ch != '0' && ch != '1') {
  1414.                 return NGX_DECLINED;
  1415.             }

  1417.             state = sw_minor_digit;
  1418.             break;

  1420.         /* minor HTTP version or end of request line */
  1421.         case sw_minor_digit:
  1422.             if (ch == CR) {
  1423.                 state = sw_almost_done;
  1424.                 break;

  1426.             } else if (ch == LF) {
  1427.                 goto done;

  1429.             } else {
  1430.                 /* support only 1.1 or 1.0 */
  1431.                 return NGX_DECLINED;
  1432.             }

  1434.         /* end of request line */
  1435.         case sw_almost_done:
  1436.             switch (ch) {
  1437.             case LF:
  1438.                 goto done;
  1439.             default:
  1440.                 return NGX_DECLINED;
  1441.             }
  1442.         }
  1443.     }

  1445.     b->pos = p;
  1446.     r->state = state;

  1448.     return NGX_AGAIN;

  1450. done:
  1451.     b->pos = p + 1;
  1452.     r->state = sw_start;

  1454.     return NGX_DONE;
  1455. }

One Level Up Top Level