masqmail

view src/listen.c @ 231:9a94124096c9

find changesets by author, revision, files, or words in the commit message
Added tag 0.3.0 for changeset 4f999b3ee49d
author meillo@marmaro.de
date Mon, 26 Jul 2010 21:54:30 +0200
parents 5745edd5b769
children fc1c6425c024
line source
1 /* MasqMail
2 Copyright (C) 1999/2000 Oliver Kurth
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19 #include <sys/wait.h>
20 #include <sys/types.h>
21
22 #include "masqmail.h"
23
24 static int volatile sighup_seen = 0;
25
26 static void
27 sighup_handler(int sig)
28 {
29 sighup_seen = 1;
30 signal(SIGHUP, sighup_handler);
31 }
32
33 static void
34 sigchld_handler(int sig)
35 {
36 pid_t pid;
37 int status;
38
39 pid = waitpid(0, &status, 0);
40 if (pid > 0) {
41 if (WEXITSTATUS(status) != EXIT_SUCCESS)
42 logwrite(LOG_WARNING, "process %d exited with %d\n", pid, WEXITSTATUS(status));
43 if (WIFSIGNALED(status))
44 logwrite(LOG_WARNING, "process with pid %d got signal: %d\n", pid, WTERMSIG(status));
45 }
46 signal(SIGCHLD, sigchld_handler);
47 }
48
49 void
50 accept_connect(int listen_sock, int sock, struct sockaddr_in *sock_addr)
51 {
52 pid_t pid;
53 int dup_sock = dup(sock);
54 FILE *out, *in;
55 gchar *rem_host;
56 gchar *ident = NULL;
57
58 rem_host = g_strdup(inet_ntoa(sock_addr->sin_addr));
59 #ifdef ENABLE_IDENT
60 {
61 gchar *id = NULL;
62 if ((id = (gchar *) ident_id(sock, 60))) {
63 ident = g_strdup(id);
64 }
65 logwrite(LOG_NOTICE, "connect from host %s, port %hd ident=%s\n", rem_host,
66 ntohs(sock_addr->sin_port), ident ? ident : "(unknown)");
67 }
68 #else
69 logwrite(LOG_NOTICE, "connect from host %s, port %hd\n", rem_host, ntohs(sock_addr->sin_port));
70 #endif
71
72 /* start child for connection: */
73 signal(SIGCHLD, sigchld_handler);
74 pid = fork();
75 if (pid == 0) {
76 close(listen_sock);
77 out = fdopen(sock, "w");
78 in = fdopen(dup_sock, "r");
79
80 smtp_in(in, out, rem_host, ident);
81
82 _exit(EXIT_SUCCESS);
83 } else if (pid < 0) {
84 logwrite(LOG_WARNING, "could not fork for incoming smtp connection: %s\n", strerror(errno));
85 }
86 #ifdef ENABLE_IDENT
87 if (ident != NULL)
88 g_free(ident);
89 #endif
90
91 close(sock);
92 close(dup_sock);
93 }
94
95 void
96 listen_port(GList * iface_list, gint qival, char *argv[])
97 {
98 int i;
99 fd_set active_fd_set, read_fd_set;
100 struct timeval tm;
101 time_t time_before, time_now;
102 struct sockaddr_in clientname;
103 size_t size;
104 GList *node, *node_next;
105 int sel_ret;
106
107 /* Create the sockets and set them up to accept connections. */
108 FD_ZERO(&active_fd_set);
109 for (node = g_list_first(iface_list); node; node = node_next) {
110 interface *iface = (interface *) (node->data);
111 int sock;
112
113 node_next = g_list_next(node);
114 if ((sock = make_server_socket(iface)) < 0) {
115 iface_list = g_list_remove_link(iface_list, node);
116 g_list_free_1(node);
117 continue;
118 }
119 if (listen(sock, 1) < 0) {
120 logwrite(LOG_ALERT, "listen: (terminating): %s\n", strerror(errno));
121 exit(EXIT_FAILURE);
122 }
123 logwrite(LOG_NOTICE, "listening on interface %s:%d\n", iface->address, iface->port);
124 DEBUG(5) debugf("sock = %d\n", sock);
125 FD_SET(sock, &active_fd_set);
126 }
127
128 /* setup handler for HUP signal: */
129 signal(SIGHUP, sighup_handler);
130 signal(SIGCHLD, sigchld_handler);
131
132 /* now that we have our socket(s), we can give up root privileges */
133 if (!conf.run_as_user) {
134 if (setegid(conf.mail_gid) != 0) {
135 logwrite(LOG_ALERT, "could not change gid to %d: %s\n", conf.mail_gid, strerror(errno));
136 exit(EXIT_FAILURE);
137 }
138 if (seteuid(conf.mail_uid) != 0) {
139 logwrite(LOG_ALERT, "could not change uid to %d: %s\n", conf.mail_uid, strerror(errno));
140 exit(EXIT_FAILURE);
141 }
142 }
143
144 /* sel_ret = 0; */
145 time(&time_before);
146 time_before -= qival;
147 sel_ret = -1;
148
149 while (1) {
150
151 /* if we were interrupted by an incoming connection (or a signal)
152 we have to recalculate the time until the next queue run should
153 occur. select may put a value into tm, but doc for select() says
154 we should not use it. */
155 if (qival > 0) {
156 time(&time_now);
157 if (sel_ret == 0) { /* we are either just starting or did a queue run */
158 tm.tv_sec = qival;
159 tm.tv_usec = 0;
160 time_before = time_now;
161 } else {
162 tm.tv_sec = qival - (time_now - time_before);
163 tm.tv_usec = 0;
164
165 /* race condition, very unlikely (but possible): */
166 if (tm.tv_sec < 0)
167 tm.tv_sec = 0;
168 }
169 }
170 /* Block until input arrives on one or more active sockets,
171 or signal arrives, or queuing interval time elapsed (if qival > 0) */
172 read_fd_set = active_fd_set;
173 if ((sel_ret = select(FD_SETSIZE, &read_fd_set, NULL, NULL, qival > 0 ? &tm : NULL)) < 0) {
174 if (errno != EINTR) {
175 logwrite(LOG_ALERT, "select: (terminating): %s\n", strerror(errno));
176 exit(EXIT_FAILURE);
177 } else {
178 if (sighup_seen) {
179 logwrite(LOG_NOTICE, "HUP signal received. Restarting daemon\n");
180
181 for (i = 0; i < FD_SETSIZE; i++)
182 if (FD_ISSET(i, &active_fd_set))
183 close(i);
184
185 execv(argv[0], &(argv[0]));
186 logwrite(LOG_ALERT, "restarting failed: %s\n", strerror(errno));
187 exit(EXIT_FAILURE);
188 }
189 }
190 } else if (sel_ret > 0) {
191 for (i = 0; i < FD_SETSIZE; i++) {
192 if (FD_ISSET(i, &read_fd_set)) {
193 int sock = i;
194 int new;
195 size = sizeof(clientname);
196 new = accept(sock, (struct sockaddr *) &clientname, &size);
197 if (new < 0) {
198 logwrite(LOG_ALERT, "accept: (ignoring): %s\n", strerror(errno));
199 } else
200 accept_connect(sock, new, &clientname);
201 }
202 }
203 } else {
204 /* If select returns 0, the interval time has elapsed.
205 We start a new queue runner process */
206 int pid;
207 signal(SIGCHLD, sigchld_handler);
208 if ((pid = fork()) == 0) {
209 queue_run();
210
211 _exit(EXIT_SUCCESS);
212 } else if (pid < 0) {
213 logwrite(LOG_ALERT, "could not fork for queue run");
214 }
215 }
216 }
217 }