blob: 2e65bc5d39ac500e9c14d7ff45519f16113e7ce2 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
/*
* Copyright (c) 2022 Egor Tensin <Egor.Tensin@gmail.com>
* This file is part of the "cimple" project.
* For details, see https://github.com/egor-tensin/cimple.
* Distributed under the MIT License.
*/
#include "tcp_server.h"
#include "log.h"
#include "net.h"
#include "signal.h"
#include <pthread.h>
#include <signal.h>
#include <stdlib.h>
struct tcp_server {
int fd;
};
int tcp_server_create(struct tcp_server **_server, const char *port)
{
int ret = 0;
struct tcp_server *server = malloc(sizeof(struct tcp_server));
if (!server) {
log_errno("malloc");
return -1;
}
ret = net_bind(port);
if (ret < 0)
goto free;
server->fd = ret;
*_server = server;
return ret;
free:
free(server);
return ret;
}
void tcp_server_destroy(struct tcp_server *server)
{
net_close(server->fd);
free(server);
}
struct child_context {
int fd;
tcp_server_conn_handler handler;
void *arg;
};
static void *connection_thread(void *_ctx)
{
struct child_context *ctx = (struct child_context *)_ctx;
int ret = 0;
/* Let the child thread handle its signals except those that should be
* handled in the main thread. */
ret = signal_block_stops();
if (ret < 0)
goto free_ctx;
ctx->handler(ctx->fd, ctx->arg);
free_ctx:
free(ctx);
return NULL;
}
int tcp_server_accept(const struct tcp_server *server, tcp_server_conn_handler handler, void *arg)
{
sigset_t old_mask;
pthread_t child;
int ret = 0;
struct child_context *ctx = calloc(1, sizeof(*ctx));
if (!ctx) {
log_errno("malloc");
return -1;
}
ctx->handler = handler;
ctx->arg = arg;
ret = net_accept(server->fd);
if (ret < 0)
goto free_ctx;
ctx->fd = ret;
/* Block all signals (we'll unblock them later); the child thread will
* have all signals blocked initially. This allows the main thread to
* handle SIGINT/SIGTERM/etc. */
ret = signal_block_all(&old_mask);
if (ret < 0)
goto close_conn;
ret = pthread_create(&child, NULL, connection_thread, ctx);
if (ret) {
pthread_errno(ret, "pthread_create");
goto restore_mask;
}
/* Restore the previously-enabled signals for handling in the main thread. */
signal_restore(&old_mask);
return ret;
restore_mask:
signal_restore(&old_mask);
close_conn:
net_close(ctx->fd);
free_ctx:
free(ctx);
return ret;
}
|
