/[LeafOK_CVS]/lbbs/src/net_server.c
ViewVC logotype

Annotation of /lbbs/src/net_server.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.84 - (hide annotations)
Sun Nov 16 02:06:56 2025 UTC (4 months ago) by sysadm
Branch: MAIN
Changes since 1.83: +12 -0 lines
Content type: text/x-csrc 
log_restart on SIGHUP
1 sysadm 1.77 /* SPDX-License-Identifier: GPL-3.0-or-later */
2     /*
3     * net_server
4     * - network server with SSH support
5     *
6 sysadm 1.78 * Copyright (C) 2004-2025 Leaflet <leaflet@leafok.com>
7 sysadm 1.77 */
8 sysadm 1.1
9 sysadm 1.81 #ifdef HAVE_CONFIG_H
10     #include "config.h"
11     #endif
12    
13 sysadm 1.62 #include "bbs.h"
14     #include "bbs_main.h"
15 sysadm 1.80 #include "bwf.h"
16 sysadm 1.1 #include "common.h"
17 sysadm 1.62 #include "database.h"
18     #include "file_loader.h"
19 sysadm 1.82 #include "hash_dict.h"
20 sysadm 1.7 #include "io.h"
21 sysadm 1.44 #include "init.h"
22 sysadm 1.62 #include "log.h"
23     #include "login.h"
24 sysadm 1.19 #include "menu.h"
25 sysadm 1.62 #include "net_server.h"
26 sysadm 1.67 #include "section_list.h"
27 sysadm 1.42 #include "section_list_loader.h"
28 sysadm 1.20 #include <errno.h>
29     #include <fcntl.h>
30 sysadm 1.74 #include <pty.h>
31 sysadm 1.19 #include <signal.h>
32 sysadm 1.20 #include <stdlib.h>
33 sysadm 1.62 #include <string.h>
34 sysadm 1.19 #include <unistd.h>
35 sysadm 1.74 #include <utmp.h>
36 sysadm 1.9 #include <arpa/inet.h>
37 sysadm 1.62 #include <libssh/callbacks.h>
38 sysadm 1.55 #include <libssh/libssh.h>
39     #include <libssh/server.h>
40 sysadm 1.62 #include <netinet/in.h>
41 sysadm 1.61 #include <sys/epoll.h>
42 sysadm 1.62 #include <sys/socket.h>
43 sysadm 1.61 #include <sys/syscall.h>
44     #include <sys/types.h>
45     #include <sys/wait.h>
46     #include <systemd/sd-daemon.h>
47 sysadm 1.3
48 sysadm 1.79 enum _net_server_constant_t
49     {
50     WAIT_CHILD_PROCESS_EXIT_TIMEOUT = 5, // second
51     WAIT_CHILD_PROCESS_KILL_TIMEOUT = 1, // second
52    
53     SSH_AUTH_MAX_DURATION = 60 * 1000, // milliseconds
54     };
55 sysadm 1.70
56 sysadm 1.79 static const char SFTP_SERVER_PATH[] = "/usr/lib/sftp-server";
57 sysadm 1.74
58     /* A userdata struct for session. */
59     struct session_data_struct
60 sysadm 1.55 {
61     int tries;
62     int error;
63     };
64    
65 sysadm 1.74 /* A userdata struct for channel. */
66     struct channel_data_struct
67     {
68     /* pid of the child process the channel will spawn. */
69     pid_t pid;
70     /* For PTY allocation */
71     socket_t pty_master;
72     socket_t pty_slave;
73     /* For communication with the child process. */
74     socket_t child_stdin;
75     socket_t child_stdout;
76     /* Only used for subsystem and exec requests. */
77     socket_t child_stderr;
78     /* Event which is used to poll the above descriptors. */
79     ssh_event event;
80     /* Terminal size struct. */
81     struct winsize *winsize;
82     };
83    
84 sysadm 1.55 static int auth_password(ssh_session session, const char *user,
85     const char *password, void *userdata)
86     {
87 sysadm 1.74 struct session_data_struct *sdata = (struct session_data_struct *)userdata;
88 sysadm 1.55 int ret;
89    
90     if (strcmp(user, "guest") == 0)
91     {
92 sysadm 1.57 ret = load_guest_info();
93 sysadm 1.55 }
94     else
95     {
96 sysadm 1.57 ret = check_user(user, password);
97 sysadm 1.55 }
98    
99     if (ret == 0)
100     {
101     return SSH_AUTH_SUCCESS;
102     }
103    
104 sysadm 1.74 if ((++(sdata->tries)) >= BBS_login_retry_times)
105 sysadm 1.55 {
106 sysadm 1.74 sdata->error = 1;
107 sysadm 1.55 }
108    
109     return SSH_AUTH_DENIED;
110     }
111    
112     static int pty_request(ssh_session session, ssh_channel channel, const char *term,
113 sysadm 1.74 int cols, int rows, int px, int py, void *userdata)
114     {
115     struct channel_data_struct *cdata = (struct channel_data_struct *)userdata;
116     int rc;
117    
118     (void)session;
119     (void)channel;
120     (void)term;
121    
122     cdata->winsize->ws_row = (unsigned short int)rows;
123     cdata->winsize->ws_col = (unsigned short int)cols;
124     cdata->winsize->ws_xpixel = (unsigned short int)px;
125     cdata->winsize->ws_ypixel = (unsigned short int)py;
126    
127     rc = openpty(&cdata->pty_master, &cdata->pty_slave, NULL, NULL, cdata->winsize);
128     if (rc != 0)
129     {
130     log_error("Failed to open pty\n");
131     return SSH_ERROR;
132     }
133    
134     return SSH_OK;
135     }
136    
137     static int pty_resize(ssh_session session, ssh_channel channel, int cols, int rows,
138     int py, int px, void *userdata)
139     {
140     struct channel_data_struct *cdata = (struct channel_data_struct *)userdata;
141    
142     (void)session;
143     (void)channel;
144    
145     cdata->winsize->ws_row = (unsigned short int)rows;
146     cdata->winsize->ws_col = (unsigned short int)cols;
147     cdata->winsize->ws_xpixel = (unsigned short int)px;
148     cdata->winsize->ws_ypixel = (unsigned short int)py;
149    
150     if (cdata->pty_master != -1)
151     {
152     return ioctl(cdata->pty_master, TIOCSWINSZ, cdata->winsize);
153     }
154    
155     return SSH_ERROR;
156     }
157    
158     static int exec_pty(const char *mode, const char *command, struct channel_data_struct *cdata)
159     {
160     (void)cdata;
161    
162     if (command != NULL)
163     {
164     log_error("Forbid exec /bin/sh %s %s)\n", mode, command);
165     }
166    
167     return SSH_OK;
168     }
169    
170     static int exec_nopty(const char *command, struct channel_data_struct *cdata)
171     {
172     (void)cdata;
173    
174     if (command != NULL)
175     {
176     log_error("Forbid exec /bin/sh -c %s)\n", command);
177     }
178    
179     return SSH_OK;
180     }
181    
182     static int exec_request(ssh_session session, ssh_channel channel, const char *command, void *userdata)
183 sysadm 1.55 {
184 sysadm 1.74 struct channel_data_struct *cdata = (struct channel_data_struct *)userdata;
185    
186     (void)session;
187     (void)channel;
188    
189     if (cdata->pid > 0)
190     {
191     return SSH_ERROR;
192     }
193    
194     if (cdata->pty_master != -1 && cdata->pty_slave != -1)
195     {
196     return exec_pty("-c", command, cdata);
197     }
198     return exec_nopty(command, cdata);
199 sysadm 1.55 }
200    
201     static int shell_request(ssh_session session, ssh_channel channel, void *userdata)
202     {
203 sysadm 1.74 struct channel_data_struct *cdata = (struct channel_data_struct *)userdata;
204    
205     (void)session;
206     (void)channel;
207    
208     if (cdata->pid > 0)
209     {
210     return SSH_ERROR;
211     }
212    
213     if (cdata->pty_master != -1 && cdata->pty_slave != -1)
214     {
215     return exec_pty("-l", NULL, cdata);
216     }
217     /* Client requested a shell without a pty, let's pretend we allow that */
218     return SSH_OK;
219 sysadm 1.55 }
220    
221 sysadm 1.74 static int subsystem_request(ssh_session session, ssh_channel channel, const char *subsystem, void *userdata)
222     {
223     (void)session;
224     (void)channel;
225    
226     log_error("subsystem_request(subsystem=%s)\n", subsystem);
227    
228     /* subsystem requests behave similarly to exec requests. */
229     if (strcmp(subsystem, "sftp") == 0)
230     {
231     return exec_request(session, channel, SFTP_SERVER_PATH, userdata);
232     }
233     return SSH_ERROR;
234     }
235 sysadm 1.55
236 sysadm 1.74 static ssh_channel channel_open(ssh_session session, void *userdata)
237 sysadm 1.55 {
238 sysadm 1.74 (void)userdata;
239    
240 sysadm 1.55 if (SSH_channel != NULL)
241     {
242     return NULL;
243     }
244    
245     SSH_channel = ssh_channel_new(session);
246    
247     return SSH_channel;
248     }
249    
250 sysadm 1.56 static int fork_server(void)
251 sysadm 1.55 {
252     ssh_event event;
253 sysadm 1.71 long int ssh_timeout = 0;
254 sysadm 1.55 int pid;
255     int i;
256     int ret;
257    
258 sysadm 1.74 /* Structure for storing the pty size. */
259     struct winsize wsize = {
260     .ws_row = 0,
261     .ws_col = 0,
262     .ws_xpixel = 0,
263     .ws_ypixel = 0};
264    
265     /* Our struct holding information about the channel. */
266     struct channel_data_struct cdata = {
267     .pid = 0,
268     .pty_master = -1,
269     .pty_slave = -1,
270     .child_stdin = -1,
271     .child_stdout = -1,
272     .child_stderr = -1,
273     .event = NULL,
274     .winsize = &wsize};
275    
276     struct session_data_struct cb_data = {
277 sysadm 1.55 .tries = 0,
278     .error = 0,
279     };
280    
281 sysadm 1.74 struct ssh_channel_callbacks_struct channel_cb = {
282     .userdata = &cdata,
283     .channel_pty_request_function = pty_request,
284     .channel_pty_window_change_function = pty_resize,
285     .channel_shell_request_function = shell_request,
286     .channel_exec_request_function = exec_request,
287     .channel_subsystem_request_function = subsystem_request};
288    
289     struct ssh_server_callbacks_struct server_cb = {
290 sysadm 1.55 .userdata = &cb_data,
291     .auth_password_function = auth_password,
292 sysadm 1.74 .channel_open_request_session_function = channel_open,
293 sysadm 1.55 };
294    
295     pid = fork();
296    
297     if (pid > 0) // Parent process
298     {
299     SYS_child_process_count++;
300     log_common("Child process (%d) start\n", pid);
301     return pid;
302     }
303     else if (pid < 0) // Error
304     {
305     log_error("fork() error (%d)\n", errno);
306     return -1;
307     }
308    
309     // Child process
310    
311     if (close(socket_server[0]) == -1 || close(socket_server[1]) == -1)
312     {
313     log_error("Close server socket failed\n");
314     }
315    
316     SSH_session = ssh_new();
317    
318     if (SSH_v2)
319     {
320     if (ssh_bind_accept_fd(sshbind, SSH_session, socket_client) != SSH_OK)
321     {
322     log_error("ssh_bind_accept_fd() error: %s\n", ssh_get_error(SSH_session));
323     goto cleanup;
324     }
325    
326     ssh_bind_free(sshbind);
327    
328 sysadm 1.71 ssh_timeout = 60; // second
329     if (ssh_options_set(SSH_session, SSH_OPTIONS_TIMEOUT, &ssh_timeout) < 0)
330     {
331     log_error("Error setting SSH options: %s\n", ssh_get_error(SSH_session));
332     goto cleanup;
333     }
334    
335 sysadm 1.75 ssh_set_auth_methods(SSH_session, SSH_AUTH_METHOD_PASSWORD);
336    
337     ssh_callbacks_init(&server_cb);
338     ssh_callbacks_init(&channel_cb);
339    
340     ssh_set_server_callbacks(SSH_session, &server_cb);
341    
342 sysadm 1.55 if (ssh_handle_key_exchange(SSH_session))
343     {
344     log_error("ssh_handle_key_exchange() error: %s\n", ssh_get_error(SSH_session));
345     goto cleanup;
346     }
347    
348     event = ssh_event_new();
349     ssh_event_add_session(event, SSH_session);
350    
351 sysadm 1.58 for (i = 0; i < SSH_AUTH_MAX_DURATION && !SYS_server_exit && !cb_data.error && SSH_channel == NULL; i += 100)
352 sysadm 1.55 {
353 sysadm 1.58 ret = ssh_event_dopoll(event, 100); // 0.1 second
354 sysadm 1.55 if (ret == SSH_ERROR)
355     {
356 sysadm 1.73 #ifdef _DEBUG
357 sysadm 1.55 log_error("ssh_event_dopoll() error: %s\n", ssh_get_error(SSH_session));
358 sysadm 1.73 #endif
359 sysadm 1.55 goto cleanup;
360     }
361     }
362    
363     if (cb_data.error)
364     {
365     log_error("SSH auth error, tried %d times\n", cb_data.tries);
366     goto cleanup;
367     }
368 sysadm 1.71
369 sysadm 1.74 ssh_set_channel_callbacks(SSH_channel, &channel_cb);
370    
371 sysadm 1.75 do
372     {
373     ret = ssh_event_dopoll(event, 100); // 0.1 second
374     if (ret == SSH_ERROR)
375     {
376     ssh_channel_close(SSH_channel);
377     }
378    
379     if (ret == SSH_AGAIN) // loop until SSH connection is fully established
380     {
381     /* Executed only once, once the child process starts. */
382     cdata.event = event;
383     break;
384     }
385     } while (ssh_channel_is_open(SSH_channel));
386    
387 sysadm 1.71 ssh_timeout = 0;
388     if (ssh_options_set(SSH_session, SSH_OPTIONS_TIMEOUT, &ssh_timeout) < 0)
389     {
390     log_error("Error setting SSH options: %s\n", ssh_get_error(SSH_session));
391     goto cleanup;
392     }
393 sysadm 1.55 }
394    
395     // Redirect Input
396     if (dup2(socket_client, STDIN_FILENO) == -1)
397     {
398     log_error("Redirect stdin to client socket failed\n");
399     goto cleanup;
400     }
401    
402     // Redirect Output
403     if (dup2(socket_client, STDOUT_FILENO) == -1)
404     {
405     log_error("Redirect stdout to client socket failed\n");
406     goto cleanup;
407     }
408    
409     SYS_child_process_count = 0;
410    
411     bbs_main();
412    
413     cleanup:
414     // Child process exit
415     SYS_server_exit = 1;
416    
417     if (SSH_v2)
418     {
419 sysadm 1.74 close(cdata.pty_master);
420     close(cdata.child_stdin);
421     close(cdata.child_stdout);
422     close(cdata.child_stderr);
423    
424 sysadm 1.55 ssh_channel_free(SSH_channel);
425     ssh_disconnect(SSH_session);
426     }
427     else if (close(socket_client) == -1)
428     {
429     log_error("Close client socket failed\n");
430     }
431    
432     ssh_free(SSH_session);
433     ssh_finalize();
434    
435     // Close Input and Output for client
436     close(STDIN_FILENO);
437     close(STDOUT_FILENO);
438    
439     log_common("Process exit normally\n");
440     log_end();
441    
442     _exit(0);
443    
444     return 0;
445     }
446    
447 sysadm 1.52 int net_server(const char *hostaddr, in_port_t port[])
448 sysadm 1.1 {
449 sysadm 1.82 HASH_DICT *hash_dict_pid_sockaddr = NULL;
450     HASH_DICT *hash_dict_sockaddr_count = NULL;
451    
452 sysadm 1.52 unsigned int addrlen;
453 sysadm 1.19 int ret;
454 sysadm 1.52 int flags[2];
455 sysadm 1.13 struct sockaddr_in sin;
456 sysadm 1.25 struct epoll_event ev, events[MAX_EVENTS];
457     int nfds, epollfd;
458 sysadm 1.19 siginfo_t siginfo;
459 sysadm 1.70 int notify_child_exit = 0;
460     time_t tm_notify_child_exit = time(NULL);
461 sysadm 1.31 int sd_notify_stopping = 0;
462 sysadm 1.66 MENU_SET bbs_menu_new;
463 sysadm 1.72 MENU_SET top10_menu_new;
464 sysadm 1.44 int i, j;
465     pid_t pid;
466 sysadm 1.51 int ssh_log_level = SSH_LOG_NOLOG;
467 sysadm 1.10
468 sysadm 1.51 ssh_init();
469    
470     sshbind = ssh_bind_new();
471    
472     if (ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_BINDADDR, hostaddr) < 0 ||
473     ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_BINDPORT, &port) < 0 ||
474     ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_HOSTKEY, SSH_HOST_KEYFILE) < 0 ||
475 sysadm 1.63 ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_HOSTKEY_ALGORITHMS, "ssh-rsa,rsa-sha2-512,rsa-sha2-256") < 0 ||
476 sysadm 1.51 ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_LOG_VERBOSITY, &ssh_log_level) < 0)
477     {
478     log_error("Error setting SSH bind options: %s\n", ssh_get_error(sshbind));
479     ssh_bind_free(sshbind);
480     return -1;
481     }
482 sysadm 1.10
483 sysadm 1.52 epollfd = epoll_create1(0);
484     if (epollfd < 0)
485 sysadm 1.13 {
486 sysadm 1.52 log_error("epoll_create1() error (%d)\n", errno);
487 sysadm 1.27 return -1;
488 sysadm 1.13 }
489 sysadm 1.10
490 sysadm 1.52 // Server socket
491     for (i = 0; i < 2; i++)
492 sysadm 1.23 {
493 sysadm 1.52 socket_server[i] = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
494 sysadm 1.23
495 sysadm 1.52 if (socket_server[i] < 0)
496     {
497     log_error("Create socket_server error (%d)\n", errno);
498     return -1;
499     }
500 sysadm 1.10
501 sysadm 1.52 sin.sin_family = AF_INET;
502     sin.sin_addr.s_addr = (hostaddr[0] != '\0' ? inet_addr(hostaddr) : INADDR_ANY);
503     sin.sin_port = htons(port[i]);
504    
505     // Reuse address and port
506     flags[i] = 1;
507     if (setsockopt(socket_server[i], SOL_SOCKET, SO_REUSEADDR, &flags[i], sizeof(flags[i])) < 0)
508     {
509     log_error("setsockopt SO_REUSEADDR error (%d)\n", errno);
510     }
511     if (setsockopt(socket_server[i], SOL_SOCKET, SO_REUSEPORT, &flags[i], sizeof(flags[i])) < 0)
512     {
513     log_error("setsockopt SO_REUSEPORT error (%d)\n", errno);
514     }
515 sysadm 1.1
516 sysadm 1.52 if (bind(socket_server[i], (struct sockaddr *)&sin, sizeof(sin)) < 0)
517     {
518     log_error("Bind address %s:%u error (%d)\n",
519     inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), errno);
520     return -1;
521     }
522 sysadm 1.16
523 sysadm 1.52 if (listen(socket_server[i], 10) < 0)
524     {
525     log_error("Telnet socket listen error (%d)\n", errno);
526     return -1;
527     }
528 sysadm 1.13
529 sysadm 1.52 log_common("Listening at %s:%u\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
530 sysadm 1.25
531 sysadm 1.52 ev.events = EPOLLIN;
532     ev.data.fd = socket_server[i];
533     if (epoll_ctl(epollfd, EPOLL_CTL_ADD, socket_server[i], &ev) == -1)
534 sysadm 1.30 {
535 sysadm 1.52 log_error("epoll_ctl(socket_server[%d]) error (%d)\n", i, errno);
536     if (close(epollfd) < 0)
537     {
538     log_error("close(epoll) error (%d)\n");
539     }
540     return -1;
541 sysadm 1.30 }
542 sysadm 1.52
543     flags[i] = fcntl(socket_server[i], F_GETFL, 0);
544     fcntl(socket_server[i], F_SETFL, flags[i] | O_NONBLOCK);
545 sysadm 1.25 }
546    
547 sysadm 1.82 hash_dict_pid_sockaddr = hash_dict_create(MAX_CLIENT_LIMIT);
548     if (hash_dict_pid_sockaddr == NULL)
549     {
550     log_error("hash_dict_create(hash_dict_pid_sockaddr) error\n");
551     return -1;
552     }
553     hash_dict_sockaddr_count = hash_dict_create(MAX_CLIENT_LIMIT);
554     if (hash_dict_sockaddr_count == NULL)
555     {
556     log_error("hash_dict_create(hash_dict_sockaddr_count) error\n");
557     return -1;
558     }
559    
560 sysadm 1.31 // Startup complete
561     sd_notifyf(0, "READY=1\n"
562 sysadm 1.52 "STATUS=Listening at %s:%d (Telnet) and %s:%d (SSH2)\n"
563 sysadm 1.31 "MAINPID=%d",
564 sysadm 1.52 hostaddr, port[0], hostaddr, port[1], getpid());
565 sysadm 1.31
566 sysadm 1.19 while (!SYS_server_exit || SYS_child_process_count > 0)
567 sysadm 1.13 {
568 sysadm 1.31 if (SYS_server_exit && !sd_notify_stopping)
569     {
570     sd_notify(0, "STOPPING=1");
571     sd_notify_stopping = 1;
572     }
573 sysadm 1.37
574 sysadm 1.22 while ((SYS_child_exit || SYS_server_exit) && SYS_child_process_count > 0)
575 sysadm 1.19 {
576 sysadm 1.30 SYS_child_exit = 0;
577    
578 sysadm 1.19 siginfo.si_pid = 0;
579     ret = waitid(P_ALL, 0, &siginfo, WEXITED | WNOHANG);
580     if (ret == 0 && siginfo.si_pid > 0)
581     {
582 sysadm 1.30 SYS_child_exit = 1; // Retry waitid
583    
584 sysadm 1.19 SYS_child_process_count--;
585 sysadm 1.49 log_common("Child process (%d) exited\n", siginfo.si_pid);
586 sysadm 1.44
587 sysadm 1.45 if (siginfo.si_pid != section_list_loader_pid)
588 sysadm 1.44 {
589 sysadm 1.82 j = 0;
590     ret = hash_dict_get(hash_dict_pid_sockaddr, (uint64_t)siginfo.si_pid, (int64_t *)&j);
591     if (ret < 0)
592     {
593     log_error("hash_dict_get(hash_dict_pid_sockaddr, %d) error\n", siginfo.si_pid);
594     }
595     else
596 sysadm 1.44 {
597 sysadm 1.82 sin.sin_addr.s_addr = (uint32_t)j;
598     j = 0;
599     ret = hash_dict_get(hash_dict_sockaddr_count, sin.sin_addr.s_addr, (int64_t *)&j);
600     if (ret < 0)
601     {
602     log_error("hash_dict_get(hash_dict_sockaddr_count, %d) error\n", sin.sin_addr.s_addr);
603     }
604     else if (ret == 0)
605     {
606     log_error("hash_dict_get(hash_dict_sockaddr_count, %d) not found\n", sin.sin_addr.s_addr);
607     j = 1;
608     }
609    
610     j--;
611     ret = hash_dict_set(hash_dict_sockaddr_count, sin.sin_addr.s_addr, j);
612     if (ret < 0)
613     {
614     log_error("hash_dict_set(hash_dict_sockaddr_count, %d, %d) error\n", sin.sin_addr.s_addr, j);
615     }
616    
617     ret = hash_dict_del(hash_dict_pid_sockaddr, (uint64_t)siginfo.si_pid);
618     if (ret < 0)
619 sysadm 1.45 {
620 sysadm 1.82 log_error("hash_dict_del(hash_dict_pid_sockaddr, %d) error\n", siginfo.si_pid);
621 sysadm 1.45 }
622     }
623 sysadm 1.44 }
624 sysadm 1.19 }
625     else if (ret == 0)
626     {
627     break;
628     }
629     else if (ret < 0)
630     {
631     log_error("Error in waitid: %d\n", errno);
632     break;
633     }
634     }
635    
636 sysadm 1.22 if (SYS_server_exit && !SYS_child_exit && SYS_child_process_count > 0)
637 sysadm 1.21 {
638 sysadm 1.70 if (notify_child_exit == 0)
639 sysadm 1.21 {
640 sysadm 1.70 sd_notifyf(0, "STATUS=Notify %d child process to exit", SYS_child_process_count);
641     log_common("Notify %d child process to exit\n", SYS_child_process_count);
642    
643 sysadm 1.82 if (kill(-getpid(), SIGTERM) < 0)
644 sysadm 1.70 {
645     log_error("Send SIGTERM signal failed (%d)\n", errno);
646     }
647    
648     notify_child_exit = 1;
649     tm_notify_child_exit = time(NULL);
650 sysadm 1.21 }
651 sysadm 1.70 else if (notify_child_exit == 1 && time(NULL) - tm_notify_child_exit >= WAIT_CHILD_PROCESS_EXIT_TIMEOUT)
652     {
653     sd_notifyf(0, "STATUS=Kill %d child process", SYS_child_process_count);
654 sysadm 1.31
655 sysadm 1.82 if (kill(-getpid(), SIGKILL) < 0)
656 sysadm 1.70 {
657 sysadm 1.82 log_error("Send SIGKILL signal failed (%d)\n", errno);
658 sysadm 1.70 }
659 sysadm 1.69
660 sysadm 1.70 notify_child_exit = 2;
661     tm_notify_child_exit = time(NULL);
662     }
663     else if (notify_child_exit == 2 && time(NULL) - tm_notify_child_exit >= WAIT_CHILD_PROCESS_KILL_TIMEOUT)
664     {
665     log_error("Main process prepare to exit without waiting for %d child process any longer\n", SYS_child_process_count);
666     SYS_child_process_count = 0;
667     }
668 sysadm 1.21 }
669    
670 sysadm 1.44 if (SYS_conf_reload && !SYS_server_exit)
671 sysadm 1.19 {
672 sysadm 1.44 SYS_conf_reload = 0;
673 sysadm 1.37 sd_notify(0, "RELOADING=1");
674 sysadm 1.30
675 sysadm 1.84 // Restart log
676     if (log_restart() < 0)
677     {
678     log_error("Restart logging failed\n");
679     }
680    
681 sysadm 1.44 // Reload configuration
682     if (load_conf(CONF_BBSD) < 0)
683     {
684     log_error("Reload conf failed\n");
685     }
686    
687 sysadm 1.80 // Reload BWF config
688     if (bwf_load(CONF_BWF) < 0)
689     {
690     log_error("Reload BWF conf failed\n");
691     }
692    
693 sysadm 1.68 if (load_menu(&bbs_menu_new, CONF_MENU) < 0)
694 sysadm 1.34 {
695 sysadm 1.68 unload_menu(&bbs_menu_new);
696 sysadm 1.72 log_error("Reload bbs menu failed\n");
697 sysadm 1.19 }
698     else
699     {
700 sysadm 1.68 unload_menu(&bbs_menu);
701     memcpy(&bbs_menu, &bbs_menu_new, sizeof(bbs_menu_new));
702 sysadm 1.72 log_common("Reload bbs menu successfully\n");
703     }
704    
705     if (load_menu(&top10_menu_new, CONF_TOP10_MENU) < 0)
706     {
707     unload_menu(&top10_menu_new);
708     log_error("Reload top10 menu failed\n");
709     }
710     else
711     {
712     unload_menu(&top10_menu);
713     top10_menu_new.allow_exit = 1;
714     memcpy(&top10_menu, &top10_menu_new, sizeof(top10_menu_new));
715     log_common("Reload top10 menu successfully\n");
716 sysadm 1.19 }
717 sysadm 1.37
718 sysadm 1.35 for (int i = 0; i < data_files_load_startup_count; i++)
719     {
720 sysadm 1.39 if (load_file(data_files_load_startup[i]) < 0)
721 sysadm 1.35 {
722 sysadm 1.76 log_error("load_file(%s) error\n", data_files_load_startup[i]);
723 sysadm 1.35 }
724     }
725 sysadm 1.49 log_common("Reload data files successfully\n");
726 sysadm 1.35
727 sysadm 1.68 // Load section config and gen_ex
728     if (load_section_config_from_db(1) < 0)
729     {
730     log_error("load_section_config_from_db(1) error\n");
731     }
732     else
733 sysadm 1.42 {
734 sysadm 1.68 log_common("Reload section config and gen_ex successfully\n");
735 sysadm 1.42 }
736 sysadm 1.68
737 sysadm 1.84 // Notify child processes to reload configuration
738     if (kill(-getpid(), SIGUSR1) < 0)
739     {
740     log_error("Send SIGUSR1 signal failed (%d)\n", errno);
741     }
742    
743 sysadm 1.68 sd_notify(0, "READY=1");
744 sysadm 1.42 }
745    
746 sysadm 1.25 nfds = epoll_wait(epollfd, events, MAX_EVENTS, 100); // 0.1 second
747 sysadm 1.22
748 sysadm 1.25 if (nfds < 0)
749 sysadm 1.19 {
750     if (errno != EINTR)
751     {
752 sysadm 1.25 log_error("epoll_wait() error (%d)\n", errno);
753     break;
754 sysadm 1.19 }
755     continue;
756     }
757 sysadm 1.13
758 sysadm 1.19 // Stop accept new connection on exit
759     if (SYS_server_exit)
760 sysadm 1.13 {
761     continue;
762     }
763    
764 sysadm 1.25 for (int i = 0; i < nfds; i++)
765 sysadm 1.13 {
766 sysadm 1.52 if (events[i].data.fd == socket_server[0] || events[i].data.fd == socket_server[1])
767 sysadm 1.13 {
768 sysadm 1.53 SSH_v2 = (events[i].data.fd == socket_server[1] ? 1 : 0);
769 sysadm 1.52
770 sysadm 1.29 while (!SYS_server_exit) // Accept all incoming connections until error
771 sysadm 1.13 {
772 sysadm 1.52 addrlen = sizeof(sin);
773 sysadm 1.53 socket_client = accept(socket_server[SSH_v2], (struct sockaddr *)&sin, &addrlen);
774 sysadm 1.25 if (socket_client < 0)
775     {
776 sysadm 1.28 if (errno == EAGAIN || errno == EWOULDBLOCK)
777     {
778     break;
779     }
780     else if (errno == EINTR)
781     {
782     continue;
783     }
784     else
785 sysadm 1.25 {
786     log_error("accept(socket_server) error (%d)\n", errno);
787 sysadm 1.28 break;
788 sysadm 1.25 }
789     }
790    
791     strncpy(hostaddr_client, inet_ntoa(sin.sin_addr), sizeof(hostaddr_client) - 1);
792     hostaddr_client[sizeof(hostaddr_client) - 1] = '\0';
793    
794     port_client = ntohs(sin.sin_port);
795    
796 sysadm 1.64 log_common("Accept %s connection from %s:%d\n", (SSH_v2 ? "SSH" : "telnet"), hostaddr_client, port_client);
797 sysadm 1.25
798 sysadm 1.43 if (SYS_child_process_count - 1 < BBS_max_client)
799 sysadm 1.25 {
800 sysadm 1.44 j = 0;
801 sysadm 1.82 ret = hash_dict_get(hash_dict_sockaddr_count, (uint64_t)sin.sin_addr.s_addr, (int64_t *)&j);
802     if (ret < 0)
803 sysadm 1.44 {
804 sysadm 1.82 log_error("hash_dict_get(hash_dict_sockaddr_count, %s) error\n", hostaddr_client);
805 sysadm 1.44 }
806    
807     if (j < BBS_max_client_per_ip)
808 sysadm 1.43 {
809 sysadm 1.52 if ((pid = fork_server()) < 0)
810 sysadm 1.44 {
811     log_error("fork_server() error\n");
812     }
813     else if (pid > 0)
814     {
815 sysadm 1.82 ret = hash_dict_set(hash_dict_pid_sockaddr, (uint64_t)pid, sin.sin_addr.s_addr);
816     if (ret < 0)
817 sysadm 1.44 {
818 sysadm 1.82 log_error("hash_dict_set(hash_dict_pid_sockaddr, %d, %s) error\n", pid, hostaddr_client);
819 sysadm 1.44 }
820    
821 sysadm 1.82 ret = hash_dict_set(hash_dict_sockaddr_count, (uint64_t)sin.sin_addr.s_addr, j + 1);
822     if (ret < 0)
823 sysadm 1.44 {
824 sysadm 1.82 log_error("hash_dict_set(hash_dict_sockaddr_count, %s, %d) error\n", hostaddr_client, j + 1);
825 sysadm 1.44 }
826     }
827 sysadm 1.43 }
828 sysadm 1.82 else
829     {
830     log_error("Rejected client connection from %s over limit per IP (%d)\n", hostaddr_client, BBS_max_client_per_ip);
831     }
832 sysadm 1.43 }
833     else
834     {
835     log_error("Rejected client connection over limit (%d)\n", SYS_child_process_count - 1);
836 sysadm 1.25 }
837    
838     if (close(socket_client) == -1)
839     {
840     log_error("close(socket_lient) error (%d)\n", errno);
841     }
842 sysadm 1.13 }
843     }
844     }
845 sysadm 1.25 }
846 sysadm 1.13
847 sysadm 1.30 if (close(epollfd) < 0)
848     {
849     log_error("close(epoll) error (%d)\n");
850     }
851    
852 sysadm 1.52 for (i = 0; i < 2; i++)
853     {
854     fcntl(socket_server[i], F_SETFL, flags[i]);
855 sysadm 1.13
856 sysadm 1.52 if (close(socket_server[i]) == -1)
857     {
858     log_error("Close server socket failed\n");
859     }
860 sysadm 1.13 }
861 sysadm 1.7
862 sysadm 1.82 hash_dict_destroy(hash_dict_pid_sockaddr);
863     hash_dict_destroy(hash_dict_sockaddr_count);
864    
865 sysadm 1.51 ssh_bind_free(sshbind);
866     ssh_finalize();
867    
868 sysadm 1.13 return 0;
869 sysadm 1.1 }
webmaster@leafok.com
 ViewVC Help
Powered by ViewVC 1.3.0-beta1