Mercurial > hg > nginx
annotate src/event/quic/ngx_event_quic_bpf.c @ 9250:55a5a40dccde
Reordered checks for Content-Length and Transfer-Encoding.
This ensures that r->headers_in.content_length_n is not set when both
Content-Length and Transfer-Encoding headers are present, making it slightly
safer to use complex processing for 400 (Bad Request) errors.
author | Maxim Dounin <mdounin@mdounin.ru> |
---|---|
date | Sat, 27 Apr 2024 18:16:27 +0300 |
parents | 7c0f9bb27763 |
children |
rev | line source |
---|---|
8676 | 1 |
2 /* | |
3 * Copyright (C) Nginx, Inc. | |
4 */ | |
5 | |
6 | |
7 #include <ngx_config.h> | |
8 #include <ngx_core.h> | |
9 | |
10 | |
11 #define NGX_QUIC_BPF_VARNAME "NGINX_BPF_MAPS" | |
12 #define NGX_QUIC_BPF_VARSEP ';' | |
13 #define NGX_QUIC_BPF_ADDRSEP '#' | |
14 | |
15 | |
16 #define ngx_quic_bpf_get_conf(cycle) \ | |
17 (ngx_quic_bpf_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_quic_bpf_module) | |
18 | |
19 #define ngx_quic_bpf_get_old_conf(cycle) \ | |
20 cycle->old_cycle->conf_ctx ? ngx_quic_bpf_get_conf(cycle->old_cycle) \ | |
21 : NULL | |
22 | |
23 #define ngx_core_get_conf(cycle) \ | |
24 (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module) | |
25 | |
26 | |
27 typedef struct { | |
28 ngx_queue_t queue; | |
29 int map_fd; | |
30 | |
31 struct sockaddr *sockaddr; | |
32 socklen_t socklen; | |
33 ngx_uint_t unused; /* unsigned unused:1; */ | |
34 } ngx_quic_sock_group_t; | |
35 | |
36 | |
37 typedef struct { | |
38 ngx_flag_t enabled; | |
39 ngx_uint_t map_size; | |
40 ngx_queue_t groups; /* of ngx_quic_sock_group_t */ | |
41 } ngx_quic_bpf_conf_t; | |
42 | |
43 | |
44 static void *ngx_quic_bpf_create_conf(ngx_cycle_t *cycle); | |
45 static ngx_int_t ngx_quic_bpf_module_init(ngx_cycle_t *cycle); | |
46 | |
47 static void ngx_quic_bpf_cleanup(void *data); | |
48 static ngx_inline void ngx_quic_bpf_close(ngx_log_t *log, int fd, | |
49 const char *name); | |
50 | |
51 static ngx_quic_sock_group_t *ngx_quic_bpf_find_group(ngx_quic_bpf_conf_t *bcf, | |
52 ngx_listening_t *ls); | |
53 static ngx_quic_sock_group_t *ngx_quic_bpf_alloc_group(ngx_cycle_t *cycle, | |
54 struct sockaddr *sa, socklen_t socklen); | |
55 static ngx_quic_sock_group_t *ngx_quic_bpf_create_group(ngx_cycle_t *cycle, | |
56 ngx_listening_t *ls); | |
57 static ngx_quic_sock_group_t *ngx_quic_bpf_get_group(ngx_cycle_t *cycle, | |
58 ngx_listening_t *ls); | |
59 static ngx_int_t ngx_quic_bpf_group_add_socket(ngx_cycle_t *cycle, | |
60 ngx_listening_t *ls); | |
61 static uint64_t ngx_quic_bpf_socket_key(ngx_fd_t fd, ngx_log_t *log); | |
62 | |
63 static ngx_int_t ngx_quic_bpf_export_maps(ngx_cycle_t *cycle); | |
64 static ngx_int_t ngx_quic_bpf_import_maps(ngx_cycle_t *cycle); | |
65 | |
66 extern ngx_bpf_program_t ngx_quic_reuseport_helper; | |
67 | |
68 | |
69 static ngx_command_t ngx_quic_bpf_commands[] = { | |
70 | |
71 { ngx_string("quic_bpf"), | |
72 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG, | |
73 ngx_conf_set_flag_slot, | |
74 0, | |
75 offsetof(ngx_quic_bpf_conf_t, enabled), | |
76 NULL }, | |
77 | |
78 ngx_null_command | |
79 }; | |
80 | |
81 | |
82 static ngx_core_module_t ngx_quic_bpf_module_ctx = { | |
83 ngx_string("quic_bpf"), | |
84 ngx_quic_bpf_create_conf, | |
85 NULL | |
86 }; | |
87 | |
88 | |
89 ngx_module_t ngx_quic_bpf_module = { | |
90 NGX_MODULE_V1, | |
91 &ngx_quic_bpf_module_ctx, /* module context */ | |
92 ngx_quic_bpf_commands, /* module directives */ | |
93 NGX_CORE_MODULE, /* module type */ | |
94 NULL, /* init master */ | |
95 ngx_quic_bpf_module_init, /* init module */ | |
96 NULL, /* init process */ | |
97 NULL, /* init thread */ | |
98 NULL, /* exit thread */ | |
99 NULL, /* exit process */ | |
100 NULL, /* exit master */ | |
101 NGX_MODULE_V1_PADDING | |
102 }; | |
103 | |
104 | |
105 static void * | |
106 ngx_quic_bpf_create_conf(ngx_cycle_t *cycle) | |
107 { | |
108 ngx_quic_bpf_conf_t *bcf; | |
109 | |
110 bcf = ngx_pcalloc(cycle->pool, sizeof(ngx_quic_bpf_conf_t)); | |
111 if (bcf == NULL) { | |
112 return NULL; | |
113 } | |
114 | |
115 bcf->enabled = NGX_CONF_UNSET; | |
116 bcf->map_size = NGX_CONF_UNSET_UINT; | |
117 | |
118 ngx_queue_init(&bcf->groups); | |
119 | |
120 return bcf; | |
121 } | |
122 | |
123 | |
124 static ngx_int_t | |
125 ngx_quic_bpf_module_init(ngx_cycle_t *cycle) | |
126 { | |
127 ngx_uint_t i; | |
128 ngx_listening_t *ls; | |
129 ngx_core_conf_t *ccf; | |
130 ngx_pool_cleanup_t *cln; | |
131 ngx_quic_bpf_conf_t *bcf; | |
132 | |
8951
7c0f9bb27763
QUIC: fixed config test with bpf (ticket #2292).
Vladimir Homutov <vl@nginx.com>
parents:
8833
diff
changeset
|
133 if (ngx_test_config) { |
7c0f9bb27763
QUIC: fixed config test with bpf (ticket #2292).
Vladimir Homutov <vl@nginx.com>
parents:
8833
diff
changeset
|
134 /* |
7c0f9bb27763
QUIC: fixed config test with bpf (ticket #2292).
Vladimir Homutov <vl@nginx.com>
parents:
8833
diff
changeset
|
135 * during config test, SO_REUSEPORT socket option is |
7c0f9bb27763
QUIC: fixed config test with bpf (ticket #2292).
Vladimir Homutov <vl@nginx.com>
parents:
8833
diff
changeset
|
136 * not set, thus making further processing meaningless |
7c0f9bb27763
QUIC: fixed config test with bpf (ticket #2292).
Vladimir Homutov <vl@nginx.com>
parents:
8833
diff
changeset
|
137 */ |
7c0f9bb27763
QUIC: fixed config test with bpf (ticket #2292).
Vladimir Homutov <vl@nginx.com>
parents:
8833
diff
changeset
|
138 return NGX_OK; |
7c0f9bb27763
QUIC: fixed config test with bpf (ticket #2292).
Vladimir Homutov <vl@nginx.com>
parents:
8833
diff
changeset
|
139 } |
7c0f9bb27763
QUIC: fixed config test with bpf (ticket #2292).
Vladimir Homutov <vl@nginx.com>
parents:
8833
diff
changeset
|
140 |
8676 | 141 ccf = ngx_core_get_conf(cycle); |
142 bcf = ngx_quic_bpf_get_conf(cycle); | |
143 | |
144 ngx_conf_init_value(bcf->enabled, 0); | |
145 | |
146 bcf->map_size = ccf->worker_processes * 4; | |
147 | |
148 cln = ngx_pool_cleanup_add(cycle->pool, 0); | |
149 if (cln == NULL) { | |
150 goto failed; | |
151 } | |
152 | |
153 cln->data = bcf; | |
154 cln->handler = ngx_quic_bpf_cleanup; | |
155 | |
156 if (ngx_inherited && ngx_is_init_cycle(cycle->old_cycle)) { | |
157 if (ngx_quic_bpf_import_maps(cycle) != NGX_OK) { | |
158 goto failed; | |
159 } | |
160 } | |
161 | |
162 ls = cycle->listening.elts; | |
163 | |
164 for (i = 0; i < cycle->listening.nelts; i++) { | |
165 if (ls[i].quic && ls[i].reuseport) { | |
166 if (ngx_quic_bpf_group_add_socket(cycle, &ls[i]) != NGX_OK) { | |
167 goto failed; | |
168 } | |
169 } | |
170 } | |
171 | |
172 if (ngx_quic_bpf_export_maps(cycle) != NGX_OK) { | |
173 goto failed; | |
174 } | |
175 | |
176 return NGX_OK; | |
177 | |
178 failed: | |
179 | |
180 if (ngx_is_init_cycle(cycle->old_cycle)) { | |
181 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, | |
182 "ngx_quic_bpf_module failed to initialize, check limits"); | |
183 | |
184 /* refuse to start */ | |
185 return NGX_ERROR; | |
186 } | |
187 | |
188 /* | |
189 * returning error now will lead to master process exiting immediately | |
190 * leaving worker processes orphaned, what is really unexpected. | |
191 * Instead, just issue a not about failed initialization and try | |
192 * to cleanup a bit. Still program can be already loaded to kernel | |
193 * for some reuseport groups, and there is no way to revert, so | |
194 * behaviour may be inconsistent. | |
195 */ | |
196 | |
197 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, | |
198 "ngx_quic_bpf_module failed to initialize properly, ignored." | |
199 "please check limits and note that nginx state now " | |
200 "can be inconsistent and restart may be required"); | |
201 | |
202 return NGX_OK; | |
203 } | |
204 | |
205 | |
206 static void | |
207 ngx_quic_bpf_cleanup(void *data) | |
208 { | |
209 ngx_quic_bpf_conf_t *bcf = (ngx_quic_bpf_conf_t *) data; | |
210 | |
211 ngx_queue_t *q; | |
212 ngx_quic_sock_group_t *grp; | |
213 | |
214 for (q = ngx_queue_head(&bcf->groups); | |
215 q != ngx_queue_sentinel(&bcf->groups); | |
216 q = ngx_queue_next(q)) | |
217 { | |
218 grp = ngx_queue_data(q, ngx_quic_sock_group_t, queue); | |
219 | |
220 ngx_quic_bpf_close(ngx_cycle->log, grp->map_fd, "map"); | |
221 } | |
222 } | |
223 | |
224 | |
225 static ngx_inline void | |
226 ngx_quic_bpf_close(ngx_log_t *log, int fd, const char *name) | |
227 { | |
228 if (close(fd) != -1) { | |
229 return; | |
230 } | |
231 | |
232 ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, | |
8833
e5a180511dec
QUIC: fixed format specifiers in ngx_quic_bpf module.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8702
diff
changeset
|
233 "quic bpf close %s fd:%d failed", name, fd); |
8676 | 234 } |
235 | |
236 | |
237 static ngx_quic_sock_group_t * | |
238 ngx_quic_bpf_find_group(ngx_quic_bpf_conf_t *bcf, ngx_listening_t *ls) | |
239 { | |
240 ngx_queue_t *q; | |
241 ngx_quic_sock_group_t *grp; | |
242 | |
243 for (q = ngx_queue_head(&bcf->groups); | |
244 q != ngx_queue_sentinel(&bcf->groups); | |
245 q = ngx_queue_next(q)) | |
246 { | |
247 grp = ngx_queue_data(q, ngx_quic_sock_group_t, queue); | |
248 | |
249 if (ngx_cmp_sockaddr(ls->sockaddr, ls->socklen, | |
250 grp->sockaddr, grp->socklen, 1) | |
251 == NGX_OK) | |
252 { | |
253 return grp; | |
254 } | |
255 } | |
256 | |
257 return NULL; | |
258 } | |
259 | |
260 | |
261 static ngx_quic_sock_group_t * | |
262 ngx_quic_bpf_alloc_group(ngx_cycle_t *cycle, struct sockaddr *sa, | |
263 socklen_t socklen) | |
264 { | |
265 ngx_quic_bpf_conf_t *bcf; | |
266 ngx_quic_sock_group_t *grp; | |
267 | |
268 bcf = ngx_quic_bpf_get_conf(cycle); | |
269 | |
270 grp = ngx_pcalloc(cycle->pool, sizeof(ngx_quic_sock_group_t)); | |
271 if (grp == NULL) { | |
272 return NULL; | |
273 } | |
274 | |
275 grp->socklen = socklen; | |
276 grp->sockaddr = ngx_palloc(cycle->pool, socklen); | |
277 if (grp->sockaddr == NULL) { | |
278 return NULL; | |
279 } | |
280 ngx_memcpy(grp->sockaddr, sa, socklen); | |
281 | |
282 ngx_queue_insert_tail(&bcf->groups, &grp->queue); | |
283 | |
284 return grp; | |
285 } | |
286 | |
287 | |
288 static ngx_quic_sock_group_t * | |
289 ngx_quic_bpf_create_group(ngx_cycle_t *cycle, ngx_listening_t *ls) | |
290 { | |
291 int progfd, failed, flags, rc; | |
292 ngx_quic_bpf_conf_t *bcf; | |
293 ngx_quic_sock_group_t *grp; | |
294 | |
295 bcf = ngx_quic_bpf_get_conf(cycle); | |
296 | |
297 if (!bcf->enabled) { | |
298 return NULL; | |
299 } | |
300 | |
301 grp = ngx_quic_bpf_alloc_group(cycle, ls->sockaddr, ls->socklen); | |
302 if (grp == NULL) { | |
303 return NULL; | |
304 } | |
305 | |
306 grp->map_fd = ngx_bpf_map_create(cycle->log, BPF_MAP_TYPE_SOCKHASH, | |
307 sizeof(uint64_t), sizeof(uint64_t), | |
308 bcf->map_size, 0); | |
309 if (grp->map_fd == -1) { | |
310 goto failed; | |
311 } | |
312 | |
313 flags = fcntl(grp->map_fd, F_GETFD); | |
314 if (flags == -1) { | |
315 ngx_log_error(NGX_LOG_EMERG, cycle->log, errno, | |
316 "quic bpf getfd failed"); | |
317 goto failed; | |
318 } | |
319 | |
320 /* need to inherit map during binary upgrade after exec */ | |
321 flags &= ~FD_CLOEXEC; | |
322 | |
323 rc = fcntl(grp->map_fd, F_SETFD, flags); | |
324 if (rc == -1) { | |
325 ngx_log_error(NGX_LOG_EMERG, cycle->log, errno, | |
326 "quic bpf setfd failed"); | |
327 goto failed; | |
328 } | |
329 | |
330 ngx_bpf_program_link(&ngx_quic_reuseport_helper, | |
331 "ngx_quic_sockmap", grp->map_fd); | |
332 | |
333 progfd = ngx_bpf_load_program(cycle->log, &ngx_quic_reuseport_helper); | |
334 if (progfd < 0) { | |
335 goto failed; | |
336 } | |
337 | |
338 failed = 0; | |
339 | |
340 if (setsockopt(ls->fd, SOL_SOCKET, SO_ATTACH_REUSEPORT_EBPF, | |
341 &progfd, sizeof(int)) | |
342 == -1) | |
343 { | |
344 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno, | |
345 "quic bpf setsockopt(SO_ATTACH_REUSEPORT_EBPF) failed"); | |
346 failed = 1; | |
347 } | |
348 | |
349 ngx_quic_bpf_close(cycle->log, progfd, "program"); | |
350 | |
351 if (failed) { | |
352 goto failed; | |
353 } | |
354 | |
355 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, | |
8833
e5a180511dec
QUIC: fixed format specifiers in ngx_quic_bpf module.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8702
diff
changeset
|
356 "quic bpf sockmap created fd:%d", grp->map_fd); |
8676 | 357 return grp; |
358 | |
359 failed: | |
360 | |
361 if (grp->map_fd != -1) { | |
362 ngx_quic_bpf_close(cycle->log, grp->map_fd, "map"); | |
363 } | |
364 | |
365 ngx_queue_remove(&grp->queue); | |
366 | |
367 return NULL; | |
368 } | |
369 | |
370 | |
371 static ngx_quic_sock_group_t * | |
372 ngx_quic_bpf_get_group(ngx_cycle_t *cycle, ngx_listening_t *ls) | |
373 { | |
374 ngx_quic_bpf_conf_t *bcf, *old_bcf; | |
375 ngx_quic_sock_group_t *grp, *ogrp; | |
376 | |
377 bcf = ngx_quic_bpf_get_conf(cycle); | |
378 | |
379 grp = ngx_quic_bpf_find_group(bcf, ls); | |
380 if (grp) { | |
381 return grp; | |
382 } | |
383 | |
384 old_bcf = ngx_quic_bpf_get_old_conf(cycle); | |
385 | |
386 if (old_bcf == NULL) { | |
387 return ngx_quic_bpf_create_group(cycle, ls); | |
388 } | |
389 | |
390 ogrp = ngx_quic_bpf_find_group(old_bcf, ls); | |
391 if (ogrp == NULL) { | |
392 return ngx_quic_bpf_create_group(cycle, ls); | |
393 } | |
394 | |
395 grp = ngx_quic_bpf_alloc_group(cycle, ls->sockaddr, ls->socklen); | |
396 if (grp == NULL) { | |
397 return NULL; | |
398 } | |
399 | |
400 grp->map_fd = dup(ogrp->map_fd); | |
401 if (grp->map_fd == -1) { | |
402 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno, | |
403 "quic bpf failed to duplicate bpf map descriptor"); | |
404 | |
405 ngx_queue_remove(&grp->queue); | |
406 | |
407 return NULL; | |
408 } | |
409 | |
410 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0, | |
8833
e5a180511dec
QUIC: fixed format specifiers in ngx_quic_bpf module.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8702
diff
changeset
|
411 "quic bpf sockmap fd duplicated old:%d new:%d", |
8702
d4e02b3b734f
QUIC: fixed indentation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8676
diff
changeset
|
412 ogrp->map_fd, grp->map_fd); |
8676 | 413 |
414 return grp; | |
415 } | |
416 | |
417 | |
418 static ngx_int_t | |
419 ngx_quic_bpf_group_add_socket(ngx_cycle_t *cycle, ngx_listening_t *ls) | |
420 { | |
421 uint64_t cookie; | |
422 ngx_quic_bpf_conf_t *bcf; | |
423 ngx_quic_sock_group_t *grp; | |
424 | |
425 bcf = ngx_quic_bpf_get_conf(cycle); | |
426 | |
427 grp = ngx_quic_bpf_get_group(cycle, ls); | |
428 | |
429 if (grp == NULL) { | |
430 if (!bcf->enabled) { | |
431 return NGX_OK; | |
432 } | |
433 | |
434 return NGX_ERROR; | |
435 } | |
436 | |
437 grp->unused = 0; | |
438 | |
439 cookie = ngx_quic_bpf_socket_key(ls->fd, cycle->log); | |
440 if (cookie == (uint64_t) NGX_ERROR) { | |
441 return NGX_ERROR; | |
442 } | |
443 | |
444 /* map[cookie] = socket; for use in kernel helper */ | |
445 if (ngx_bpf_map_update(grp->map_fd, &cookie, &ls->fd, BPF_ANY) == -1) { | |
446 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno, | |
447 "quic bpf failed to update socket map key=%xL", cookie); | |
448 return NGX_ERROR; | |
449 } | |
450 | |
451 ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0, | |
8833
e5a180511dec
QUIC: fixed format specifiers in ngx_quic_bpf module.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8702
diff
changeset
|
452 "quic bpf sockmap fd:%d add socket:%d cookie:0x%xL worker:%ui", |
e5a180511dec
QUIC: fixed format specifiers in ngx_quic_bpf module.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8702
diff
changeset
|
453 grp->map_fd, ls->fd, cookie, ls->worker); |
8676 | 454 |
455 /* do not inherit this socket */ | |
456 ls->ignore = 1; | |
457 | |
458 return NGX_OK; | |
459 } | |
460 | |
461 | |
462 static uint64_t | |
463 ngx_quic_bpf_socket_key(ngx_fd_t fd, ngx_log_t *log) | |
464 { | |
465 uint64_t cookie; | |
466 socklen_t optlen; | |
467 | |
468 optlen = sizeof(cookie); | |
469 | |
470 if (getsockopt(fd, SOL_SOCKET, SO_COOKIE, &cookie, &optlen) == -1) { | |
471 ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno, | |
472 "quic bpf getsockopt(SO_COOKIE) failed"); | |
473 | |
474 return (ngx_uint_t) NGX_ERROR; | |
475 } | |
476 | |
477 return cookie; | |
478 } | |
479 | |
480 | |
481 static ngx_int_t | |
482 ngx_quic_bpf_export_maps(ngx_cycle_t *cycle) | |
483 { | |
484 u_char *p, *buf; | |
485 size_t len; | |
486 ngx_str_t *var; | |
487 ngx_queue_t *q; | |
488 ngx_core_conf_t *ccf; | |
489 ngx_quic_bpf_conf_t *bcf; | |
490 ngx_quic_sock_group_t *grp; | |
491 | |
492 ccf = ngx_core_get_conf(cycle); | |
493 bcf = ngx_quic_bpf_get_conf(cycle); | |
494 | |
495 len = sizeof(NGX_QUIC_BPF_VARNAME) + 1; | |
496 | |
497 q = ngx_queue_head(&bcf->groups); | |
498 | |
499 while (q != ngx_queue_sentinel(&bcf->groups)) { | |
500 | |
501 grp = ngx_queue_data(q, ngx_quic_sock_group_t, queue); | |
502 | |
503 q = ngx_queue_next(q); | |
504 | |
505 if (grp->unused) { | |
506 /* | |
507 * map was inherited, but it is not used in this configuration; | |
508 * do not pass such map further and drop the group to prevent | |
509 * interference with changes during reload | |
510 */ | |
511 | |
512 ngx_quic_bpf_close(cycle->log, grp->map_fd, "map"); | |
513 ngx_queue_remove(&grp->queue); | |
514 | |
515 continue; | |
516 } | |
517 | |
518 len += NGX_INT32_LEN + 1 + NGX_SOCKADDR_STRLEN + 1; | |
519 } | |
520 | |
521 len++; | |
522 | |
523 buf = ngx_palloc(cycle->pool, len); | |
524 if (buf == NULL) { | |
525 return NGX_ERROR; | |
526 } | |
527 | |
528 p = ngx_cpymem(buf, NGX_QUIC_BPF_VARNAME "=", | |
529 sizeof(NGX_QUIC_BPF_VARNAME)); | |
530 | |
531 for (q = ngx_queue_head(&bcf->groups); | |
532 q != ngx_queue_sentinel(&bcf->groups); | |
533 q = ngx_queue_next(q)) | |
534 { | |
535 grp = ngx_queue_data(q, ngx_quic_sock_group_t, queue); | |
536 | |
537 p = ngx_sprintf(p, "%ud", grp->map_fd); | |
538 | |
539 *p++ = NGX_QUIC_BPF_ADDRSEP; | |
540 | |
541 p += ngx_sock_ntop(grp->sockaddr, grp->socklen, p, | |
542 NGX_SOCKADDR_STRLEN, 1); | |
543 | |
544 *p++ = NGX_QUIC_BPF_VARSEP; | |
545 } | |
546 | |
547 *p = '\0'; | |
548 | |
549 var = ngx_array_push(&ccf->env); | |
550 if (var == NULL) { | |
551 return NGX_ERROR; | |
552 } | |
553 | |
554 var->data = buf; | |
555 var->len = sizeof(NGX_QUIC_BPF_VARNAME) - 1; | |
556 | |
557 return NGX_OK; | |
558 } | |
559 | |
560 | |
561 static ngx_int_t | |
562 ngx_quic_bpf_import_maps(ngx_cycle_t *cycle) | |
563 { | |
564 int s; | |
565 u_char *inherited, *p, *v; | |
566 ngx_uint_t in_fd; | |
567 ngx_addr_t tmp; | |
568 ngx_quic_bpf_conf_t *bcf; | |
569 ngx_quic_sock_group_t *grp; | |
570 | |
571 inherited = (u_char *) getenv(NGX_QUIC_BPF_VARNAME); | |
572 | |
573 if (inherited == NULL) { | |
574 return NGX_OK; | |
575 } | |
576 | |
577 bcf = ngx_quic_bpf_get_conf(cycle); | |
578 | |
579 #if (NGX_SUPPRESS_WARN) | |
580 s = -1; | |
581 #endif | |
582 | |
583 in_fd = 1; | |
584 | |
585 for (p = inherited, v = p; *p; p++) { | |
586 | |
587 switch (*p) { | |
588 | |
589 case NGX_QUIC_BPF_ADDRSEP: | |
590 | |
591 if (!in_fd) { | |
592 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, | |
593 "quic bpf failed to parse inherited env"); | |
594 return NGX_ERROR; | |
595 } | |
596 in_fd = 0; | |
597 | |
598 s = ngx_atoi(v, p - v); | |
599 if (s == NGX_ERROR) { | |
600 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, | |
601 "quic bpf failed to parse inherited map fd"); | |
602 return NGX_ERROR; | |
603 } | |
604 | |
605 v = p + 1; | |
606 break; | |
607 | |
608 case NGX_QUIC_BPF_VARSEP: | |
609 | |
610 if (in_fd) { | |
611 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, | |
612 "quic bpf failed to parse inherited env"); | |
613 return NGX_ERROR; | |
614 } | |
615 in_fd = 1; | |
616 | |
617 grp = ngx_pcalloc(cycle->pool, | |
618 sizeof(ngx_quic_sock_group_t)); | |
619 if (grp == NULL) { | |
620 return NGX_ERROR; | |
621 } | |
622 | |
623 grp->map_fd = s; | |
624 | |
625 if (ngx_parse_addr_port(cycle->pool, &tmp, v, p - v) | |
626 != NGX_OK) | |
627 { | |
628 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, | |
629 "quic bpf failed to parse inherited" | |
630 " address '%*s'", p - v , v); | |
631 | |
632 ngx_quic_bpf_close(cycle->log, s, "inherited map"); | |
633 | |
634 return NGX_ERROR; | |
635 } | |
636 | |
637 grp->sockaddr = tmp.sockaddr; | |
638 grp->socklen = tmp.socklen; | |
639 | |
640 grp->unused = 1; | |
641 | |
642 ngx_queue_insert_tail(&bcf->groups, &grp->queue); | |
643 | |
644 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0, | |
645 "quic bpf sockmap inherited with " | |
8833
e5a180511dec
QUIC: fixed format specifiers in ngx_quic_bpf module.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8702
diff
changeset
|
646 "fd:%d address:%*s", |
8676 | 647 grp->map_fd, p - v, v); |
648 v = p + 1; | |
649 break; | |
650 | |
651 default: | |
652 break; | |
653 } | |
654 } | |
655 | |
656 return NGX_OK; | |
657 } |