Bug Summary

File:lib/lwan.c
Warning:line 338, column 17
Potential memory leak

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name lwan.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -fno-plt -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/buildbot/lwan-worker/clang-analyze/build/src/lib -resource-dir /usr/lib/clang/14.0.6 -include /home/buildbot/lwan-worker/clang-analyze/build/lwan-build-config.h -D _FILE_OFFSET_BITS=64 -D _TIME_BITS=64 -I /home/buildbot/lwan-worker/clang-analyze/build/src/lib/missing -I /usr/include/python3.10 -I /usr/include/luajit-2.1 -I /usr/include/valgrind -I /home/buildbot/lwan-worker/clang-analyze/build/src/lib -I /home/buildbot/lwan-worker/clang-analyze/build -internal-isystem /usr/lib/clang/14.0.6/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../x86_64-pc-linux-gnu/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-unused-parameter -Wno-free-nonheap-object -std=gnu99 -fdebug-compilation-dir=/home/buildbot/lwan-worker/clang-analyze/build/src/lib -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/buildbot/lwan-worker/clang-analyze/CLANG/2022-09-17-204021-1796446-1 -x c /home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c
1/*
2 * lwan - simple web server
3 * Copyright (c) 2012, 2013 L. A. F. Pereira <l@tia.mat.br>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
18 * USA.
19 */
20
21#define _GNU_SOURCE
22#include <assert.h>
23#include <ctype.h>
24#include <dlfcn.h>
25#include <errno(*__errno_location ()).h>
26#include <fcntl.h>
27#include <libproc.h>
28#include <limits.h>
29#include <signal.h>
30#include <stdlib.h>
31#include <string.h>
32#include <sys/resource.h>
33#include <sys/socket.h>
34#include <sys/types.h>
35#include <unistd.h>
36
37#include "lwan-private.h"
38
39#include "lwan-config.h"
40#include "lwan-http-authorize.h"
41
42#if defined(LWAN_HAVE_LUA)
43#include "lwan-lua.h"
44#endif
45
46/* Ideally, this would check if all items in enum lwan_request_flags,
47 * when bitwise-or'd together, would not have have any bit set that
48 * is also set in REQUEST_METHOD_MASK. */
49static_assert_Static_assert(REQUEST_ACCEPT_DEFLATE > REQUEST_METHOD_MASK,
50 "enough bits to store request methods");
51
52/* See detect_fastest_monotonic_clock() */
53clockid_t monotonic_clock_id = CLOCK_MONOTONIC1;
54
55static const struct lwan_config default_config = {
56 .listener = "localhost:8080",
57 .keep_alive_timeout = 15,
58 .quiet = false0,
59 .proxy_protocol = false0,
60 .allow_cors = false0,
61 .expires = 1 * ONE_WEEK(((60 * 60) * 24) * 7),
62 .n_threads = 0,
63 .max_post_data_size = 10 * DEFAULT_BUFFER_SIZE4096,
64 .allow_post_temp_file = false0,
65 .max_put_data_size = 10 * DEFAULT_BUFFER_SIZE4096,
66 .allow_put_temp_file = false0,
67};
68
69LWAN_HANDLER_ROUTE(brew_coffee, "/brew-coffee")static enum lwan_http_status lwan_handler_brew_coffee( struct
lwan_request *, struct lwan_response *, void *); static const
struct lwan_handler_info __attribute__((used, section("lwan_handler"
))) lwan_handler_info_brew_coffee = {.name = "brew_coffee", .
handler = lwan_handler_brew_coffee}; static const struct lwan_url_map_route_info
__attribute__((used, section("lwan_url_map"))) lwan_url_map_route_info_brew_coffee
= {.route = "/brew-coffee", .handler = lwan_handler_brew_coffee
}; __attribute__((used)) static enum lwan_http_status lwan_handler_brew_coffee
( struct lwan_request *request __attribute__((unused)), struct
lwan_response *response __attribute__((unused)), void *data __attribute__
((unused)))
70{
71 /* Placeholder handler so that __start_lwan_handler and __stop_lwan_handler
72 * symbols will get defined.
73 */
74 return HTTP_I_AM_A_TEAPOT;
75}
76
77__attribute__((no_sanitize_address))
78static void *find_handler(const char *name)
79{
80 const struct lwan_handler_info *handler;
81
82 LWAN_SECTION_FOREACH(lwan_handler, handler)for (handler = ({ extern const typeof(*handler) __start_lwan_handler
[]; __start_lwan_handler; }); handler < ({ extern const typeof
(*handler) __stop_lwan_handler[]; __stop_lwan_handler; }); (handler
)++)
{
83 if (streq(handler->name, name))
84 return handler->handler;
85 }
86
87 return NULL((void*)0);
88}
89
90__attribute__((no_sanitize_address))
91static const struct lwan_module *find_module(const char *name)
92{
93 const struct lwan_module_info *module;
94
95 LWAN_SECTION_FOREACH(lwan_module, module)for (module = ({ extern const typeof(*module) __start_lwan_module
[]; __start_lwan_module; }); module < ({ extern const typeof
(*module) __stop_lwan_module[]; __stop_lwan_module; }); (module
)++)
{
96 if (streq(module->name, name))
97 return module->module;
98 }
99
100 return NULL((void*)0);
101}
102
103static void destroy_urlmap(void *data)
104{
105 struct lwan_url_map *url_map = data;
106
107 if (url_map->module) {
108 const struct lwan_module *module = url_map->module;
109
110 if (module->destroy)
111 module->destroy(url_map->data);
112 } else if (url_map->data && url_map->flags & HANDLER_DATA_IS_HASH_TABLE) {
113 hash_free(url_map->data);
114 }
115
116 free(url_map->authorization.realm);
117 free(url_map->authorization.password_file);
118 free((char *)url_map->prefix);
119 free(url_map);
120}
121
122static struct lwan_url_map *add_url_map(struct lwan_trie *t, const char *prefix,
123 const struct lwan_url_map *map)
124{
125 struct lwan_url_map *copy = malloc(sizeof(*copy));
126
127 if (!copy)
128 lwan_status_critical_perror("Could not copy URL map")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 128, __FUNCTION__, "Could not copy URL map")
;
129
130 memcpy(copy, map, sizeof(*copy));
131
132 copy->prefix = strdup(prefix ? prefix : copy->prefix);
133 if (!copy->prefix)
134 lwan_status_critical_perror("Could not copy URL prefix")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 134, __FUNCTION__, "Could not copy URL prefix")
;
135
136 copy->prefix_len = strlen(copy->prefix);
137 lwan_trie_add(t, copy->prefix, copy);
138
139 return copy;
140}
141
142static bool_Bool can_override_header(const char *name)
143{
144 /* NOTE: Update lwan_prepare_response_header_full() in lwan-response.c
145 * if new headers are added here. */
146
147 if (strcaseequal_neutral(name, "Date"))
148 return false0;
149 if (strcaseequal_neutral(name, "Expires"))
150 return false0;
151 if (strcaseequal_neutral(name, "WWW-Authenticate"))
152 return false0;
153 if (strcaseequal_neutral(name, "Connection"))
154 return false0;
155 if (strcaseequal_neutral(name, "Content-Type"))
156 return false0;
157 if (strcaseequal_neutral(name, "Transfer-Encoding"))
158 return false0;
159 if (!strncasecmp(name, "Access-Control-Allow-",
160 sizeof("Access-Control-Allow-") - 1))
161 return false0;
162
163 return true1;
164}
165
166static void build_response_headers(struct lwan *l,
167 const struct lwan_key_value *kv)
168{
169 struct lwan_strbuf strbuf;
170 bool_Bool set_server = false0;
171
172 assert(l)((void) sizeof ((l) ? 1 : 0), __extension__ ({ if (l) ; else __assert_fail
("l", "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 172, __extension__ __PRETTY_FUNCTION__); }))
;
173
174 lwan_strbuf_init(&strbuf);
175
176 for (; kv && kv->key; kv++) {
177 if (!can_override_header(kv->key)) {
178 lwan_status_warning("Cannot override header '%s'", kv->key)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 178, __FUNCTION__, "Cannot override header '%s'", kv->key
)
;
179 } else {
180 if (strcaseequal_neutral(kv->key, "Server"))
181 set_server = true1;
182
183 lwan_strbuf_append_printf(&strbuf, "\r\n%s: %s", kv->key,
184 kv->value);
185 }
186 }
187
188 if (!set_server)
189 lwan_strbuf_append_strz(&strbuf, "\r\nServer: lwan");
190
191 lwan_strbuf_append_strz(&strbuf, "\r\n\r\n");
192
193 l->headers = (struct lwan_value){.value = lwan_strbuf_get_buffer(&strbuf),
194 .len = lwan_strbuf_get_length(&strbuf)};
195}
196
197static void parse_global_headers(struct config *c,
198 struct lwan *lwan)
199{
200 struct lwan_key_value_array hdrs;
201 const struct config_line *l;
202 struct lwan_key_value *kv;
203
204 lwan_key_value_array_init(&hdrs);
205
206 while ((l = config_read_line(c))) {
207 switch (l->type) {
208 case CONFIG_LINE_TYPE_SECTION:
209 config_error(
210 c, "No sections are supported under the 'headers' section");
211 goto cleanup;
212
213 case CONFIG_LINE_TYPE_LINE:
214 kv = lwan_key_value_array_append(&hdrs);
215 if (!kv) {
216 lwan_status_critical_perror(lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 217, __FUNCTION__, "Could not allocate memory for custom response header"
)
217 "Could not allocate memory for custom response header")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 217, __FUNCTION__, "Could not allocate memory for custom response header"
)
;
218 }
219
220 kv->key = strdup(l->key);
221 if (!kv->key) {
222 lwan_status_critical_perror(lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 223, __FUNCTION__, "Could not allocate memory for custom response header"
)
223 "Could not allocate memory for custom response header")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 223, __FUNCTION__, "Could not allocate memory for custom response header"
)
;
224 }
225
226 kv->value = strdup(l->value);
227 if (!kv->value) {
228 lwan_status_critical_perror(lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 229, __FUNCTION__, "Could not allocate memory for custom response header"
)
229 "Could not allocate memory for custom response header")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 229, __FUNCTION__, "Could not allocate memory for custom response header"
)
;
230 }
231 break;
232
233 case CONFIG_LINE_TYPE_SECTION_END:
234 kv = lwan_key_value_array_append(&hdrs);
235 if (!kv) {
236 lwan_status_critical_perror(lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 237, __FUNCTION__, "Could not allocate memory for custom response header"
)
237 "Could not allocate memory for custom response header")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 237, __FUNCTION__, "Could not allocate memory for custom response header"
)
;
238 }
239
240 kv->key = NULL((void*)0);
241 kv->value = NULL((void*)0);
242
243 build_response_headers(lwan, lwan_key_value_array_get_array(&hdrs));
244 goto cleanup;
245 }
246 }
247
248 config_error(c, "EOF while looking for end of 'headers' section");
249
250cleanup:
251 LWAN_ARRAY_FOREACH (&hdrs, kv)for (kv = (&hdrs)->base.base; kv < ((typeof(kv))(&
hdrs)->base.base + (&hdrs)->base.elements); kv++)
{
252 free(kv->key);
253 free(kv->value);
254 }
255 lwan_key_value_array_reset(&hdrs);
256}
257
258static void parse_listener_prefix_authorization(struct config *c,
259 const struct config_line *l,
260 struct lwan_url_map *url_map)
261{
262 if (!streq(l->value, "basic")) {
263 config_error(c, "Only basic authorization supported");
264 return;
265 }
266
267 memset(&url_map->authorization, 0, sizeof(url_map->authorization));
268
269 while ((l = config_read_line(c))) {
270 switch (l->type) {
271 case CONFIG_LINE_TYPE_LINE:
272 if (streq(l->key, "realm")) {
273 free(url_map->authorization.realm);
274 url_map->authorization.realm = strdup(l->value);
275 } else if (streq(l->key, "password_file")) {
276 free(url_map->authorization.password_file);
277 url_map->authorization.password_file = realpath(l->value, NULL((void*)0));
278 if (!url_map->authorization.password_file)
279 config_error(c, "Could not determine full path for password file: %s", l->value);
280 }
281 break;
282
283 case CONFIG_LINE_TYPE_SECTION:
284 config_error(c, "Unexpected section: %s", l->key);
285 goto error;
286
287 case CONFIG_LINE_TYPE_SECTION_END:
288 if (!url_map->authorization.realm)
289 url_map->authorization.realm = strdup("Lwan");
290 if (!url_map->authorization.password_file)
291 url_map->authorization.password_file = strdup("htpasswd");
292
293 url_map->flags |= HANDLER_MUST_AUTHORIZE;
294 return;
295 }
296 }
297
298 config_error(c, "Could not find end of authorization section");
299
300error:
301 free(url_map->authorization.realm);
302 free(url_map->authorization.password_file);
303}
304
305__attribute__((no_sanitize_address))
306static const char *get_module_name(const struct lwan_module *module)
307{
308 const struct lwan_module_info *iter;
309
310 LWAN_SECTION_FOREACH(lwan_module, iter)for (iter = ({ extern const typeof(*iter) __start_lwan_module
[]; __start_lwan_module; }); iter < ({ extern const typeof
(*iter) __stop_lwan_module[]; __stop_lwan_module; }); (iter)++
)
{
311 if (iter->module == module)
312 return iter->name;
313 }
314
315 return "<unknown>";
316}
317
318static void parse_listener_prefix(struct config *c,
319 const struct config_line *l,
320 struct lwan *lwan,
321 const struct lwan_module *module,
322 void *handler)
323{
324 struct lwan_url_map url_map = {};
325 struct hash *hash = hash_str_new(free, free);
326 char *prefix = strdupa(l->value)(__extension__ ({ const char *__old = (l->value); size_t __len
= strlen (__old) + 1; char *__new = (char *) __builtin_alloca
(__len); (char *) memcpy (__new, __old, __len); }))
;
327 struct config *isolated;
328
329 if (!hash)
21
Assuming 'hash' is non-null
22
Taking false branch
330 lwan_status_critical("Could not allocate hash table")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 330, __FUNCTION__, "Could not allocate hash table")
;
331
332 isolated = config_isolate_section(c, l);
333 if (!isolated) {
23
Assuming 'isolated' is non-null
24
Taking false branch
334 config_error(c, "Could not isolate configuration file");
335 goto out;
336 }
337
338 while ((l = config_read_line(c))) {
25
Loop condition is true. Entering loop body
28
Execution continues on line 338
29
Potential memory leak
339 switch (l->type) {
26
Control jumps to 'case CONFIG_LINE_TYPE_LINE:' at line 340
340 case CONFIG_LINE_TYPE_LINE:
341 hash_add(hash, strdup(l->key), strdup(l->value));
27
Memory is allocated
342 break;
343
344 case CONFIG_LINE_TYPE_SECTION:
345 if (streq(l->key, "authorization")) {
346 parse_listener_prefix_authorization(c, l, &url_map);
347 } else if (!config_skip_section(c, l)) {
348 config_error(c, "Could not skip section");
349 goto out;
350 }
351 break;
352
353 case CONFIG_LINE_TYPE_SECTION_END:
354 goto add_map;
355 }
356 }
357
358 config_error(c, "Expecting section end while parsing prefix");
359 goto out;
360
361add_map:
362 assert((handler && !module) || (!handler && module))((void) sizeof (((handler && !module) || (!handler &&
module)) ? 1 : 0), __extension__ ({ if ((handler && !
module) || (!handler && module)) ; else __assert_fail
("(handler && !module) || (!handler && module)"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 362, __extension__ __PRETTY_FUNCTION__); }))
;
363
364 if (handler) {
365 url_map.handler = handler;
366 url_map.flags |= HANDLER_PARSE_MASK | HANDLER_DATA_IS_HASH_TABLE;
367 url_map.data = hash;
368 url_map.module = NULL((void*)0);
369
370 hash = NULL((void*)0);
371 } else if (module->create_from_hash && module->handle_request) {
372 lwan_status_debug("Initializing module %s from config",lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 373, __FUNCTION__, "Initializing module %s from config", get_module_name
(module))
373 get_module_name(module))lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 373, __FUNCTION__, "Initializing module %s from config", get_module_name
(module))
;
374
375 url_map.data = module->create_from_hash(prefix, hash);
376 if (!url_map.data) {
377 config_error(c, "Could not create module instance");
378 goto out;
379 }
380
381 if (module->parse_conf && !module->parse_conf(url_map.data, isolated)) {
382 const char *msg = config_last_error(isolated);
383
384 config_error(c, "Error from module: %s", msg ? msg : "Unknown");
385 goto out;
386 }
387
388 url_map.handler = module->handle_request;
389 url_map.flags |= module->flags;
390 url_map.module = module;
391 } else if (UNLIKELY(!module->create_from_hash)__builtin_expect(((!module->create_from_hash)), (0))) {
392 config_error(c, "Module isn't prepared to load settings from a file; "
393 "create_from_hash() method isn't present");
394 goto out;
395 } else if (UNLIKELY(!module->handle_request)__builtin_expect(((!module->handle_request)), (0))) {
396 config_error(c, "Module does not have handle_request() method");
397 goto out;
398 }
399
400 add_url_map(&lwan->url_map_trie, prefix, &url_map);
401
402out:
403 hash_free(hash);
404 config_close(isolated);
405}
406
407static void register_url_map(struct lwan *l, const struct lwan_url_map *map)
408{
409 struct lwan_url_map *copy = add_url_map(&l->url_map_trie, NULL((void*)0), map);
410
411 if (copy->module && copy->module->create) {
412 lwan_status_debug("Initializing module %s from struct",lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 413, __FUNCTION__, "Initializing module %s from struct", get_module_name
(copy->module))
413 get_module_name(copy->module))lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 413, __FUNCTION__, "Initializing module %s from struct", get_module_name
(copy->module))
;
414
415 copy->data = copy->module->create(map->prefix, copy->args);
416 if (!copy->data) {
417 lwan_status_critical("Could not initialize module %s",lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 418, __FUNCTION__, "Could not initialize module %s", get_module_name
(copy->module))
418 get_module_name(copy->module))lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 418, __FUNCTION__, "Could not initialize module %s", get_module_name
(copy->module))
;
419 }
420
421 copy->flags = copy->module->flags;
422 copy->handler = copy->module->handle_request;
423 } else {
424 copy->flags = HANDLER_PARSE_MASK;
425 }
426}
427
428void lwan_set_url_map(struct lwan *l, const struct lwan_url_map *map)
429{
430 lwan_trie_destroy(&l->url_map_trie);
431 if (UNLIKELY(!lwan_trie_init(&l->url_map_trie, destroy_urlmap))__builtin_expect(((!lwan_trie_init(&l->url_map_trie, destroy_urlmap
))), (0))
)
432 lwan_status_critical_perror("Could not initialize trie")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 432, __FUNCTION__, "Could not initialize trie")
;
433
434 for (; map->prefix; map++)
435 register_url_map(l, map);
436}
437
438void lwan_detect_url_map(struct lwan *l)
439{
440 const struct lwan_url_map_route_info *iter;
441
442 lwan_trie_destroy(&l->url_map_trie);
443 if (UNLIKELY(!lwan_trie_init(&l->url_map_trie, destroy_urlmap))__builtin_expect(((!lwan_trie_init(&l->url_map_trie, destroy_urlmap
))), (0))
)
444 lwan_status_critical_perror("Could not initialize trie")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 444, __FUNCTION__, "Could not initialize trie")
;
445
446 LWAN_SECTION_FOREACH(lwan_url_map, iter)for (iter = ({ extern const typeof(*iter) __start_lwan_url_map
[]; __start_lwan_url_map; }); iter < ({ extern const typeof
(*iter) __stop_lwan_url_map[]; __stop_lwan_url_map; }); (iter
)++)
{
447 struct lwan_url_map map = {.prefix = iter->route,
448 .handler = iter->handler};
449 register_url_map(l, &map);
450 }
451}
452
453const char *lwan_get_config_path(char *path_buf, size_t path_buf_len)
454{
455 char buffer[PATH_MAX4096];
456
457 if (proc_pidpath(getpid(), buffer, sizeof(buffer)) < 0)
458 goto out;
459
460 char *path = strrchr(buffer, '/');
461 if (!path)
462 goto out;
463 int ret = snprintf(path_buf, path_buf_len, "%s.conf", path + 1);
464 if (ret < 0 || ret >= (int)path_buf_len)
465 goto out;
466
467 return path_buf;
468
469out:
470 return "lwan.conf";
471}
472
473static void parse_tls_listener(struct config *conf, const struct config_line *line, struct lwan *lwan)
474{
475#if !defined(LWAN_HAVE_MBEDTLS)
476 config_error(conf, "Lwan has been built without mbedTLS support");
477 return;
478#endif
479
480 lwan->config.tls_listener = strdup(line->value);
481 if (!lwan->config.tls_listener) {
482 config_error(conf, "Could not allocate memory for tls_listener");
483 return;
484 }
485
486 lwan->config.ssl.cert = NULL((void*)0);
487 lwan->config.ssl.key = NULL((void*)0);
488
489 while ((line = config_read_line(conf))) {
490 switch (line->type) {
491 case CONFIG_LINE_TYPE_SECTION_END:
492 if (!lwan->config.ssl.cert)
493 config_error(conf, "Missing path to certificate");
494 if (!lwan->config.ssl.key)
495 config_error(conf, "Missing path to private key");
496 return;
497 case CONFIG_LINE_TYPE_SECTION:
498 config_error(conf, "Unexpected section: %s", line->key);
499 return;
500 case CONFIG_LINE_TYPE_LINE:
501 if (streq(line->key, "cert")) {
502 free(lwan->config.ssl.cert);
503 lwan->config.ssl.cert = strdup(line->value);
504 if (!lwan->config.ssl.cert)
505 return lwan_status_critical("Could not copy string")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 505, __FUNCTION__, "Could not copy string")
;
506 } else if (streq(line->key, "key")) {
507 free(lwan->config.ssl.key);
508 lwan->config.ssl.key = strdup(line->value);
509 if (!lwan->config.ssl.key)
510 return lwan_status_critical("Could not copy string")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 510, __FUNCTION__, "Could not copy string")
;
511 } else if (streq(line->key, "hsts")) {
512 lwan->config.ssl.send_hsts_header = parse_bool(line->value, false0);
513 } else {
514 config_error(conf, "Unexpected key: %s", line->key);
515 }
516 }
517 }
518
519 config_error(conf, "Expecting section end while parsing SSL configuration");
520}
521
522static void
523parse_listener(struct config *c, const struct config_line *l, struct lwan *lwan)
524{
525 lwan->config.listener = strdup(l->value);
526 if (!lwan->config.listener)
527 config_error(c, "Could not allocate memory for listener");
528
529 while ((l = config_read_line(c))) {
530 switch (l->type) {
531 case CONFIG_LINE_TYPE_LINE:
532 config_error(c, "Unexpected key %s", l->key);
533 return;
534 case CONFIG_LINE_TYPE_SECTION:
535 config_error(c, "Unexpected section %s", l->key);
536 return;
537 case CONFIG_LINE_TYPE_SECTION_END:
538 return;
539 }
540 }
541
542 config_error(c, "Unexpected EOF while parsing listener");
543}
544
545static void
546parse_site(struct config *c, const struct config_line *l, struct lwan *lwan)
547{
548 while ((l = config_read_line(c))) {
14
Loop condition is true. Entering loop body
549 switch (l->type) {
15
Control jumps to 'case CONFIG_LINE_TYPE_SECTION:' at line 553
550 case CONFIG_LINE_TYPE_LINE:
551 config_error(c, "Expecting prefix section");
552 return;
553 case CONFIG_LINE_TYPE_SECTION:
554 /* FIXME: per-site authorization? */
555
556 if (l->key[0] == '&') {
16
Assuming the condition is false
17
Taking false branch
557 void *handler = find_handler(l->key + 1);
558 if (handler) {
559 parse_listener_prefix(c, l, lwan, NULL((void*)0), handler);
560 continue;
561 }
562
563 config_error(c, "Could not find handler name: %s", l->key + 1);
564 return;
565 }
566
567 const struct lwan_module *module = find_module(l->key);
568 if (module) {
18
Assuming 'module' is non-null
19
Taking true branch
569 parse_listener_prefix(c, l, lwan, module, NULL((void*)0));
20
Calling 'parse_listener_prefix'
570 continue;
571 }
572
573 config_error(c, "Invalid section or module not found: %s", l->key);
574 return;
575 case CONFIG_LINE_TYPE_SECTION_END:
576 return;
577 }
578 }
579
580 config_error(c, "Expecting section end while parsing listener");
581}
582
583static bool_Bool setup_from_config(struct lwan *lwan, const char *path)
584{
585 const struct config_line *line;
586 struct config *conf;
587 bool_Bool has_site = false0;
588 bool_Bool has_listener = false0;
589 bool_Bool has_tls_listener = false0;
590 char path_buf[PATH_MAX4096];
591
592 if (!path
3.1
'path' is null
)
4
Taking true branch
593 path = lwan_get_config_path(path_buf, sizeof(path_buf));
594 lwan_status_info("Loading configuration file: %s", path)lwan_status_info_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 594, __FUNCTION__, "Loading configuration file: %s", path)
;
595
596 conf = config_open(path);
597 if (!conf)
5
Assuming 'conf' is non-null
6
Taking false branch
598 return false0;
599
600 if (!lwan_trie_init(&lwan->url_map_trie, destroy_urlmap))
7
Assuming the condition is false
8
Taking false branch
601 return false0;
602
603 while ((line = config_read_line(conf))) {
9
Loop condition is true. Entering loop body
604 switch (line->type) {
10
Control jumps to 'case CONFIG_LINE_TYPE_SECTION:' at line 665
605 case CONFIG_LINE_TYPE_LINE:
606 if (streq(line->key, "keep_alive_timeout")) {
607 lwan->config.keep_alive_timeout = (unsigned int)parse_long(
608 line->value, default_config.keep_alive_timeout);
609 } else if (streq(line->key, "quiet")) {
610 lwan->config.quiet =
611 parse_bool(line->value, default_config.quiet);
612 } else if (streq(line->key, "proxy_protocol")) {
613 lwan->config.proxy_protocol =
614 parse_bool(line->value, default_config.proxy_protocol);
615 } else if (streq(line->key, "allow_cors")) {
616 lwan->config.allow_cors =
617 parse_bool(line->value, default_config.allow_cors);
618 } else if (streq(line->key, "expires")) {
619 lwan->config.expires =
620 parse_time_period(line->value, default_config.expires);
621 } else if (streq(line->key, "error_template")) {
622 free(lwan->config.error_template);
623 lwan->config.error_template = strdup(line->value);
624 } else if (streq(line->key, "threads")) {
625 long n_threads =
626 parse_long(line->value, default_config.n_threads);
627 if (n_threads < 0)
628 config_error(conf, "Invalid number of threads: %ld",
629 n_threads);
630 lwan->config.n_threads = (unsigned int)n_threads;
631 } else if (streq(line->key, "max_post_data_size")) {
632 long max_post_data_size = parse_long(
633 line->value, (long)default_config.max_post_data_size);
634 if (max_post_data_size < 0)
635 config_error(conf, "Negative maximum post data size");
636 else if (max_post_data_size > 128 * (1 << 20))
637 config_error(conf,
638 "Maximum post data can't be over 128MiB");
639 lwan->config.max_post_data_size = (size_t)max_post_data_size;
640 } else if (streq(line->key, "max_put_data_size")) {
641 long max_put_data_size = parse_long(
642 line->value, (long)default_config.max_put_data_size);
643 if (max_put_data_size < 0)
644 config_error(conf, "Negative maximum put data size");
645 else if (max_put_data_size > 128 * (1 << 20))
646 config_error(conf,
647 "Maximum put data can't be over 128MiB");
648 lwan->config.max_put_data_size = (size_t)max_put_data_size;
649 } else if (streq(line->key, "allow_temp_files")) {
650 bool_Bool has_post, has_put;
651
652 if (strstr(line->value, "all")) {
653 has_post = has_put = true1;
654 } else {
655 has_post = !!strstr(line->value, "post");
656 has_put = !!strstr(line->value, "put");
657 }
658
659 lwan->config.allow_post_temp_file = has_post;
660 lwan->config.allow_put_temp_file = has_put;
661 } else {
662 config_error(conf, "Unknown config key: %s", line->key);
663 }
664 break;
665 case CONFIG_LINE_TYPE_SECTION:
666 if (streq(line->key, "site")) {
11
Taking true branch
667 if (!has_site
11.1
'has_site' is false
) {
12
Taking true branch
668 parse_site(conf, line, lwan);
13
Calling 'parse_site'
669 has_site = true1;
670 } else {
671 config_error(conf, "Only one site may be configured");
672 }
673 } else if (streq(line->key, "straitjacket")) {
674 lwan_straitjacket_enforce_from_config(conf);
675 } else if (streq(line->key, "headers")) {
676 parse_global_headers(conf, lwan);
677 } else if (streq(line->key, "listener")) {
678 if (has_listener) {
679 config_error(conf, "Listener already set up");
680 } else {
681 parse_listener(conf, line, lwan);
682 has_listener = true1;
683 }
684 } else if (streq(line->key, "tls_listener")) {
685 if (has_tls_listener) {
686 config_error(conf, "TLS Listener already set up");
687 } else {
688 parse_tls_listener(conf, line, lwan);
689 has_tls_listener = true1;
690 }
691 } else {
692 config_error(conf, "Unknown section type: %s", line->key);
693 }
694 break;
695 case CONFIG_LINE_TYPE_SECTION_END:
696 config_error(conf, "Unexpected section end");
697 }
698 }
699
700 if (config_last_error(conf)) {
701 lwan_status_critical("Error on config file \"%s\", line %d: %s", path,lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 702, __FUNCTION__, "Error on config file \"%s\", line %d: %s"
, path, config_cur_line(conf), config_last_error(conf))
702 config_cur_line(conf), config_last_error(conf))lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 702, __FUNCTION__, "Error on config file \"%s\", line %d: %s"
, path, config_cur_line(conf), config_last_error(conf))
;
703 lwan_trie_destroy(&lwan->url_map_trie);
704 }
705
706 config_close(conf);
707
708 return true1;
709}
710
711static void try_setup_from_config(struct lwan *l,
712 const struct lwan_config *config)
713{
714 if (!setup_from_config(l, config->config_file_path)) {
3
Calling 'setup_from_config'
715 if (config->config_file_path) {
716 lwan_status_critical("Could not read config file: %s",lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 717, __FUNCTION__, "Could not read config file: %s", config
->config_file_path)
717 config->config_file_path)lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 717, __FUNCTION__, "Could not read config file: %s", config
->config_file_path)
;
718 }
719 }
720
721 lwan_status_init(l); /* `quiet` key might have changed value. */
722
723 l->config.request_flags =
724 (l->config.proxy_protocol ? REQUEST_ALLOW_PROXY_REQS : 0) |
725 (l->config.allow_cors ? REQUEST_ALLOW_CORS : 0) |
726 (l->config.ssl.send_hsts_header ? REQUEST_WANTS_HSTS_HEADER : 0);
727}
728
729static rlim_t setup_open_file_count_limits(void)
730{
731 struct rlimit r;
732
733 if (getrlimit(RLIMIT_NOFILERLIMIT_NOFILE, &r) < 0) {
734 lwan_status_perror("Could not obtain maximum number of file "lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 736, __FUNCTION__, "Could not obtain maximum number of file "
"descriptors. Assuming %d", 256)
735 "descriptors. Assuming %d",lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 736, __FUNCTION__, "Could not obtain maximum number of file "
"descriptors. Assuming %d", 256)
736 OPEN_MAX)lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 736, __FUNCTION__, "Could not obtain maximum number of file "
"descriptors. Assuming %d", 256)
;
737 return OPEN_MAX256;
738 }
739
740 if (r.rlim_max != r.rlim_cur) {
741 const rlim_t current = r.rlim_cur;
742
743 if (r.rlim_max == RLIM_INFINITY0xffffffffffffffffuLL && r.rlim_cur < OPEN_MAX256) {
744 r.rlim_cur = OPEN_MAX256;
745 } else if (r.rlim_cur < r.rlim_max) {
746 r.rlim_cur = r.rlim_max;
747 } else {
748 /* Shouldn't happen, so just return the current value. */
749 goto out;
750 }
751
752 if (setrlimit(RLIMIT_NOFILERLIMIT_NOFILE, &r) < 0) {
753 lwan_status_perror("Could not raise maximum number of file "lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 755, __FUNCTION__, "Could not raise maximum number of file "
"descriptors to %" "l" "u" ". Leaving at " "%" "l" "u", r.rlim_max
, current)
754 "descriptors to %" PRIu64 ". Leaving at "lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 755, __FUNCTION__, "Could not raise maximum number of file "
"descriptors to %" "l" "u" ". Leaving at " "%" "l" "u", r.rlim_max
, current)
755 "%" PRIu64, r.rlim_max, current)lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 755, __FUNCTION__, "Could not raise maximum number of file "
"descriptors to %" "l" "u" ". Leaving at " "%" "l" "u", r.rlim_max
, current)
;
756 r.rlim_cur = current;
757 }
758 }
759
760out:
761 return r.rlim_cur;
762}
763
764static void allocate_connections(struct lwan *l, size_t max_open_files)
765{
766 const size_t sz = max_open_files * sizeof(struct lwan_connection);
767
768 l->conns = lwan_aligned_alloc(sz, 64);
769 if (UNLIKELY(!l->conns)__builtin_expect(((!l->conns)), (0)))
770 lwan_status_critical_perror("lwan_alloc_aligned")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 770, __FUNCTION__, "lwan_alloc_aligned")
;
771
772 memset(l->conns, 0, sz);
773}
774
775static void get_number_of_cpus(struct lwan *l)
776{
777 long n_online_cpus = sysconf(_SC_NPROCESSORS_ONLN_SC_NPROCESSORS_ONLN);
778 long n_available_cpus = sysconf(_SC_NPROCESSORS_CONF_SC_NPROCESSORS_CONF);
779
780 if (n_online_cpus < 0) {
781 lwan_status_warning(lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 782, __FUNCTION__, "Could not get number of online CPUs, assuming 1 CPU"
)
782 "Could not get number of online CPUs, assuming 1 CPU")lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 782, __FUNCTION__, "Could not get number of online CPUs, assuming 1 CPU"
)
;
783 n_online_cpus = 1;
784 }
785
786 if (n_available_cpus < 0) {
787 lwan_status_warning(lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 789, __FUNCTION__, "Could not get number of available CPUs, assuming %ld CPUs"
, n_online_cpus)
788 "Could not get number of available CPUs, assuming %ld CPUs",lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 789, __FUNCTION__, "Could not get number of available CPUs, assuming %ld CPUs"
, n_online_cpus)
789 n_online_cpus)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 789, __FUNCTION__, "Could not get number of available CPUs, assuming %ld CPUs"
, n_online_cpus)
;
790 n_available_cpus = n_online_cpus;
791 }
792
793 l->online_cpus = (unsigned int)n_online_cpus;
794 l->available_cpus = (unsigned int)n_available_cpus;
795}
796
797void lwan_init(struct lwan *l) { lwan_init_with_config(l, &default_config); }
1
Calling 'lwan_init_with_config'
798
799const struct lwan_config *lwan_get_default_config(void)
800{
801 return &default_config;
802}
803
804static char *dup_or_null(const char *s)
805{
806 return s ? strdup(s) : NULL((void*)0);
807}
808
809void lwan_init_with_config(struct lwan *l, const struct lwan_config *config)
810{
811 /* Load defaults */
812 memset(l, 0, sizeof(*l));
813 memcpy(&l->config, config, sizeof(*config));
814 l->config.listener = dup_or_null(l->config.listener);
815 l->config.config_file_path = dup_or_null(l->config.config_file_path);
816 l->config.ssl.key = dup_or_null(l->config.ssl.key);
817 l->config.ssl.cert = dup_or_null(l->config.ssl.cert);
818
819 /* Initialize status first, as it is used by other things during
820 * their initialization. */
821 lwan_status_init(l);
822
823 /* These will only print debugging messages. Debug messages are always
824 * printed if we're on a debug build, so the quiet setting will be
825 * respected. */
826 lwan_job_thread_init();
827 lwan_tables_init();
828
829 /* Get the number of CPUs here because straightjacket might be active
830 * and this will block access to /proc and /sys, which will cause
831 * get_number_of_cpus() to get incorrect fallback values. */
832 get_number_of_cpus(l);
833
834 try_setup_from_config(l, config);
2
Calling 'try_setup_from_config'
835
836 if (!l->headers.len)
837 build_response_headers(l, config->global_headers);
838
839 lwan_response_init(l);
840
841 /* Continue initialization as normal. */
842 lwan_status_debug("Initializing lwan web server")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 842, __FUNCTION__, "Initializing lwan web server")
;
843
844 if (!l->config.n_threads) {
845 l->thread.count = l->online_cpus;
846 if (l->thread.count == 1)
847 l->thread.count = 2;
848 } else if (l->config.n_threads > 3 * l->online_cpus) {
849 l->thread.count = l->online_cpus * 3;
850
851 lwan_status_warning("%d threads requested, but only %d online CPUs "lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 854, __FUNCTION__, "%d threads requested, but only %d online CPUs "
"(out of %d configured CPUs); capping to %d threads", l->
config.n_threads, l->online_cpus, l->available_cpus, 3 *
l->online_cpus)
852 "(out of %d configured CPUs); capping to %d threads",lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 854, __FUNCTION__, "%d threads requested, but only %d online CPUs "
"(out of %d configured CPUs); capping to %d threads", l->
config.n_threads, l->online_cpus, l->available_cpus, 3 *
l->online_cpus)
853 l->config.n_threads, l->online_cpus, l->available_cpus,lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 854, __FUNCTION__, "%d threads requested, but only %d online CPUs "
"(out of %d configured CPUs); capping to %d threads", l->
config.n_threads, l->online_cpus, l->available_cpus, 3 *
l->online_cpus)
854 3 * l->online_cpus)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 854, __FUNCTION__, "%d threads requested, but only %d online CPUs "
"(out of %d configured CPUs); capping to %d threads", l->
config.n_threads, l->online_cpus, l->available_cpus, 3 *
l->online_cpus)
;
855 } else if (l->config.n_threads > 255) {
856 l->thread.count = 256;
857
858 lwan_status_warning("%d threads requested, but max 256 supported",lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 859, __FUNCTION__, "%d threads requested, but max 256 supported"
, l->config.n_threads)
859 l->config.n_threads)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 859, __FUNCTION__, "%d threads requested, but max 256 supported"
, l->config.n_threads)
;
860 } else {
861 l->thread.count = l->config.n_threads;
862 }
863
864 rlim_t max_open_files = setup_open_file_count_limits();
865 allocate_connections(l, (size_t)max_open_files);
866
867 l->thread.max_fd = (unsigned)max_open_files / (unsigned)l->thread.count;
868 lwan_status_info("Using %d threads, maximum %d sockets per thread",lwan_status_info_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 869, __FUNCTION__, "Using %d threads, maximum %d sockets per thread"
, l->thread.count, l->thread.max_fd)
869 l->thread.count, l->thread.max_fd)lwan_status_info_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 869, __FUNCTION__, "Using %d threads, maximum %d sockets per thread"
, l->thread.count, l->thread.max_fd)
;
870
871 signal(SIGPIPE13, SIG_IGN((__sighandler_t) 1));
872
873 lwan_readahead_init();
874 lwan_thread_init(l);
875 lwan_http_authorize_init();
876}
877
878void lwan_shutdown(struct lwan *l)
879{
880 lwan_status_info("Shutting down")lwan_status_info_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 880, __FUNCTION__, "Shutting down")
;
881
882 free(l->config.listener);
883 free(l->config.error_template);
884 free(l->config.config_file_path);
885
886 lwan_always_bzero(l->config.ssl.cert, strlen(l->config.ssl.cert));
887 free(l->config.ssl.cert);
888 lwan_always_bzero(l->config.ssl.key, strlen(l->config.ssl.key));
889 free(l->config.ssl.key);
890
891 lwan_job_thread_shutdown();
892 lwan_thread_shutdown(l);
893
894 lwan_status_debug("Shutting down URL handlers")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 894, __FUNCTION__, "Shutting down URL handlers")
;
895 lwan_trie_destroy(&l->url_map_trie);
896
897 free(l->headers.value);
898 free(l->conns);
899
900 lwan_response_shutdown(l);
901 lwan_tables_shutdown();
902 lwan_status_shutdown(l);
903 lwan_http_authorize_shutdown();
904 lwan_readahead_shutdown();
905}
906
907void lwan_main_loop(struct lwan *l)
908{
909 lwan_status_info("Ready to serve")lwan_status_info_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan.c"
, 909, __FUNCTION__, "Ready to serve")
;
910
911 lwan_job_thread_main_loop();
912}
913
914#ifdef CLOCK_MONOTONIC_COARSE6
915__attribute__((constructor)) static void detect_fastest_monotonic_clock(void)
916{
917 struct timespec ts;
918
919 if (!clock_gettime(CLOCK_MONOTONIC_COARSE6, &ts))
920 monotonic_clock_id = CLOCK_MONOTONIC_COARSE6;
921}
922#endif
923
924void lwan_set_thread_name(const char *name)
925{
926 char thread_name[16];
927 char process_name[PATH_MAX4096];
928 char *tmp;
929 int ret;
930
931 if (proc_pidpath(getpid(), process_name, sizeof(process_name)) < 0)
932 return;
933
934 tmp = strrchr(process_name, '/');
935 if (!tmp)
936 return;
937
938 ret = snprintf(thread_name, sizeof(thread_name), "%s %s", tmp + 1, name);
939 if (ret < 0)
940 return;
941
942 pthread_set_name_np(pthread_self(), thread_name);
943}