source: MondoRescue/branches/3.3/mindi-busybox/networking/isrv.c@ 3621

Last change on this file since 3621 was 3621, checked in by Bruno Cornec, 7 years ago

New 3?3 banch for incorporation of latest busybox 1.25. Changing minor version to handle potential incompatibilities.
  • Property svn:eol-style set to native
File size: 7.4 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * Generic non-forking server infrastructure.
4 * Intended to make writing telnetd-type servers easier.
5 *
6 * Copyright (C) 2007 Denys Vlasenko
7 *
8 * Licensed under GPLv2, see file LICENSE in this source tree.
9 */
10
11#include "libbb.h"
12#include "isrv.h"
13
14#define DEBUG 0
15
16#if DEBUG
17#define DPRINTF(args...) bb_error_msg(args)
18#else
19#define DPRINTF(args...) ((void)0)
20#endif
21
22/* Helpers */
23
24/* Opaque structure */
25
26struct isrv_state_t {
27 short *fd2peer; /* one per registered fd */
28 void **param_tbl; /* one per registered peer */
29 /* one per registered peer; doesn't exist if !timeout */
30 time_t *timeo_tbl;
31 int (*new_peer)(isrv_state_t *state, int fd);
32 time_t curtime;
33 int timeout;
34 int fd_count;
35 int peer_count;
36 int wr_count;
37 fd_set rd;
38 fd_set wr;
39};
40#define FD2PEER (state->fd2peer)
41#define PARAM_TBL (state->param_tbl)
42#define TIMEO_TBL (state->timeo_tbl)
43#define CURTIME (state->curtime)
44#define TIMEOUT (state->timeout)
45#define FD_COUNT (state->fd_count)
46#define PEER_COUNT (state->peer_count)
47#define WR_COUNT (state->wr_count)
48
49/* callback */
50void isrv_want_rd(isrv_state_t *state, int fd)
51{
52 FD_SET(fd, &state->rd);
53}
54
55/* callback */
56void isrv_want_wr(isrv_state_t *state, int fd)
57{
58 if (!FD_ISSET(fd, &state->wr)) {
59 WR_COUNT++;
60 FD_SET(fd, &state->wr);
61 }
62}
63
64/* callback */
65void isrv_dont_want_rd(isrv_state_t *state, int fd)
66{
67 FD_CLR(fd, &state->rd);
68}
69
70/* callback */
71void isrv_dont_want_wr(isrv_state_t *state, int fd)
72{
73 if (FD_ISSET(fd, &state->wr)) {
74 WR_COUNT--;
75 FD_CLR(fd, &state->wr);
76 }
77}
78
79/* callback */
80int isrv_register_fd(isrv_state_t *state, int peer, int fd)
81{
82 int n;
83
84 DPRINTF("register_fd(peer:%d,fd:%d)", peer, fd);
85
86 if (FD_COUNT >= FD_SETSIZE) return -1;
87 if (FD_COUNT <= fd) {
88 n = FD_COUNT;
89 FD_COUNT = fd + 1;
90
91 DPRINTF("register_fd: FD_COUNT %d", FD_COUNT);
92
93 FD2PEER = xrealloc(FD2PEER, FD_COUNT * sizeof(FD2PEER[0]));
94 while (n < fd) FD2PEER[n++] = -1;
95 }
96
97 DPRINTF("register_fd: FD2PEER[%d] = %d", fd, peer);
98
99 FD2PEER[fd] = peer;
100 return 0;
101}
102
103/* callback */
104void isrv_close_fd(isrv_state_t *state, int fd)
105{
106 DPRINTF("close_fd(%d)", fd);
107
108 close(fd);
109 isrv_dont_want_rd(state, fd);
110 if (WR_COUNT) isrv_dont_want_wr(state, fd);
111
112 FD2PEER[fd] = -1;
113 if (fd == FD_COUNT-1) {
114 do fd--; while (fd >= 0 && FD2PEER[fd] == -1);
115 FD_COUNT = fd + 1;
116
117 DPRINTF("close_fd: FD_COUNT %d", FD_COUNT);
118
119 FD2PEER = xrealloc(FD2PEER, FD_COUNT * sizeof(FD2PEER[0]));
120 }
121}
122
123/* callback */
124int isrv_register_peer(isrv_state_t *state, void *param)
125{
126 int n;
127
128 if (PEER_COUNT >= FD_SETSIZE) return -1;
129 n = PEER_COUNT++;
130
131 DPRINTF("register_peer: PEER_COUNT %d", PEER_COUNT);
132
133 PARAM_TBL = xrealloc(PARAM_TBL, PEER_COUNT * sizeof(PARAM_TBL[0]));
134 PARAM_TBL[n] = param;
135 if (TIMEOUT) {
136 TIMEO_TBL = xrealloc(TIMEO_TBL, PEER_COUNT * sizeof(TIMEO_TBL[0]));
137 TIMEO_TBL[n] = CURTIME;
138 }
139 return n;
140}
141
142static void remove_peer(isrv_state_t *state, int peer)
143{
144 int movesize;
145 int fd;
146
147 DPRINTF("remove_peer(%d)", peer);
148
149 fd = FD_COUNT - 1;
150 while (fd >= 0) {
151 if (FD2PEER[fd] == peer) {
152 isrv_close_fd(state, fd);
153 fd--;
154 continue;
155 }
156 if (FD2PEER[fd] > peer)
157 FD2PEER[fd]--;
158 fd--;
159 }
160
161 PEER_COUNT--;
162 DPRINTF("remove_peer: PEER_COUNT %d", PEER_COUNT);
163
164 movesize = (PEER_COUNT - peer) * sizeof(void*);
165 if (movesize > 0) {
166 memcpy(&PARAM_TBL[peer], &PARAM_TBL[peer+1], movesize);
167 if (TIMEOUT)
168 memcpy(&TIMEO_TBL[peer], &TIMEO_TBL[peer+1], movesize);
169 }
170 PARAM_TBL = xrealloc(PARAM_TBL, PEER_COUNT * sizeof(PARAM_TBL[0]));
171 if (TIMEOUT)
172 TIMEO_TBL = xrealloc(TIMEO_TBL, PEER_COUNT * sizeof(TIMEO_TBL[0]));
173}
174
175static void handle_accept(isrv_state_t *state, int fd)
176{
177 int n, newfd;
178
179 /* suppress gcc warning "cast from ptr to int of different size" */
180 fcntl(fd, F_SETFL, (int)(ptrdiff_t)(PARAM_TBL[0]) | O_NONBLOCK);
181 newfd = accept(fd, NULL, 0);
182 fcntl(fd, F_SETFL, (int)(ptrdiff_t)(PARAM_TBL[0]));
183 if (newfd < 0) {
184 if (errno == EAGAIN) return;
185 /* Most probably someone gave us wrong fd type
186 * (for example, non-socket). Don't want
187 * to loop forever. */
188 bb_perror_msg_and_die("accept");
189 }
190
191 DPRINTF("new_peer(%d)", newfd);
192 n = state->new_peer(state, newfd);
193 if (n)
194 remove_peer(state, n); /* unsuccesful peer start */
195}
196
197static void handle_fd_set(isrv_state_t *state, fd_set *fds, int (*h)(int, void **))
198{
199 enum { LONG_CNT = sizeof(fd_set) / sizeof(long) };
200 int fds_pos;
201 int fd, peer;
202 /* need to know value at _the beginning_ of this routine */
203 int fd_cnt = FD_COUNT;
204
205 BUILD_BUG_ON(LONG_CNT * sizeof(long) != sizeof(fd_set));
206
207 fds_pos = 0;
208 while (1) {
209 /* Find next nonzero bit */
210 while (fds_pos < LONG_CNT) {
211 if (((long*)fds)[fds_pos] == 0) {
212 fds_pos++;
213 continue;
214 }
215 /* Found non-zero word */
216 fd = fds_pos * sizeof(long)*8; /* word# -> bit# */
217 while (1) {
218 if (FD_ISSET(fd, fds)) {
219 FD_CLR(fd, fds);
220 goto found_fd;
221 }
222 fd++;
223 }
224 }
225 break; /* all words are zero */
226 found_fd:
227 if (fd >= fd_cnt) { /* paranoia */
228 DPRINTF("handle_fd_set: fd > fd_cnt?? (%d > %d)",
229 fd, fd_cnt);
230 break;
231 }
232 DPRINTF("handle_fd_set: fd %d is active", fd);
233 peer = FD2PEER[fd];
234 if (peer < 0)
235 continue; /* peer is already gone */
236 if (peer == 0) {
237 handle_accept(state, fd);
238 continue;
239 }
240 DPRINTF("h(fd:%d)", fd);
241 if (h(fd, &PARAM_TBL[peer])) {
242 /* this peer is gone */
243 remove_peer(state, peer);
244 } else if (TIMEOUT) {
245 TIMEO_TBL[peer] = monotonic_sec();
246 }
247 }
248}
249
250static void handle_timeout(isrv_state_t *state, int (*do_timeout)(void **))
251{
252 int n, peer;
253 peer = PEER_COUNT-1;
254 /* peer 0 is not checked */
255 while (peer > 0) {
256 DPRINTF("peer %d: time diff %d", peer,
257 (int)(CURTIME - TIMEO_TBL[peer]));
258 if ((CURTIME - TIMEO_TBL[peer]) >= TIMEOUT) {
259 DPRINTF("peer %d: do_timeout()", peer);
260 n = do_timeout(&PARAM_TBL[peer]);
261 if (n)
262 remove_peer(state, peer);
263 }
264 peer--;
265 }
266}
267
268/* Driver */
269void isrv_run(
270 int listen_fd,
271 int (*new_peer)(isrv_state_t *state, int fd),
272 int (*do_rd)(int fd, void **),
273 int (*do_wr)(int fd, void **),
274 int (*do_timeout)(void **),
275 int timeout,
276 int linger_timeout)
277{
278 isrv_state_t *state = xzalloc(sizeof(*state));
279 state->new_peer = new_peer;
280 state->timeout = timeout;
281
282 /* register "peer" #0 - it will accept new connections */
283 isrv_register_peer(state, NULL);
284 isrv_register_fd(state, /*peer:*/ 0, listen_fd);
285 isrv_want_rd(state, listen_fd);
286 /* remember flags to make blocking<->nonblocking switch faster */
287 /* (suppress gcc warning "cast from ptr to int of different size") */
288 PARAM_TBL[0] = (void*)(ptrdiff_t)(fcntl(listen_fd, F_GETFL));
289
290 while (1) {
291 struct timeval tv;
292 fd_set rd;
293 fd_set wr;
294 fd_set *wrp = NULL;
295 int n;
296
297 tv.tv_sec = timeout;
298 if (PEER_COUNT <= 1)
299 tv.tv_sec = linger_timeout;
300 tv.tv_usec = 0;
301 rd = state->rd;
302 if (WR_COUNT) {
303 wr = state->wr;
304 wrp = &wr;
305 }
306
307 DPRINTF("run: select(FD_COUNT:%d,timeout:%d)...",
308 FD_COUNT, (int)tv.tv_sec);
309 n = select(FD_COUNT, &rd, wrp, NULL, tv.tv_sec ? &tv : NULL);
310 DPRINTF("run: ...select:%d", n);
311
312 if (n < 0) {
313 if (errno != EINTR)
314 bb_perror_msg("select");
315 continue;
316 }
317
318 if (n == 0 && linger_timeout && PEER_COUNT <= 1)
319 break;
320
321 if (timeout) {
322 time_t t = monotonic_sec();
323 if (t != CURTIME) {
324 CURTIME = t;
325 handle_timeout(state, do_timeout);
326 }
327 }
328 if (n > 0) {
329 handle_fd_set(state, &rd, do_rd);
330 if (wrp)
331 handle_fd_set(state, wrp, do_wr);
332 }
333 }
334 DPRINTF("run: bailout");
335 /* NB: accept socket is not closed. Caller is to decide what to do */
336}
Note: See TracBrowser for help on using the repository browser.