| 1 |
|
| #include "feersum_core.h" |
| 2 |
|
| #include "picohttpparser-git/picohttpparser.c" |
| 3 |
|
| |
| 4 |
|
| #include "rinq.c" |
| 5 |
|
| |
| 6 |
|
| #include "feersum_core.c.inc" |
| 7 |
|
| #include "feersum_utils.c.inc" |
| 8 |
|
| #include "feersum_h1.c.inc" |
| 9 |
|
| #include "feersum_psgi.c.inc" |
| 10 |
|
| |
| 11 |
|
| #ifdef FEERSUM_HAS_TLS |
| 12 |
|
| #include "feersum_tls.c.inc" |
| 13 |
|
| #endif |
| 14 |
|
| #ifdef FEERSUM_HAS_H2 |
| 15 |
|
| #include "feersum_h2.c.inc" |
| 16 |
|
| #endif |
| 17 |
|
| |
| 18 |
|
| MODULE = Feersum PACKAGE = Feersum |
| 19 |
|
| |
| 20 |
|
| PROTOTYPES: ENABLE |
| 21 |
|
| |
| 22 |
|
| SV * |
| 23 |
|
| _xs_new_server(SV *classname) |
| 24 |
|
| CODE: |
| 25 |
|
| { |
| 26 |
|
| PERL_UNUSED_VAR(classname); |
| 27 |
455 |
| struct feer_server *s = new_feer_server(aTHX); |
| 28 |
455 |
| RETVAL = feer_server_2sv(s); |
| 29 |
|
| } |
| 30 |
|
| OUTPUT: |
| 31 |
|
| RETVAL |
| 32 |
|
| |
| 33 |
|
| SV * |
| 34 |
|
| _xs_default_server(SV *classname) |
| 35 |
|
| CODE: |
| 36 |
|
| { |
| 37 |
|
| PERL_UNUSED_VAR(classname); |
| 38 |
222 |
| RETVAL = feer_server_2sv(default_server); |
| 39 |
|
| } |
| 40 |
|
| OUTPUT: |
| 41 |
|
| RETVAL |
| 42 |
|
| |
| 43 |
|
| void |
| 44 |
|
| set_server_name_and_port(struct feer_server *server, SV *name, SV *port) |
| 45 |
|
| PPCODE: |
| 46 |
|
| { |
| 47 |
|
| /* unlisten() zeroes n_listeners but leaves last_listener_idx stale */ |
| 48 |
558 |
| int idx = server->last_listener_idx; |
| 49 |
558 |
▶ | if (idx < 0 || idx >= server->n_listeners) |
Branch: 2 branches
| Branch | True | False | Total |
| if (idx < 0 || idx >= server->n_listeners) |
558 |
0 |
558 |
| if (idx < 0 || idx >= server->n_listeners) |
0 |
558 |
558 |
|
| 50 |
0 |
| idx = server->n_listeners > 0 ? server->n_listeners - 1 : 0; |
| 51 |
558 |
| struct feer_listen *lsnr = &server->listeners[idx]; |
| 52 |
558 |
| SvREFCNT_dec(lsnr->server_name); |
| 53 |
558 |
| lsnr->server_name = newSVsv(name); |
| 54 |
558 |
| SvREADONLY_on(lsnr->server_name); |
| 55 |
|
| |
| 56 |
558 |
| SvREFCNT_dec(lsnr->server_port); |
| 57 |
558 |
| lsnr->server_port = newSVsv(port); |
| 58 |
558 |
| SvREADONLY_on(lsnr->server_port); |
| 59 |
|
| } |
| 60 |
|
| |
| 61 |
|
| void |
| 62 |
|
| accept_on_fd(struct feer_server *server, int fd) |
| 63 |
|
| PPCODE: |
| 64 |
|
| { |
| 65 |
|
| struct sockaddr_storage addr; |
| 66 |
558 |
| socklen_t addr_len = sizeof(addr); |
| 67 |
|
| struct feer_listen *lsnr; |
| 68 |
|
| |
| 69 |
|
| /* shutting_down is terminal: prepare_cb skips accept watchers while it is set */ |
| 70 |
558 |
▶ | if (unlikely(server->shutting_down)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (unlikely(server->shutting_down)) |
1 |
557 |
558 |
|
| 71 |
1 |
| croak("cannot listen after graceful_shutdown; it is terminal"); |
| 72 |
|
| |
| 73 |
557 |
▶ | if (server->n_listeners == 0) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (server->n_listeners == 0) { |
504 |
53 |
557 |
|
| 74 |
504 |
| lsnr = &server->listeners[0]; |
| 75 |
504 |
| server->n_listeners = 1; |
| 76 |
|
| } else { |
| 77 |
53 |
| lsnr = NULL; |
| 78 |
|
| /* an fd already in the table takes its own slot back, or shutdown |
| 79 |
|
| * would close it twice */ |
| 80 |
198 |
▶ | for (int j = 0; j < server->n_listeners; j++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (int j = 0; j < server->n_listeners; j++) { |
145 |
53 |
198 |
|
| 81 |
145 |
▶ | if (server->listeners[j].fd == fd) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (server->listeners[j].fd == fd) { |
0 |
145 |
145 |
|
| 82 |
0 |
| lsnr = &server->listeners[j]; |
| 83 |
|
| /* re-init below would otherwise leave the old watcher armed */ |
| 84 |
0 |
▶ | if (ev_is_active(&lsnr->accept_w)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (ev_is_active(&lsnr->accept_w)) |
0 |
0 |
0 |
|
| 85 |
0 |
| ev_io_stop(feersum_ev_loop, &lsnr->accept_w); |
| 86 |
0 |
| break; |
| 87 |
|
| } |
| 88 |
|
| } |
| 89 |
198 |
▶ | for (int j = 0; !lsnr && j < server->n_listeners; j++) { |
Branch: 2 branches
| Branch | True | False | Total |
| for (int j = 0; !lsnr && j < server->n_listeners; j++) { |
198 |
0 |
198 |
| for (int j = 0; !lsnr && j < server->n_listeners; j++) { |
145 |
53 |
198 |
|
| 90 |
145 |
▶ | if (server->listeners[j].fd == -1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (server->listeners[j].fd == -1) { |
0 |
145 |
145 |
|
| 91 |
0 |
| lsnr = &server->listeners[j]; |
| 92 |
0 |
| break; |
| 93 |
|
| } |
| 94 |
|
| } |
| 95 |
|
| #ifdef FEERSUM_HAS_TLS |
| 96 |
53 |
▶ | if (lsnr) |
Branch: 1 branch
| Branch | True | False | Total |
| if (lsnr) |
0 |
53 |
53 |
|
| 97 |
0 |
| feer_tls_cleanup_listener(lsnr); |
| 98 |
|
| #endif |
| 99 |
53 |
▶ | if (!lsnr) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!lsnr) { |
53 |
0 |
53 |
|
| 100 |
53 |
▶ | if (server->n_listeners < FEER_MAX_LISTENERS) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (server->n_listeners < FEER_MAX_LISTENERS) { |
53 |
0 |
53 |
|
| 101 |
53 |
| lsnr = &server->listeners[server->n_listeners]; |
| 102 |
53 |
| Zero(lsnr, 1, struct feer_listen); |
| 103 |
53 |
| lsnr->server = server; |
| 104 |
53 |
| lsnr->fd = -1; |
| 105 |
53 |
| lsnr->is_tcp = 1; |
| 106 |
53 |
| server->n_listeners++; |
| 107 |
|
| } else { |
| 108 |
0 |
| croak("Too many listeners (max %d)", FEER_MAX_LISTENERS); |
| 109 |
|
| } |
| 110 |
|
| } |
| 111 |
|
| } |
| 112 |
|
| |
| 113 |
557 |
| server->last_listener_idx = (int)(lsnr - server->listeners); |
| 114 |
|
| |
| 115 |
557 |
| Zero(&addr, 1, struct sockaddr_storage); |
| 116 |
557 |
▶ | if (getsockname(fd, (struct sockaddr*)&addr, &addr_len) == -1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (getsockname(fd, (struct sockaddr*)&addr, &addr_len) == -1) { |
0 |
557 |
557 |
|
| 117 |
0 |
| warn("getsockname failed: %s (assuming TCP socket)", strerror(errno)); |
| 118 |
0 |
| addr.ss_family = AF_INET; |
| 119 |
|
| } |
| 120 |
557 |
| switch (addr.ss_family) { |
| 121 |
554 |
| case AF_INET: |
| 122 |
|
| case AF_INET6: |
| 123 |
554 |
| lsnr->is_tcp = 1; |
| 124 |
|
| #ifdef TCP_DEFER_ACCEPT |
| 125 |
|
| /* not with drain_accept_queue: a deferred connection is invisible |
| 126 |
|
| * to accept(), so the shutdown drain would close the listener on it */ |
| 127 |
554 |
▶ | if (!server->drain_accept_queue) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!server->drain_accept_queue) { |
554 |
0 |
554 |
|
| 128 |
|
| trace("going to defer accept on %d\n",fd); |
| 129 |
554 |
▶ | if (setsockopt(fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &(int){1}, sizeof(int)) < 0) |
Branch: 1 branch
| Branch | True | False | Total |
| if (setsockopt(fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &(int){1}, sizeof(int)) < 0) |
0 |
554 |
554 |
|
| 130 |
0 |
| trouble("setsockopt TCP_DEFER_ACCEPT fd=%d: %s\n", fd, strerror(errno)); |
| 131 |
|
| } |
| 132 |
|
| #endif |
| 133 |
554 |
| break; |
| 134 |
|
| #ifdef AF_UNIX |
| 135 |
3 |
| case AF_UNIX: |
| 136 |
3 |
| lsnr->is_tcp = 0; |
| 137 |
3 |
| break; |
| 138 |
|
| #endif |
| 139 |
|
| } |
| 140 |
|
| |
| 141 |
|
| trace("going to accept on %d\n",fd); |
| 142 |
557 |
| feersum_ev_loop = EV_DEFAULT; |
| 143 |
557 |
| lsnr->fd = fd; |
| 144 |
|
| |
| 145 |
557 |
▶ | if (!server->watchers_initialized) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!server->watchers_initialized) { |
504 |
53 |
557 |
|
| 146 |
504 |
| server->watchers_initialized = true; |
| 147 |
|
| |
| 148 |
504 |
| ev_prepare_init(&server->ep, prepare_cb); |
| 149 |
504 |
| server->ep.data = (void *)server; |
| 150 |
504 |
| ev_prepare_start(feersum_ev_loop, &server->ep); |
| 151 |
|
| |
| 152 |
504 |
| ev_check_init(&server->ec, check_cb); |
| 153 |
504 |
| server->ec.data = (void *)server; |
| 154 |
|
| /* below the io watchers: at equal priority check_cb runs first and |
| 155 |
|
| * dispatch slips an iteration */ |
| 156 |
504 |
| ev_set_priority(&server->ec, EV_MINPRI); |
| 157 |
504 |
| ev_check_start(feersum_ev_loop, &server->ec); |
| 158 |
|
| |
| 159 |
504 |
| ev_idle_init(&server->ei, idle_cb); |
| 160 |
504 |
| server->ei.data = (void *)server; |
| 161 |
|
| |
| 162 |
504 |
| date_timer_refs++; |
| 163 |
53 |
▶ | } else if (!ev_is_active(&server->ep)) { |
Branch: 1 branch
| Branch | True | False | Total |
| } else if (!ev_is_active(&server->ep)) { |
29 |
24 |
53 |
|
| 164 |
29 |
| ev_prepare_start(feersum_ev_loop, &server->ep); |
| 165 |
|
| } |
| 166 |
|
| |
| 167 |
557 |
▶ | if (!ev_is_active(&date_timer)) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!ev_is_active(&date_timer)) { |
386 |
171 |
557 |
|
| 168 |
386 |
| date_timer_cb(feersum_ev_loop, &date_timer, 0); |
| 169 |
386 |
| ev_timer_init(&date_timer, date_timer_cb, 1.0, 1.0); |
| 170 |
386 |
| ev_timer_start(feersum_ev_loop, &date_timer); |
| 171 |
|
| } |
| 172 |
|
| |
| 173 |
|
| /* a blocking listener wedges the loop (accept() past the last pending |
| 174 |
|
| * connection blocks); prep_socket only covers accepted fds */ |
| 175 |
|
| { |
| 176 |
557 |
| int fl = fcntl(fd, F_GETFL); |
| 177 |
557 |
▶ | if (fl >= 0 && !(fl & O_NONBLOCK)) |
Branch: 2 branches
| Branch | True | False | Total |
| if (fl >= 0 && !(fl & O_NONBLOCK)) |
557 |
0 |
557 |
| if (fl >= 0 && !(fl & O_NONBLOCK)) |
0 |
557 |
557 |
|
| 178 |
0 |
| (void)fcntl(fd, F_SETFL, fl | O_NONBLOCK); |
| 179 |
|
| } |
| 180 |
|
| |
| 181 |
557 |
| setup_accept_watcher(lsnr, fd); |
| 182 |
|
| } |
| 183 |
|
| |
| 184 |
|
| void |
| 185 |
|
| unlisten (struct feer_server *server) |
| 186 |
|
| PPCODE: |
| 187 |
|
| { |
| 188 |
|
| trace("stopping accept\n"); |
| 189 |
24 |
| ev_prepare_stop(feersum_ev_loop, &server->ep); |
| 190 |
24 |
| ev_check_stop(feersum_ev_loop, &server->ec); |
| 191 |
24 |
| ev_idle_stop(feersum_ev_loop, &server->ei); |
| 192 |
53 |
▶ | for (int i = 0; i < server->n_listeners; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (int i = 0; i < server->n_listeners; i++) { |
29 |
24 |
53 |
|
| 193 |
29 |
| struct feer_listen *lsnr = &server->listeners[i]; |
| 194 |
29 |
| ev_io_stop(feersum_ev_loop, &lsnr->accept_w); |
| 195 |
29 |
| ev_timer_stop(feersum_ev_loop, &lsnr->emfile_w); |
| 196 |
29 |
| lsnr->fd = -1; |
| 197 |
29 |
| lsnr->pause_flags = 0; |
| 198 |
|
| #ifdef FEERSUM_HAS_TLS |
| 199 |
29 |
| feer_tls_cleanup_listener(lsnr); |
| 200 |
|
| #endif |
| 201 |
29 |
| SvREFCNT_dec(lsnr->server_name); |
| 202 |
29 |
| lsnr->server_name = NULL; |
| 203 |
29 |
| SvREFCNT_dec(lsnr->server_port); |
| 204 |
29 |
| lsnr->server_port = NULL; |
| 205 |
|
| } |
| 206 |
24 |
| server->n_listeners = 0; |
| 207 |
24 |
▶ | if (server->watchers_initialized) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (server->watchers_initialized) { |
22 |
2 |
24 |
|
| 208 |
22 |
| server->watchers_initialized = false; |
| 209 |
22 |
▶ | if (--date_timer_refs <= 0) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (--date_timer_refs <= 0) { |
18 |
4 |
22 |
|
| 210 |
18 |
| ev_timer_stop(feersum_ev_loop, &date_timer); |
| 211 |
18 |
| date_timer_refs = 0; |
| 212 |
|
| } |
| 213 |
|
| } |
| 214 |
|
| } |
| 215 |
|
| |
| 216 |
|
| void |
| 217 |
|
| pause_accept (struct feer_server *server) |
| 218 |
|
| PPCODE: |
| 219 |
|
| { |
| 220 |
32 |
▶ | if (server->shutting_down) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (server->shutting_down) { |
0 |
32 |
32 |
|
| 221 |
|
| trace("cannot pause during shutdown\n"); |
| 222 |
0 |
| XSRETURN_NO; |
| 223 |
|
| } |
| 224 |
32 |
| int paused_any = 0; |
| 225 |
64 |
▶ | for (int i = 0; i < server->n_listeners; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (int i = 0; i < server->n_listeners; i++) { |
32 |
32 |
64 |
|
| 226 |
32 |
| struct feer_listen *lsnr = &server->listeners[i]; |
| 227 |
32 |
▶ | if (!(lsnr->pause_flags & FEER_PAUSE_USER)) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(lsnr->pause_flags & FEER_PAUSE_USER)) { |
31 |
1 |
32 |
|
| 228 |
|
| trace("pausing accept on listener %d\n", i); |
| 229 |
31 |
▶ | if (ev_is_active(&lsnr->accept_w)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (ev_is_active(&lsnr->accept_w)) |
1 |
30 |
31 |
|
| 230 |
1 |
| ev_io_stop(feersum_ev_loop, &lsnr->accept_w); |
| 231 |
31 |
| lsnr->pause_flags |= FEER_PAUSE_USER; |
| 232 |
31 |
| paused_any = 1; |
| 233 |
|
| } |
| 234 |
|
| } |
| 235 |
32 |
▶ | if (paused_any) |
Branch: 1 branch
| Branch | True | False | Total |
| if (paused_any) |
31 |
1 |
32 |
|
| 236 |
31 |
| XSRETURN_YES; |
| 237 |
|
| else |
| 238 |
1 |
| XSRETURN_NO; |
| 239 |
|
| } |
| 240 |
|
| |
| 241 |
|
| void |
| 242 |
|
| resume_accept (struct feer_server *server) |
| 243 |
|
| PPCODE: |
| 244 |
|
| { |
| 245 |
30 |
▶ | if (server->shutting_down) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (server->shutting_down) { |
0 |
30 |
30 |
|
| 246 |
|
| trace("cannot resume during shutdown\n"); |
| 247 |
0 |
| XSRETURN_NO; |
| 248 |
|
| } |
| 249 |
30 |
| int resumed_any = 0; |
| 250 |
60 |
▶ | for (int i = 0; i < server->n_listeners; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (int i = 0; i < server->n_listeners; i++) { |
30 |
30 |
60 |
|
| 251 |
30 |
| struct feer_listen *lsnr = &server->listeners[i]; |
| 252 |
30 |
▶ | if (lsnr->pause_flags & FEER_PAUSE_USER) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (lsnr->pause_flags & FEER_PAUSE_USER) { |
29 |
1 |
30 |
|
| 253 |
|
| trace("resuming accept on listener %d\n", i); |
| 254 |
29 |
| lsnr->pause_flags &= ~FEER_PAUSE_USER; |
| 255 |
29 |
▶ | if (!lsnr->pause_flags && lsnr->fd >= 0) |
Branch: 2 branches
| Branch | True | False | Total |
| if (!lsnr->pause_flags && lsnr->fd >= 0) |
29 |
0 |
29 |
| if (!lsnr->pause_flags && lsnr->fd >= 0) |
29 |
0 |
29 |
|
| 256 |
29 |
| ev_io_start(feersum_ev_loop, &lsnr->accept_w); |
| 257 |
29 |
| resumed_any = 1; |
| 258 |
|
| } |
| 259 |
|
| } |
| 260 |
30 |
▶ | if (resumed_any) |
Branch: 1 branch
| Branch | True | False | Total |
| if (resumed_any) |
29 |
1 |
30 |
|
| 261 |
29 |
| XSRETURN_YES; |
| 262 |
|
| else |
| 263 |
1 |
| XSRETURN_NO; |
| 264 |
|
| } |
| 265 |
|
| |
| 266 |
|
| bool |
| 267 |
|
| accept_is_paused (struct feer_server *server) |
| 268 |
|
| CODE: |
| 269 |
|
| { |
| 270 |
30 |
| RETVAL = (server->n_listeners > 0); |
| 271 |
58 |
▶ | for (int i = 0; i < server->n_listeners; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (int i = 0; i < server->n_listeners; i++) { |
30 |
28 |
58 |
|
| 272 |
30 |
▶ | if (!(server->listeners[i].pause_flags & FEER_PAUSE_USER)) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(server->listeners[i].pause_flags & FEER_PAUSE_USER)) { |
2 |
28 |
30 |
|
| 273 |
2 |
| RETVAL = 0; break; |
| 274 |
|
| } |
| 275 |
|
| } |
| 276 |
|
| } |
| 277 |
|
| OUTPUT: |
| 278 |
|
| RETVAL |
| 279 |
|
| |
| 280 |
|
| void |
| 281 |
|
| request_handler(struct feer_server *server, SV *cb) |
| 282 |
|
| PROTOTYPE: $& |
| 283 |
|
| ALIAS: |
| 284 |
|
| psgi_request_handler = 1 |
| 285 |
|
| PPCODE: |
| 286 |
|
| { |
| 287 |
579 |
▶ | if (unlikely(!SvOK(cb) || !SvROK(cb))) |
Branch: 2 branches
| Branch | True | False | Total |
| if (unlikely(!SvOK(cb) || !SvROK(cb))) |
579 |
0 |
579 |
| if (unlikely(!SvOK(cb) || !SvROK(cb))) |
0 |
579 |
579 |
|
| 288 |
0 |
| croak("can't supply an undef handler"); |
| 289 |
579 |
| SvREFCNT_dec(server->request_cb_cv); |
| 290 |
579 |
| server->request_cb_cv = newSVsv(cb); |
| 291 |
579 |
| server->request_cb_is_psgi = ix; |
| 292 |
|
| trace("assigned %s request handler %p\n", |
| 293 |
|
| ix ? "PSGI" : "Feersum", server->request_cb_cv); |
| 294 |
|
| } |
| 295 |
|
| |
| 296 |
|
| void |
| 297 |
|
| graceful_shutdown (struct feer_server *server, SV *cb) |
| 298 |
|
| PROTOTYPE: $& |
| 299 |
|
| PPCODE: |
| 300 |
|
| { |
| 301 |
161 |
▶ | if (!IsCodeRef(cb)) |
Branch: 2 branches
| Branch | True | False | Total |
| if (!IsCodeRef(cb)) |
161 |
0 |
161 |
| if (!IsCodeRef(cb)) |
0 |
161 |
161 |
|
| 302 |
0 |
| croak("must supply a code reference"); |
| 303 |
161 |
▶ | if (unlikely(server->shutting_down)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (unlikely(server->shutting_down)) |
1 |
160 |
161 |
|
| 304 |
1 |
| croak("already shutting down"); |
| 305 |
160 |
| feer_begin_graceful_shutdown(aTHX_ server, cb); |
| 306 |
|
| } |
| 307 |
|
| |
| 308 |
|
| void |
| 309 |
|
| access_log (struct feer_server *server, ...) |
| 310 |
|
| PROTOTYPE: $;$ |
| 311 |
|
| PPCODE: |
| 312 |
|
| { |
| 313 |
4 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
3 |
1 |
4 |
|
| 314 |
3 |
| SV *cb = ST(1); |
| 315 |
3 |
▶ | if (SvOK(cb) && !IsCodeRef(cb)) |
Branch: 3 branches
| Branch | True | False | Total |
| if (SvOK(cb) && !IsCodeRef(cb)) |
2 |
1 |
3 |
| if (SvOK(cb) && !IsCodeRef(cb)) |
2 |
0 |
2 |
| if (SvOK(cb) && !IsCodeRef(cb)) |
0 |
2 |
2 |
|
| 316 |
0 |
| croak("access_log must be a code reference or undef"); |
| 317 |
3 |
| SvREFCNT_dec(server->access_log_cb_cv); |
| 318 |
3 |
▶ | server->access_log_cb_cv = SvOK(cb) ? newSVsv(cb) : NULL; |
Branch: 1 branch
| Branch | True | False | Total |
| server->access_log_cb_cv = SvOK(cb) ? newSVsv(cb) : NULL; |
2 |
1 |
3 |
|
| 319 |
|
| } |
| 320 |
4 |
▶ | if (server->access_log_cb_cv) |
Branch: 1 branch
| Branch | True | False | Total |
| if (server->access_log_cb_cv) |
3 |
1 |
4 |
|
| 321 |
3 |
▶ | XPUSHs(sv_2mortal(newSVsv(server->access_log_cb_cv))); |
Branch: 1 branch
| Branch | True | False | Total |
| XPUSHs(sv_2mortal(newSVsv(server->access_log_cb_cv))); |
0 |
3 |
3 |
|
| 322 |
|
| else |
| 323 |
1 |
▶ | XPUSHs(&PL_sv_undef); |
Branch: 1 branch
| Branch | True | False | Total |
| XPUSHs(&PL_sv_undef); |
0 |
1 |
1 |
|
| 324 |
4 |
| XSRETURN(1); |
| 325 |
|
| } |
| 326 |
|
| |
| 327 |
|
| void |
| 328 |
|
| max_requests_per_worker (struct feer_server *server, ...) |
| 329 |
|
| PROTOTYPE: $;$$$ |
| 330 |
|
| PPCODE: |
| 331 |
|
| { |
| 332 |
2 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
2 |
0 |
2 |
|
| 333 |
|
| /* range-check the NV, as every limit here does: SvIV saturates at |
| 334 |
|
| * 2**63 and past UV range; !(>=) also catches NaN */ |
| 335 |
2 |
| NV want = SvNV(ST(1)); |
| 336 |
2 |
▶ | if (!(want >= 0.0)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(want >= 0.0)) |
1 |
1 |
2 |
|
| 337 |
1 |
| croak("max_requests_per_worker must be non-negative"); |
| 338 |
1 |
▶ | UV limit = want >= (NV)UV_MAX ? UV_MAX : (UV)want; |
Branch: 1 branch
| Branch | True | False | Total |
| UV limit = want >= (NV)UV_MAX ? UV_MAX : (UV)want; |
0 |
1 |
1 |
|
| 339 |
1 |
▶ | if (limit && (items < 3 || !IsCodeRef(ST(2)))) |
Branch: 4 branches
| Branch | True | False | Total |
| if (limit && (items < 3 || !IsCodeRef(ST(2)))) |
1 |
0 |
1 |
| if (limit && (items < 3 || !IsCodeRef(ST(2)))) |
1 |
0 |
1 |
| if (limit && (items < 3 || !IsCodeRef(ST(2)))) |
1 |
0 |
1 |
| if (limit && (items < 3 || !IsCodeRef(ST(2)))) |
0 |
1 |
1 |
|
| 340 |
0 |
| croak("must supply a code reference to run once the worker has drained"); |
| 341 |
1 |
▶ | bool has_begin = limit && items > 3 && SvOK(ST(3)); |
Branch: 3 branches
| Branch | True | False | Total |
| bool has_begin = limit && items > 3 && SvOK(ST(3)); |
1 |
0 |
1 |
| bool has_begin = limit && items > 3 && SvOK(ST(3)); |
0 |
1 |
1 |
| bool has_begin = limit && items > 3 && SvOK(ST(3)); |
0 |
0 |
0 |
|
| 342 |
1 |
▶ | if (has_begin && !IsCodeRef(ST(3))) |
Branch: 3 branches
| Branch | True | False | Total |
| if (has_begin && !IsCodeRef(ST(3))) |
0 |
1 |
1 |
| if (has_begin && !IsCodeRef(ST(3))) |
0 |
0 |
0 |
| if (has_begin && !IsCodeRef(ST(3))) |
0 |
0 |
0 |
|
| 343 |
0 |
| croak("the retirement callback must be a code reference"); |
| 344 |
1 |
| SvREFCNT_dec(server->max_requests_cb_cv); |
| 345 |
1 |
| SvREFCNT_dec(server->retire_begin_cb_cv); |
| 346 |
1 |
▶ | server->max_requests_cb_cv = limit ? newSVsv(ST(2)) : NULL; |
Branch: 1 branch
| Branch | True | False | Total |
| server->max_requests_cb_cv = limit ? newSVsv(ST(2)) : NULL; |
1 |
0 |
1 |
|
| 347 |
1 |
▶ | server->retire_begin_cb_cv = has_begin ? newSVsv(ST(3)) : NULL; |
Branch: 1 branch
| Branch | True | False | Total |
| server->retire_begin_cb_cv = has_begin ? newSVsv(ST(3)) : NULL; |
0 |
1 |
1 |
|
| 348 |
1 |
| server->max_requests = (UV)limit; |
| 349 |
|
| } |
| 350 |
1 |
| XSRETURN_UV(server->max_requests); |
| 351 |
|
| } |
| 352 |
|
| |
| 353 |
|
| double |
| 354 |
|
| read_timeout (struct feer_server *server, ...) |
| 355 |
|
| PROTOTYPE: $;$ |
| 356 |
|
| CODE: |
| 357 |
|
| { |
| 358 |
8191 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
6179 |
2012 |
8191 |
|
| 359 |
6179 |
| double val = SvNV(ST(1)); |
| 360 |
6179 |
▶ | if (!(val > 0.0)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(val > 0.0)) |
4 |
6175 |
6179 |
|
| 361 |
4 |
| croak("read_timeout must be a positive (non-zero) value"); |
| 362 |
|
| trace("set read_timeout %f\n", val); |
| 363 |
6175 |
| server->read_timeout = val; |
| 364 |
|
| } |
| 365 |
8187 |
▶ | RETVAL = server->read_timeout; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->read_timeout; |
7998 |
189 |
8187 |
|
| 366 |
|
| } |
| 367 |
|
| OUTPUT: |
| 368 |
|
| RETVAL |
| 369 |
|
| |
| 370 |
|
| double |
| 371 |
|
| header_timeout (struct feer_server *server, ...) |
| 372 |
|
| PROTOTYPE: $;$ |
| 373 |
|
| CODE: |
| 374 |
|
| { |
| 375 |
32 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
27 |
5 |
32 |
|
| 376 |
27 |
| double val = SvNV(ST(1)); |
| 377 |
27 |
▶ | if (!(val >= 0.0)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(val >= 0.0)) |
3 |
24 |
27 |
|
| 378 |
3 |
| croak("header_timeout must be non-negative (0 to disable)"); |
| 379 |
|
| trace("set header_timeout %f\n", val); |
| 380 |
24 |
| server->header_timeout = val; |
| 381 |
|
| } |
| 382 |
29 |
▶ | RETVAL = server->header_timeout; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->header_timeout; |
2 |
27 |
29 |
|
| 383 |
|
| } |
| 384 |
|
| OUTPUT: |
| 385 |
|
| RETVAL |
| 386 |
|
| |
| 387 |
|
| double |
| 388 |
|
| write_timeout (struct feer_server *server, ...) |
| 389 |
|
| PROTOTYPE: $;$ |
| 390 |
|
| CODE: |
| 391 |
|
| { |
| 392 |
14 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
10 |
4 |
14 |
|
| 393 |
10 |
| double val = SvNV(ST(1)); |
| 394 |
10 |
▶ | if (!(val >= 0.0)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(val >= 0.0)) |
3 |
7 |
10 |
|
| 395 |
3 |
| croak("write_timeout must be non-negative (0 to disable)"); |
| 396 |
|
| trace("set write_timeout %f\n", val); |
| 397 |
7 |
| server->write_timeout = val; |
| 398 |
|
| } |
| 399 |
11 |
▶ | RETVAL = server->write_timeout; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->write_timeout; |
3 |
8 |
11 |
|
| 400 |
|
| } |
| 401 |
|
| OUTPUT: |
| 402 |
|
| RETVAL |
| 403 |
|
| |
| 404 |
|
| double |
| 405 |
|
| linger_timeout (struct feer_server *server, ...) |
| 406 |
|
| PROTOTYPE: $;$ |
| 407 |
|
| CODE: |
| 408 |
|
| { |
| 409 |
185 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
184 |
1 |
185 |
|
| 410 |
184 |
| double val = SvNV(ST(1)); |
| 411 |
184 |
▶ | if (!(val >= 0.0)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(val >= 0.0)) |
2 |
182 |
184 |
|
| 412 |
2 |
| croak("linger_timeout must be non-negative (0 to disable)"); |
| 413 |
|
| trace("set linger_timeout %f\n", val); |
| 414 |
182 |
| server->linger_timeout = val; |
| 415 |
|
| } |
| 416 |
183 |
▶ | RETVAL = server->linger_timeout; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->linger_timeout; |
3 |
180 |
183 |
|
| 417 |
|
| } |
| 418 |
|
| OUTPUT: |
| 419 |
|
| RETVAL |
| 420 |
|
| |
| 421 |
|
| double |
| 422 |
|
| eof_park_timeout (struct feer_server *server, ...) |
| 423 |
|
| PROTOTYPE: $;$ |
| 424 |
|
| CODE: |
| 425 |
|
| { |
| 426 |
114 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
87 |
27 |
114 |
|
| 427 |
87 |
| double val = SvNV(ST(1)); |
| 428 |
87 |
▶ | if (!(val >= 0.0)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(val >= 0.0)) |
18 |
69 |
87 |
|
| 429 |
18 |
| croak("eof_park_timeout must be non-negative (0 to disable)"); |
| 430 |
|
| trace("set eof_park_timeout %f\n", val); |
| 431 |
69 |
| server->eof_park_timeout = val; |
| 432 |
|
| } |
| 433 |
96 |
▶ | RETVAL = server->eof_park_timeout; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->eof_park_timeout; |
0 |
96 |
96 |
|
| 434 |
|
| } |
| 435 |
|
| OUTPUT: |
| 436 |
|
| RETVAL |
| 437 |
|
| |
| 438 |
|
| void |
| 439 |
|
| set_keepalive (struct feer_server *server, SV *set) |
| 440 |
|
| PPCODE: |
| 441 |
|
| { |
| 442 |
|
| trace("set keepalive %d\n", SvTRUE(set)); |
| 443 |
201 |
| server->is_keepalive = SvTRUE(set); |
| 444 |
|
| } |
| 445 |
|
| |
| 446 |
|
| int |
| 447 |
|
| get_keepalive (struct feer_server *server) |
| 448 |
|
| CODE: |
| 449 |
9 |
▶ | RETVAL = server->is_keepalive ? 1 : 0; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->is_keepalive ? 1 : 0; |
5 |
4 |
9 |
|
| 450 |
|
| OUTPUT: |
| 451 |
|
| RETVAL |
| 452 |
|
| |
| 453 |
|
| void |
| 454 |
|
| set_drain_accept_queue (struct feer_server *server, SV *set) |
| 455 |
|
| PPCODE: |
| 456 |
|
| { |
| 457 |
|
| trace("set drain_accept_queue %d\n", SvTRUE(set)); |
| 458 |
2 |
| server->drain_accept_queue = SvTRUE(set); |
| 459 |
|
| #ifdef TCP_DEFER_ACCEPT |
| 460 |
|
| /* Keep TCP_DEFER_ACCEPT in sync on listeners registered before this |
| 461 |
|
| * call, so the order against use_socket() does not matter. A deferred |
| 462 |
|
| * connection is invisible to accept() until its data arrives, and the |
| 463 |
|
| * shutdown drain would close the listener on top of it. */ |
| 464 |
4 |
▶ | for (int i = 0; i < server->n_listeners; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (int i = 0; i < server->n_listeners; i++) { |
2 |
2 |
4 |
|
| 465 |
2 |
| struct feer_listen *lsnr = &server->listeners[i]; |
| 466 |
2 |
▶ | if (lsnr->is_tcp && lsnr->fd >= 0 |
Branch: 2 branches
| Branch | True | False | Total |
| if (lsnr->is_tcp && lsnr->fd >= 0 |
2 |
0 |
2 |
| if (lsnr->is_tcp && lsnr->fd >= 0 |
2 |
0 |
2 |
|
| 467 |
2 |
▶ | && setsockopt(lsnr->fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, |
Branch: 1 branch
| Branch | True | False | Total |
| && setsockopt(lsnr->fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, |
0 |
2 |
2 |
|
| 468 |
2 |
| &(int){ server->drain_accept_queue ? 0 : 1 }, |
| 469 |
|
| sizeof(int)) < 0) |
| 470 |
0 |
| trouble("setsockopt TCP_DEFER_ACCEPT fd=%d: %s\n", |
| 471 |
|
| lsnr->fd, strerror(errno)); |
| 472 |
|
| } |
| 473 |
|
| #endif |
| 474 |
|
| } |
| 475 |
|
| |
| 476 |
|
| int |
| 477 |
|
| get_drain_accept_queue (struct feer_server *server) |
| 478 |
|
| CODE: |
| 479 |
2 |
▶ | RETVAL = server->drain_accept_queue ? 1 : 0; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->drain_accept_queue ? 1 : 0; |
0 |
2 |
2 |
|
| 480 |
|
| OUTPUT: |
| 481 |
|
| RETVAL |
| 482 |
|
| |
| 483 |
|
| void |
| 484 |
|
| set_reverse_proxy (struct feer_server *server, SV *set) |
| 485 |
|
| PPCODE: |
| 486 |
|
| { |
| 487 |
|
| trace("set reverse_proxy %d\n", SvTRUE(set)); |
| 488 |
18 |
| server->use_reverse_proxy = SvTRUE(set); |
| 489 |
|
| } |
| 490 |
|
| |
| 491 |
|
| int |
| 492 |
|
| get_reverse_proxy (struct feer_server *server) |
| 493 |
|
| CODE: |
| 494 |
|
| { |
| 495 |
11 |
▶ | RETVAL = server->use_reverse_proxy; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->use_reverse_proxy; |
7 |
4 |
11 |
|
| 496 |
|
| } |
| 497 |
|
| OUTPUT: |
| 498 |
|
| RETVAL |
| 499 |
|
| |
| 500 |
|
| void |
| 501 |
|
| set_psgix_io (struct feer_server *server, SV *set) |
| 502 |
|
| PPCODE: |
| 503 |
|
| { |
| 504 |
7 |
| server->psgix_io = SvTRUE(set); |
| 505 |
|
| trace("set psgix_io %d\n", server->psgix_io); |
| 506 |
|
| } |
| 507 |
|
| |
| 508 |
|
| int |
| 509 |
|
| get_psgix_io (struct feer_server *server) |
| 510 |
|
| CODE: |
| 511 |
|
| { |
| 512 |
9 |
▶ | RETVAL = server->psgix_io; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->psgix_io; |
7 |
2 |
9 |
|
| 513 |
|
| } |
| 514 |
|
| OUTPUT: |
| 515 |
|
| RETVAL |
| 516 |
|
| |
| 517 |
|
| void |
| 518 |
|
| set_proxy_protocol (struct feer_server *server, SV *set) |
| 519 |
|
| PPCODE: |
| 520 |
|
| { |
| 521 |
|
| trace("set proxy_protocol %d\n", SvTRUE(set)); |
| 522 |
64 |
| server->use_proxy_protocol = SvTRUE(set); |
| 523 |
|
| } |
| 524 |
|
| |
| 525 |
|
| int |
| 526 |
|
| get_proxy_protocol (struct feer_server *server) |
| 527 |
|
| CODE: |
| 528 |
|
| { |
| 529 |
11 |
▶ | RETVAL = server->use_proxy_protocol; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->use_proxy_protocol; |
7 |
4 |
11 |
|
| 530 |
|
| } |
| 531 |
|
| OUTPUT: |
| 532 |
|
| RETVAL |
| 533 |
|
| |
| 534 |
|
| int |
| 535 |
|
| read_priority (struct feer_server *server, ...) |
| 536 |
|
| ALIAS: |
| 537 |
|
| write_priority = 1 |
| 538 |
|
| accept_priority = 2 |
| 539 |
|
| PROTOTYPE: $;$ |
| 540 |
|
| CODE: |
| 541 |
|
| { |
| 542 |
|
| static const char *names[] = {"read", "write", "accept"}; |
| 543 |
|
| PERL_UNUSED_VAR(names); /* only consumed by trace() */ |
| 544 |
18094 |
| int *field = ix == 2 ? &server->accept_priority |
| 545 |
30158 |
▶ | : ix == 1 ? &server->write_priority |
Branch: 1 branch
| Branch | True | False | Total |
| : ix == 1 ? &server->write_priority |
6030 |
12064 |
18094 |
|
| 546 |
12064 |
▶ | : &server->read_priority; |
Branch: 1 branch
| Branch | True | False | Total |
| : &server->read_priority; |
6032 |
6032 |
12064 |
|
| 547 |
18094 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
18049 |
45 |
18094 |
|
| 548 |
|
| /* narrowing SvIV to int wraps; !(>) sends NaN to EV_MINPRI */ |
| 549 |
18049 |
| NV want = SvNV(ST(1)); |
| 550 |
18049 |
| int new_priority = !(want > (NV)EV_MINPRI) ? EV_MINPRI |
| 551 |
30094 |
▶ | : want >= (NV)EV_MAXPRI ? EV_MAXPRI |
Branch: 1 branch
| Branch | True | False | Total |
| : want >= (NV)EV_MAXPRI ? EV_MAXPRI |
12045 |
6004 |
18049 |
|
| 552 |
12045 |
▶ | : (int)want; |
Branch: 1 branch
| Branch | True | False | Total |
| : (int)want; |
6038 |
6007 |
12045 |
|
| 553 |
|
| trace("set %s_priority %d\n", names[ix], new_priority); |
| 554 |
18049 |
| *field = new_priority; |
| 555 |
|
| } |
| 556 |
18094 |
▶ | RETVAL = *field; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = *field; |
18062 |
32 |
18094 |
|
| 557 |
|
| } |
| 558 |
|
| OUTPUT: |
| 559 |
|
| RETVAL |
| 560 |
|
| |
| 561 |
|
| int |
| 562 |
|
| max_accept_per_loop (struct feer_server *server, ...) |
| 563 |
|
| PROTOTYPE: $;$ |
| 564 |
|
| CODE: |
| 565 |
|
| { |
| 566 |
46 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
25 |
21 |
46 |
|
| 567 |
25 |
| NV want = SvNV(ST(1)); |
| 568 |
25 |
| int new_max = !(want >= 1) ? 1 /* also catches NaN */ |
| 569 |
46 |
▶ | : want >= (NV)INT_MAX ? INT_MAX |
Branch: 1 branch
| Branch | True | False | Total |
| : want >= (NV)INT_MAX ? INT_MAX |
21 |
4 |
25 |
|
| 570 |
21 |
▶ | : (int)want; |
Branch: 1 branch
| Branch | True | False | Total |
| : (int)want; |
12 |
9 |
21 |
|
| 571 |
|
| trace("set max_accept_per_loop %d\n", new_max); |
| 572 |
25 |
| server->max_accept_per_loop = new_max; |
| 573 |
|
| } |
| 574 |
46 |
▶ | RETVAL = server->max_accept_per_loop; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->max_accept_per_loop; |
24 |
22 |
46 |
|
| 575 |
|
| } |
| 576 |
|
| OUTPUT: |
| 577 |
|
| RETVAL |
| 578 |
|
| |
| 579 |
|
| int |
| 580 |
|
| active_conns (struct feer_server *server) |
| 581 |
|
| CODE: |
| 582 |
332 |
▶ | RETVAL = server->active_conns; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->active_conns; |
79 |
253 |
332 |
|
| 583 |
|
| OUTPUT: |
| 584 |
|
| RETVAL |
| 585 |
|
| |
| 586 |
|
| int |
| 587 |
|
| max_connections (struct feer_server *server, ...) |
| 588 |
|
| PROTOTYPE: $;$ |
| 589 |
|
| CODE: |
| 590 |
|
| { |
| 591 |
249 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
229 |
20 |
249 |
|
| 592 |
229 |
| NV want = SvNV(ST(1)); |
| 593 |
229 |
| int new_max = !(want > 0) ? 0 /* <= 0, or NaN: unlimited */ |
| 594 |
424 |
▶ | : want >= (NV)INT_MAX ? INT_MAX |
Branch: 1 branch
| Branch | True | False | Total |
| : want >= (NV)INT_MAX ? INT_MAX |
195 |
34 |
229 |
|
| 595 |
195 |
▶ | : (int)want; |
Branch: 1 branch
| Branch | True | False | Total |
| : (int)want; |
11 |
184 |
195 |
|
| 596 |
|
| trace("set max_connections %d\n", new_max); |
| 597 |
229 |
| server->max_connections = new_max; |
| 598 |
229 |
| feer_server_resume_capacity(server); |
| 599 |
|
| } |
| 600 |
249 |
▶ | RETVAL = server->max_connections; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->max_connections; |
27 |
222 |
249 |
|
| 601 |
|
| } |
| 602 |
|
| OUTPUT: |
| 603 |
|
| RETVAL |
| 604 |
|
| |
| 605 |
|
| size_t |
| 606 |
|
| max_read_buf (struct feer_server *server, ...) |
| 607 |
|
| PROTOTYPE: $;$ |
| 608 |
|
| CODE: |
| 609 |
|
| { |
| 610 |
47 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
33 |
14 |
47 |
|
| 611 |
|
| /* clamp on the NV: a UV into size_t truncates where they differ */ |
| 612 |
33 |
| NV want = SvNV(ST(1)); |
| 613 |
33 |
▶ | if (want < 0.0) |
Branch: 1 branch
| Branch | True | False | Total |
| if (want < 0.0) |
1 |
32 |
33 |
|
| 614 |
1 |
| croak("max_read_buf must be non-negative"); |
| 615 |
32 |
| size_t new_max = !(want > 0.0) ? 0 /* 0, or NaN: default */ |
| 616 |
62 |
▶ | : want >= (NV)SIZE_MAX ? SIZE_MAX |
Branch: 1 branch
| Branch | True | False | Total |
| : want >= (NV)SIZE_MAX ? SIZE_MAX |
30 |
2 |
32 |
|
| 617 |
30 |
▶ | : (size_t)want; |
Branch: 1 branch
| Branch | True | False | Total |
| : (size_t)want; |
2 |
28 |
30 |
|
| 618 |
32 |
▶ | if (new_max == 0) new_max = MAX_READ_BUF; |
Branch: 1 branch
| Branch | True | False | Total |
| if (new_max == 0) new_max = MAX_READ_BUF; |
2 |
30 |
32 |
|
| 619 |
32 |
| server->max_read_buf = new_max; |
| 620 |
|
| } |
| 621 |
46 |
▶ | RETVAL = server->max_read_buf; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->max_read_buf; |
18 |
28 |
46 |
|
| 622 |
|
| } |
| 623 |
|
| OUTPUT: |
| 624 |
|
| RETVAL |
| 625 |
|
| |
| 626 |
|
| size_t |
| 627 |
|
| max_body_len (struct feer_server *server, ...) |
| 628 |
|
| PROTOTYPE: $;$ |
| 629 |
|
| CODE: |
| 630 |
|
| { |
| 631 |
46 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
32 |
14 |
46 |
|
| 632 |
32 |
| NV want = SvNV(ST(1)); |
| 633 |
32 |
▶ | if (want < 0.0) |
Branch: 1 branch
| Branch | True | False | Total |
| if (want < 0.0) |
1 |
31 |
32 |
|
| 634 |
1 |
| croak("max_body_len must be non-negative"); |
| 635 |
31 |
| size_t new_max = !(want > 0.0) ? 0 /* 0, or NaN: default */ |
| 636 |
61 |
▶ | : want >= (NV)SIZE_MAX ? SIZE_MAX |
Branch: 1 branch
| Branch | True | False | Total |
| : want >= (NV)SIZE_MAX ? SIZE_MAX |
30 |
1 |
31 |
|
| 637 |
30 |
▶ | : (size_t)want; |
Branch: 1 branch
| Branch | True | False | Total |
| : (size_t)want; |
2 |
28 |
30 |
|
| 638 |
31 |
▶ | if (new_max == 0) new_max = MAX_BODY_LEN; |
Branch: 1 branch
| Branch | True | False | Total |
| if (new_max == 0) new_max = MAX_BODY_LEN; |
1 |
30 |
31 |
|
| 639 |
31 |
| server->max_body_len = new_max; |
| 640 |
|
| } |
| 641 |
45 |
▶ | RETVAL = server->max_body_len; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->max_body_len; |
16 |
29 |
45 |
|
| 642 |
|
| } |
| 643 |
|
| OUTPUT: |
| 644 |
|
| RETVAL |
| 645 |
|
| |
| 646 |
|
| size_t |
| 647 |
|
| max_uri_len (struct feer_server *server, ...) |
| 648 |
|
| PROTOTYPE: $;$ |
| 649 |
|
| CODE: |
| 650 |
|
| { |
| 651 |
42 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
25 |
17 |
42 |
|
| 652 |
25 |
| NV want = SvNV(ST(1)); |
| 653 |
25 |
▶ | if (want < 0.0) |
Branch: 1 branch
| Branch | True | False | Total |
| if (want < 0.0) |
1 |
24 |
25 |
|
| 654 |
1 |
| croak("max_uri_len must be non-negative"); |
| 655 |
24 |
| size_t new_max = !(want > 0.0) ? 0 /* 0, or NaN: default */ |
| 656 |
47 |
▶ | : want >= (NV)SIZE_MAX ? SIZE_MAX |
Branch: 1 branch
| Branch | True | False | Total |
| : want >= (NV)SIZE_MAX ? SIZE_MAX |
23 |
1 |
24 |
|
| 657 |
23 |
▶ | : (size_t)want; |
Branch: 1 branch
| Branch | True | False | Total |
| : (size_t)want; |
2 |
21 |
23 |
|
| 658 |
24 |
▶ | if (new_max == 0) new_max = MAX_URI_LEN; |
Branch: 1 branch
| Branch | True | False | Total |
| if (new_max == 0) new_max = MAX_URI_LEN; |
1 |
23 |
24 |
|
| 659 |
24 |
| server->max_uri_len = new_max; |
| 660 |
|
| } |
| 661 |
41 |
▶ | RETVAL = server->max_uri_len; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->max_uri_len; |
16 |
25 |
41 |
|
| 662 |
|
| } |
| 663 |
|
| OUTPUT: |
| 664 |
|
| RETVAL |
| 665 |
|
| |
| 666 |
|
| size_t |
| 667 |
|
| wbuf_low_water (struct feer_server *server, ...) |
| 668 |
|
| PROTOTYPE: $;$ |
| 669 |
|
| CODE: |
| 670 |
|
| { |
| 671 |
34 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
19 |
15 |
34 |
|
| 672 |
19 |
| NV want = SvNV(ST(1)); |
| 673 |
19 |
▶ | if (want < 0.0) |
Branch: 1 branch
| Branch | True | False | Total |
| if (want < 0.0) |
1 |
18 |
19 |
|
| 674 |
1 |
| croak("wbuf_low_water must be non-negative"); |
| 675 |
18 |
| server->wbuf_low_water = !(want > 0.0) ? 0 |
| 676 |
34 |
▶ | : want >= (NV)SIZE_MAX ? SIZE_MAX |
Branch: 1 branch
| Branch | True | False | Total |
| : want >= (NV)SIZE_MAX ? SIZE_MAX |
16 |
2 |
18 |
|
| 677 |
16 |
▶ | : (size_t)want; |
Branch: 1 branch
| Branch | True | False | Total |
| : (size_t)want; |
2 |
14 |
16 |
|
| 678 |
|
| } |
| 679 |
33 |
▶ | RETVAL = server->wbuf_low_water; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->wbuf_low_water; |
16 |
17 |
33 |
|
| 680 |
|
| } |
| 681 |
|
| OUTPUT: |
| 682 |
|
| RETVAL |
| 683 |
|
| |
| 684 |
|
| void |
| 685 |
|
| set_multiprocess (struct feer_server *server, SV *set) |
| 686 |
|
| PPCODE: |
| 687 |
|
| { |
| 688 |
6 |
| server->multiprocess = SvTRUE(set); |
| 689 |
|
| } |
| 690 |
|
| |
| 691 |
|
| int |
| 692 |
|
| get_multiprocess (struct feer_server *server) |
| 693 |
|
| CODE: |
| 694 |
7 |
▶ | RETVAL = server->multiprocess ? 1 : 0; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->multiprocess ? 1 : 0; |
7 |
0 |
7 |
|
| 695 |
|
| OUTPUT: |
| 696 |
|
| RETVAL |
| 697 |
|
| |
| 698 |
|
| int |
| 699 |
|
| max_h2_concurrent_streams (struct feer_server *server, ...) |
| 700 |
|
| PROTOTYPE: $;$ |
| 701 |
|
| CODE: |
| 702 |
|
| { |
| 703 |
|
| #ifdef FEERSUM_HAS_H2 |
| 704 |
|
| if (items > 1) { |
| 705 |
|
| /* capped because h2_check_stream_poll_cbs uses a fixed-size stack array */ |
| 706 |
|
| NV want = SvNV(ST(1)); |
| 707 |
|
| int n = !(want >= 1) ? 1 /* also catches NaN */ |
| 708 |
|
| : want >= (NV)FEER_H2_MAX_CONCURRENT_STREAMS |
| 709 |
|
| ? FEER_H2_MAX_CONCURRENT_STREAMS |
| 710 |
|
| : (int)want; |
| 711 |
|
| server->max_h2_concurrent_streams = n; |
| 712 |
|
| } |
| 713 |
|
| RETVAL = server->max_h2_concurrent_streams; |
| 714 |
|
| #else |
| 715 |
|
| PERL_UNUSED_VAR(server); |
| 716 |
0 |
▶ | if (items > 1) |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) |
0 |
0 |
0 |
|
| 717 |
0 |
| warn("H2 not compiled in, max_h2_concurrent_streams ignored"); |
| 718 |
0 |
▶ | RETVAL = 0; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = 0; |
0 |
0 |
0 |
|
| 719 |
|
| #endif |
| 720 |
|
| } |
| 721 |
|
| OUTPUT: |
| 722 |
|
| RETVAL |
| 723 |
|
| |
| 724 |
|
| size_t |
| 725 |
|
| max_h2_conn_body (struct feer_server *server, ...) |
| 726 |
|
| PROTOTYPE: $;$ |
| 727 |
|
| CODE: |
| 728 |
|
| { |
| 729 |
|
| #ifdef FEERSUM_HAS_H2 |
| 730 |
|
| if (items > 1) { |
| 731 |
|
| NV want = SvNV(ST(1)); |
| 732 |
|
| if (want < 0.0) |
| 733 |
|
| croak("max_h2_conn_body must be non-negative"); |
| 734 |
|
| server->max_h2_conn_body = !(want > 0.0) ? 0 /* 0/NaN: off */ |
| 735 |
|
| : want >= (NV)SIZE_MAX ? SIZE_MAX |
| 736 |
|
| : (size_t)want; |
| 737 |
|
| } |
| 738 |
|
| RETVAL = server->max_h2_conn_body; |
| 739 |
|
| #else |
| 740 |
|
| PERL_UNUSED_VAR(server); |
| 741 |
0 |
▶ | if (items > 1) |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) |
0 |
0 |
0 |
|
| 742 |
0 |
| warn("H2 not compiled in, max_h2_conn_body ignored"); |
| 743 |
0 |
▶ | RETVAL = 0; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = 0; |
0 |
0 |
0 |
|
| 744 |
|
| #endif |
| 745 |
|
| } |
| 746 |
|
| OUTPUT: |
| 747 |
|
| RETVAL |
| 748 |
|
| |
| 749 |
|
| UV |
| 750 |
|
| total_requests (struct feer_server *server) |
| 751 |
|
| CODE: |
| 752 |
3 |
▶ | RETVAL = server->total_requests; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->total_requests; |
0 |
3 |
3 |
|
| 753 |
|
| OUTPUT: |
| 754 |
|
| RETVAL |
| 755 |
|
| |
| 756 |
|
| unsigned int |
| 757 |
|
| max_connection_reqs (struct feer_server *server, ...) |
| 758 |
|
| PROTOTYPE: $;$ |
| 759 |
|
| CODE: |
| 760 |
|
| { |
| 761 |
31 |
▶ | if (items > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (items > 1) { |
19 |
12 |
31 |
|
| 762 |
19 |
| NV want = SvNV(ST(1)); |
| 763 |
19 |
▶ | if (!(want >= 0.0)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(want >= 0.0)) |
1 |
18 |
19 |
|
| 764 |
1 |
| croak("max_connection_reqs must be non-negative (0 for unlimited)"); |
| 765 |
18 |
▶ | unsigned int reqs = want >= (NV)UINT_MAX ? UINT_MAX : (unsigned int)want; |
Branch: 1 branch
| Branch | True | False | Total |
| unsigned int reqs = want >= (NV)UINT_MAX ? UINT_MAX : (unsigned int)want; |
9 |
9 |
18 |
|
| 766 |
|
| trace("set max requests per connection %u\n", reqs); |
| 767 |
18 |
| server->max_connection_reqs = reqs; |
| 768 |
|
| } |
| 769 |
30 |
▶ | RETVAL = server->max_connection_reqs; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = server->max_connection_reqs; |
22 |
8 |
30 |
|
| 770 |
|
| } |
| 771 |
|
| OUTPUT: |
| 772 |
|
| RETVAL |
| 773 |
|
| |
| 774 |
|
| void |
| 775 |
|
| _xs_destroy (struct feer_server *server) |
| 776 |
|
| PPCODE: |
| 777 |
|
| { |
| 778 |
|
| trace3("DESTROY server\n"); |
| 779 |
|
| /* the server may be freed without unlisten(): stop everything that points at it */ |
| 780 |
830 |
| ev_prepare_stop(feersum_ev_loop, &server->ep); |
| 781 |
830 |
| ev_check_stop(feersum_ev_loop, &server->ec); |
| 782 |
830 |
| ev_idle_stop(feersum_ev_loop, &server->ei); |
| 783 |
830 |
| SvREFCNT_dec(server->request_cb_cv); |
| 784 |
830 |
| SvREFCNT_dec(server->shutdown_cb_cv); |
| 785 |
830 |
| SvREFCNT_dec(server->max_requests_cb_cv); |
| 786 |
830 |
| SvREFCNT_dec(server->retire_begin_cb_cv); |
| 787 |
830 |
| SvREFCNT_dec(server->access_log_cb_cv); |
| 788 |
1358 |
▶ | for (int i = 0; i < server->n_listeners; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (int i = 0; i < server->n_listeners; i++) { |
528 |
830 |
1358 |
|
| 789 |
528 |
| struct feer_listen *lsnr = &server->listeners[i]; |
| 790 |
528 |
| ev_io_stop(feersum_ev_loop, &lsnr->accept_w); |
| 791 |
528 |
| ev_timer_stop(feersum_ev_loop, &lsnr->emfile_w); |
| 792 |
528 |
| SvREFCNT_dec(lsnr->server_name); |
| 793 |
528 |
| SvREFCNT_dec(lsnr->server_port); |
| 794 |
|
| #ifdef FEERSUM_HAS_TLS |
| 795 |
528 |
| feer_tls_cleanup_listener(lsnr); |
| 796 |
|
| #endif |
| 797 |
|
| } |
| 798 |
830 |
▶ | if (server->watchers_initialized && --date_timer_refs <= 0) { |
Branch: 2 branches
| Branch | True | False | Total |
| if (server->watchers_initialized && --date_timer_refs <= 0) { |
322 |
508 |
830 |
| if (server->watchers_initialized && --date_timer_refs <= 0) { |
237 |
85 |
322 |
|
| 799 |
237 |
| ev_timer_stop(feersum_ev_loop, &date_timer); |
| 800 |
237 |
| date_timer_refs = 0; |
| 801 |
|
| } |
| 802 |
|
| } |
| 803 |
|
| |
| 804 |
|
| void |
| 805 |
|
| set_tls (struct feer_server *server, ...) |
| 806 |
|
| PPCODE: |
| 807 |
|
| { |
| 808 |
|
| #ifdef FEERSUM_HAS_TLS |
| 809 |
283 |
| const char *cert_file = NULL; |
| 810 |
283 |
| const char *key_file = NULL; |
| 811 |
283 |
| const char *sni_name = NULL; |
| 812 |
283 |
| int listener_idx = -1; /* -1 means last-added listener (default) */ |
| 813 |
283 |
| int h2 = 0; |
| 814 |
|
| int i; |
| 815 |
|
| |
| 816 |
283 |
▶ | if (items < 3 || (items - 1) % 2 != 0) |
Branch: 2 branches
| Branch | True | False | Total |
| if (items < 3 || (items - 1) % 2 != 0) |
282 |
1 |
283 |
| if (items < 3 || (items - 1) % 2 != 0) |
0 |
282 |
282 |
|
| 817 |
1 |
| croak("set_tls requires key => value pairs (cert_file => $path, key_file => $path)"); |
| 818 |
|
| |
| 819 |
989 |
▶ | for (i = 1; i < items; i += 2) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 1; i < items; i += 2) { |
717 |
272 |
989 |
|
| 820 |
717 |
| const char *key = SvPV_nolen(ST(i)); |
| 821 |
717 |
| SV *val = ST(i + 1); |
| 822 |
717 |
▶ | if (strcmp(key, "cert_file") == 0) |
Branch: 1 branch
| Branch | True | False | Total |
| if (strcmp(key, "cert_file") == 0) |
271 |
446 |
717 |
|
| 823 |
271 |
| cert_file = SvPV_nolen(val); |
| 824 |
446 |
▶ | else if (strcmp(key, "key_file") == 0) |
Branch: 1 branch
| Branch | True | False | Total |
| else if (strcmp(key, "key_file") == 0) |
271 |
175 |
446 |
|
| 825 |
271 |
| key_file = SvPV_nolen(val); |
| 826 |
175 |
▶ | else if (strcmp(key, "listener") == 0) { |
Branch: 1 branch
| Branch | True | False | Total |
| else if (strcmp(key, "listener") == 0) { |
16 |
159 |
175 |
|
| 827 |
|
| /* check the NV: SvIV wraps; !( ) also refuses NaN */ |
| 828 |
16 |
| NV want = SvNV(val); |
| 829 |
16 |
▶ | if (!(want >= -1.0 && want <= (NV)INT_MAX)) |
Branch: 2 branches
| Branch | True | False | Total |
| if (!(want >= -1.0 && want <= (NV)INT_MAX)) |
16 |
0 |
16 |
| if (!(want >= -1.0 && want <= (NV)INT_MAX)) |
8 |
8 |
16 |
|
| 830 |
8 |
| croak("set_tls: listener index %" NVgf " out of range (0..%d or -1)", |
| 831 |
|
| want, server->n_listeners - 1); |
| 832 |
8 |
| listener_idx = (int)want; |
| 833 |
|
| } |
| 834 |
159 |
▶ | else if (strcmp(key, "h2") == 0) |
Branch: 1 branch
| Branch | True | False | Total |
| else if (strcmp(key, "h2") == 0) |
53 |
106 |
159 |
|
| 835 |
53 |
| h2 = SvTRUE(val) ? 1 : 0; |
| 836 |
106 |
▶ | else if (strcmp(key, "sni") == 0) |
Branch: 1 branch
| Branch | True | False | Total |
| else if (strcmp(key, "sni") == 0) |
104 |
2 |
106 |
|
| 837 |
104 |
| sni_name = SvPV_nolen(val); |
| 838 |
|
| else |
| 839 |
2 |
| croak("set_tls: unknown option '%s'", key); |
| 840 |
|
| } |
| 841 |
|
| |
| 842 |
272 |
▶ | if (!cert_file) croak("set_tls: cert_file is required"); |
Branch: 1 branch
| Branch | True | False | Total |
| if (!cert_file) croak("set_tls: cert_file is required"); |
3 |
269 |
272 |
|
| 843 |
269 |
▶ | if (!key_file) croak("set_tls: key_file is required"); |
Branch: 1 branch
| Branch | True | False | Total |
| if (!key_file) croak("set_tls: key_file is required"); |
3 |
266 |
269 |
|
| 844 |
|
| |
| 845 |
266 |
▶ | if (server->n_listeners == 0) |
Branch: 1 branch
| Branch | True | False | Total |
| if (server->n_listeners == 0) |
3 |
263 |
266 |
|
| 846 |
3 |
| croak("set_tls: no listeners configured (call use_socket/accept_on_fd first)"); |
| 847 |
|
| |
| 848 |
263 |
▶ | if (listener_idx < -1) |
Branch: 1 branch
| Branch | True | False | Total |
| if (listener_idx < -1) |
0 |
263 |
263 |
|
| 849 |
0 |
| croak("set_tls: listener index %d out of range (0..%d or -1)", |
| 850 |
|
| listener_idx, server->n_listeners - 1); |
| 851 |
263 |
▶ | if (listener_idx < 0) |
Branch: 1 branch
| Branch | True | False | Total |
| if (listener_idx < 0) |
255 |
8 |
263 |
|
| 852 |
255 |
| listener_idx = server->n_listeners - 1; |
| 853 |
263 |
▶ | if (listener_idx >= server->n_listeners) |
Branch: 1 branch
| Branch | True | False | Total |
| if (listener_idx >= server->n_listeners) |
2 |
261 |
263 |
|
| 854 |
2 |
| croak("set_tls: listener index %d out of range (0..%d)", |
| 855 |
|
| listener_idx, server->n_listeners - 1); |
| 856 |
|
| |
| 857 |
261 |
| struct feer_listen *lsnr = &server->listeners[listener_idx]; |
| 858 |
|
| |
| 859 |
|
| /* validate before creating the context: a croak after would leak it */ |
| 860 |
261 |
| STRLEN sni_name_len = 0; |
| 861 |
|
| char sni_lower[256]; |
| 862 |
261 |
| int sni_existing = -1; |
| 863 |
261 |
▶ | if (sni_name) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (sni_name) { |
104 |
157 |
261 |
|
| 864 |
104 |
| sni_name_len = strlen(sni_name); |
| 865 |
104 |
▶ | if (sni_name_len == 0) |
Branch: 1 branch
| Branch | True | False | Total |
| if (sni_name_len == 0) |
0 |
104 |
104 |
|
| 866 |
0 |
| croak("set_tls: SNI hostname must not be empty"); |
| 867 |
104 |
▶ | if (sni_name_len >= 256) |
Branch: 1 branch
| Branch | True | False | Total |
| if (sni_name_len >= 256) |
0 |
104 |
104 |
|
| 868 |
0 |
| croak("set_tls: SNI hostname too long"); |
| 869 |
104 |
▶ | if (!lsnr->tls_ctx_ref) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!lsnr->tls_ctx_ref) |
0 |
104 |
104 |
|
| 870 |
0 |
| croak("set_tls: set a default TLS context before adding SNI entries"); |
| 871 |
1340 |
▶ | for (i = 0; (size_t)i < sni_name_len; i++) |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; (size_t)i < sni_name_len; i++) |
1236 |
104 |
1340 |
|
| 872 |
1236 |
| sni_lower[i] = ascii_lower[(unsigned char)sni_name[i]]; |
| 873 |
104 |
| sni_lower[sni_name_len] = '\0'; |
| 874 |
|
| /* a re-registered name is a cert rotation and must work on a full table */ |
| 875 |
664 |
▶ | for (i = 0; i < lsnr->n_sni_entries; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < lsnr->n_sni_entries; i++) { |
624 |
40 |
664 |
|
| 876 |
624 |
▶ | if (strcmp(lsnr->sni_entries[i].hostname, sni_lower) == 0) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (strcmp(lsnr->sni_entries[i].hostname, sni_lower) == 0) { |
64 |
560 |
624 |
|
| 877 |
64 |
| sni_existing = i; |
| 878 |
64 |
| break; |
| 879 |
|
| } |
| 880 |
|
| } |
| 881 |
104 |
▶ | if (sni_existing < 0 && lsnr->n_sni_entries >= FEER_MAX_SNI_ENTRIES) |
Branch: 2 branches
| Branch | True | False | Total |
| if (sni_existing < 0 && lsnr->n_sni_entries >= FEER_MAX_SNI_ENTRIES) |
40 |
64 |
104 |
| if (sni_existing < 0 && lsnr->n_sni_entries >= FEER_MAX_SNI_ENTRIES) |
2 |
38 |
40 |
|
| 882 |
2 |
| croak("set_tls: too many SNI entries (max %d)", FEER_MAX_SNI_ENTRIES); |
| 883 |
|
| /* ALPN is negotiated by the default context, so a per-SNI h2 flag would be a no-op */ |
| 884 |
102 |
▶ | if (h2) |
Branch: 1 branch
| Branch | True | False | Total |
| if (h2) |
1 |
101 |
102 |
|
| 885 |
1 |
| croak("set_tls: 'h2' option is listener-wide; set it on the " |
| 886 |
|
| "default certificate, not per-SNI entry"); |
| 887 |
|
| } |
| 888 |
|
| |
| 889 |
258 |
| ptls_context_t *new_ctx = feer_tls_create_context(aTHX_ cert_file, key_file, h2); |
| 890 |
258 |
▶ | if (!new_ctx) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!new_ctx) |
7 |
251 |
258 |
|
| 891 |
7 |
| croak("set_tls: failed to create TLS context"); |
| 892 |
|
| |
| 893 |
251 |
▶ | if (sni_name) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (sni_name) { |
101 |
150 |
251 |
|
| 894 |
|
| struct feer_sni_entry *e; |
| 895 |
101 |
▶ | if (sni_existing >= 0) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (sni_existing >= 0) { |
64 |
37 |
101 |
|
| 896 |
64 |
| e = &lsnr->sni_entries[sni_existing]; |
| 897 |
64 |
| feer_tls_ctx_ref_dec(e->ctx_ref); |
| 898 |
|
| } |
| 899 |
|
| else { |
| 900 |
37 |
| e = &lsnr->sni_entries[lsnr->n_sni_entries++]; |
| 901 |
37 |
| Newx(e->hostname, sni_name_len + 1, char); |
| 902 |
37 |
| memcpy(e->hostname, sni_lower, sni_name_len + 1); |
| 903 |
|
| } |
| 904 |
101 |
| e->ctx_ref = feer_tls_ctx_ref_new(new_ctx); |
| 905 |
|
| |
| 906 |
|
| trace("SNI entry '%s' set on listener %d (h2=%d)\n", |
| 907 |
|
| e->hostname, listener_idx, h2); |
| 908 |
|
| } else { |
| 909 |
150 |
▶ | if (lsnr->tls_ctx_ref) |
Branch: 1 branch
| Branch | True | False | Total |
| if (lsnr->tls_ctx_ref) |
1 |
149 |
150 |
|
| 910 |
1 |
| feer_tls_ctx_ref_dec(lsnr->tls_ctx_ref); |
| 911 |
150 |
| lsnr->tls_ctx_ref = feer_tls_ctx_ref_new(new_ctx); |
| 912 |
|
| |
| 913 |
|
| trace("TLS enabled on listener %d (h2=%d)\n", listener_idx, h2); |
| 914 |
|
| } |
| 915 |
|
| #else |
| 916 |
|
| PERL_UNUSED_VAR(server); |
| 917 |
|
| croak("set_tls: Feersum was not compiled with TLS support (need picotls submodule + OpenSSL; see Alien::OpenSSL)"); |
| 918 |
|
| #endif |
| 919 |
|
| } |
| 920 |
|
| |
| 921 |
|
| int |
| 922 |
|
| has_tls (struct feer_server *server) |
| 923 |
|
| CODE: |
| 924 |
|
| { |
| 925 |
|
| PERL_UNUSED_VAR(server); |
| 926 |
|
| #ifdef FEERSUM_HAS_TLS |
| 927 |
186 |
▶ | RETVAL = 1; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = 1; |
0 |
186 |
186 |
|
| 928 |
|
| #else |
| 929 |
|
| RETVAL = 0; |
| 930 |
|
| #endif |
| 931 |
|
| } |
| 932 |
|
| OUTPUT: |
| 933 |
|
| RETVAL |
| 934 |
|
| |
| 935 |
|
| int |
| 936 |
|
| has_h2 (struct feer_server *server) |
| 937 |
|
| CODE: |
| 938 |
|
| { |
| 939 |
|
| PERL_UNUSED_VAR(server); |
| 940 |
|
| #ifdef FEERSUM_HAS_H2 |
| 941 |
|
| RETVAL = 1; |
| 942 |
|
| #else |
| 943 |
109 |
▶ | RETVAL = 0; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = 0; |
0 |
109 |
109 |
|
| 944 |
|
| #endif |
| 945 |
|
| } |
| 946 |
|
| OUTPUT: |
| 947 |
|
| RETVAL |
| 948 |
|
| |
| 949 |
|
| int |
| 950 |
|
| has_outq_probe (struct feer_server *server) |
| 951 |
|
| CODE: |
| 952 |
|
| { |
| 953 |
|
| PERL_UNUSED_VAR(server); |
| 954 |
|
| #ifdef FEERSUM_HAS_OUTQ |
| 955 |
2 |
▶ | RETVAL = 1; |
Branch: 1 branch
| Branch | True | False | Total |
| RETVAL = 1; |
0 |
2 |
2 |
|
| 956 |
|
| #else |
| 957 |
|
| RETVAL = 0; |
| 958 |
|
| #endif |
| 959 |
|
| } |
| 960 |
|
| OUTPUT: |
| 961 |
|
| RETVAL |
| 962 |
|
| |
| 963 |
|
| BOOT: |
| 964 |
|
| { |
| 965 |
375 |
| feer_stash = gv_stashpv("Feersum", 1); |
| 966 |
375 |
| feer_conn_stash = gv_stashpv("Feersum::Connection", 1); |
| 967 |
375 |
| feer_conn_writer_stash = gv_stashpv("Feersum::Connection::Writer",1); |
| 968 |
375 |
| feer_conn_reader_stash = gv_stashpv("Feersum::Connection::Reader",1); |
| 969 |
|
| /* writes to closed sockets must return EPIPE, not kill the process */ |
| 970 |
375 |
| signal(SIGPIPE, SIG_IGN); |
| 971 |
375 |
▶ | I_EV_API("Feersum"); |
Branch: 3 branches
| Branch | True | False | Total |
| I_EV_API("Feersum"); |
0 |
375 |
375 |
| I_EV_API("Feersum"); |
375 |
0 |
375 |
| I_EV_API("Feersum"); |
0 |
375 |
375 |
|
| 972 |
|
| |
| 973 |
375 |
| const char *env_fl_max = getenv("FEERSUM_FREELIST_MAX"); |
| 974 |
375 |
▶ | if (env_fl_max) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (env_fl_max) { |
0 |
375 |
375 |
|
| 975 |
0 |
| int n = atoi(env_fl_max); |
| 976 |
0 |
| FEERSUM_FREELIST_MAX = n < 0 ? 0 : n; /* clamp; 0 disables */ |
| 977 |
|
| } |
| 978 |
|
| |
| 979 |
375 |
| default_server = new_feer_server(aTHX); |
| 980 |
375 |
| SvREFCNT_inc_void_NN(default_server->self); // never freed |
| 981 |
|
| |
| 982 |
375 |
| psgi_ver = newAV(); |
| 983 |
375 |
| av_extend(psgi_ver, 1); |
| 984 |
375 |
| av_push(psgi_ver, newSViv(1)); |
| 985 |
375 |
| av_push(psgi_ver, newSViv(1)); |
| 986 |
375 |
| SvREADONLY_on((SV*)psgi_ver); |
| 987 |
|
| |
| 988 |
375 |
| psgi_serv10 = newSVpvs("HTTP/1.0"); |
| 989 |
375 |
| SvREADONLY_on(psgi_serv10); |
| 990 |
375 |
| psgi_serv11 = newSVpvs("HTTP/1.1"); |
| 991 |
375 |
| SvREADONLY_on(psgi_serv11); |
| 992 |
|
| |
| 993 |
375 |
| method_GET = newSVpvs("GET"); |
| 994 |
375 |
| SvREADONLY_on(method_GET); |
| 995 |
375 |
| method_POST = newSVpvs("POST"); |
| 996 |
375 |
| SvREADONLY_on(method_POST); |
| 997 |
375 |
| method_HEAD = newSVpvs("HEAD"); |
| 998 |
375 |
| SvREADONLY_on(method_HEAD); |
| 999 |
375 |
| method_PUT = newSVpvs("PUT"); |
| 1000 |
375 |
| SvREADONLY_on(method_PUT); |
| 1001 |
375 |
| method_PATCH = newSVpvs("PATCH"); |
| 1002 |
375 |
| SvREADONLY_on(method_PATCH); |
| 1003 |
375 |
| method_DELETE = newSVpvs("DELETE"); |
| 1004 |
375 |
| SvREADONLY_on(method_DELETE); |
| 1005 |
375 |
| method_OPTIONS = newSVpvs("OPTIONS"); |
| 1006 |
375 |
| SvREADONLY_on(method_OPTIONS); |
| 1007 |
|
| |
| 1008 |
375 |
| status_200 = newSVpvs("200 OK"); |
| 1009 |
375 |
| SvREADONLY_on(status_200); |
| 1010 |
375 |
| status_201 = newSVpvs("201 Created"); |
| 1011 |
375 |
| SvREADONLY_on(status_201); |
| 1012 |
375 |
| status_204 = newSVpvs("204 No Content"); |
| 1013 |
375 |
| SvREADONLY_on(status_204); |
| 1014 |
375 |
| status_301 = newSVpvs("301 Moved Permanently"); |
| 1015 |
375 |
| SvREADONLY_on(status_301); |
| 1016 |
375 |
| status_302 = newSVpvs("302 Found"); |
| 1017 |
375 |
| SvREADONLY_on(status_302); |
| 1018 |
375 |
| status_304 = newSVpvs("304 Not Modified"); |
| 1019 |
375 |
| SvREADONLY_on(status_304); |
| 1020 |
375 |
| status_400 = newSVpvs("400 Bad Request"); |
| 1021 |
375 |
| SvREADONLY_on(status_400); |
| 1022 |
375 |
| status_404 = newSVpvs("404 Not Found"); |
| 1023 |
375 |
| SvREADONLY_on(status_404); |
| 1024 |
375 |
| status_500 = newSVpvs("500 Internal Server Error"); |
| 1025 |
375 |
| SvREADONLY_on(status_500); |
| 1026 |
|
| |
| 1027 |
375 |
| empty_query_sv = newSVpvs(""); |
| 1028 |
375 |
| SvREADONLY_on(empty_query_sv); |
| 1029 |
|
| |
| 1030 |
375 |
| Zero(&psgix_io_vtbl, 1, MGVTBL); |
| 1031 |
375 |
| psgix_io_vtbl.svt_get = psgix_io_svt_get; |
| 1032 |
375 |
| newCONSTSUB(feer_stash, "HEADER_NORM_SKIP", newSViv(HEADER_NORM_SKIP)); |
| 1033 |
375 |
| newCONSTSUB(feer_stash, "HEADER_NORM_UPCASE", newSViv(HEADER_NORM_UPCASE)); |
| 1034 |
375 |
| newCONSTSUB(feer_stash, "HEADER_NORM_LOCASE", newSViv(HEADER_NORM_LOCASE)); |
| 1035 |
375 |
| newCONSTSUB(feer_stash, "HEADER_NORM_UPCASE_DASH", newSViv(HEADER_NORM_UPCASE_DASH)); |
| 1036 |
375 |
| newCONSTSUB(feer_stash, "HEADER_NORM_LOCASE_DASH", newSViv(HEADER_NORM_LOCASE_DASH)); |
| 1037 |
|
| |
| 1038 |
|
| trace3("Feersum booted, iomatrix %lu, FEERSUM_IOMATRIX_SIZE=%u, " |
| 1039 |
|
| "feer_req %lu, feer_conn %lu\n", |
| 1040 |
|
| (long unsigned int)sizeof(struct iomatrix), |
| 1041 |
|
| (unsigned int)FEERSUM_IOMATRIX_SIZE, |
| 1042 |
|
| (long unsigned int)sizeof(struct feer_req), |
| 1043 |
|
| (long unsigned int)sizeof(struct feer_conn) |
| 1044 |
|
| ); |
| 1045 |
|
| } |
| 1046 |
|
| |
| 1047 |
|
| INCLUDE: feersum_conn.xs |