1 /******************************************************************************/
2 /* */
3 /* Copyright (c) International Business Machines Corp., 2005 */
4 /* */
5 /* This program is free software; you can redistribute it and/or modify */
6 /* it under the terms of the GNU General Public License as published by */
7 /* the Free Software Foundation; either version 2 of the License, or */
8 /* (at your option) 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 */
13 /* the 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 USA */
18 /* */
19 /******************************************************************************/
20
21 /*
22 * File:
23 * ns-udpserver.c
24 *
25 * Description:
26 * This is UDP traffic server.
27 * Received UDP datagram from a client, then send it to the client
28 *
29 * Author:
30 * Mitsuru Chinen <mitch@jp.ibm.com>
31 *
32 * History:
33 * Oct 19 2005 - Created (Mitsuru Chinen)
34 *---------------------------------------------------------------------------*/
35
36 #include "ns-traffic.h"
37
38 /*
39 * Standard Include Files
40 */
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <errno.h>
45 #include <fcntl.h>
46 #include <netdb.h>
47 #include <time.h>
48 #include <unistd.h>
49 #include <sys/select.h>
50 #include <sys/socket.h>
51 #include <sys/stat.h>
52 #include <sys/types.h>
53 #include <sys/wait.h>
54 #include <netinet/in.h>
55
56 /*
57 * Gloval variables
58 */
59 struct sigaction handler; /* Behavior for a signal */
60 int catch_sighup; /* When catch the SIGHUP, set to non-zero */
61
62 /*
63 * Function: usage()
64 *
65 * Descripton:
66 * Print the usage of this program. Then, terminate this program with
67 * the specified exit value.
68 *
69 * Argument:
70 * exit_value: exit value
71 *
72 * Return value:
73 * This function does not return.
74 */
usage(char * program_name,int exit_value)75 void usage(char *program_name, int exit_value)
76 {
77 FILE *stream = stdout; /* stream where the usage is output */
78
79 if (exit_value == EXIT_FAILURE)
80 stream = stderr;
81
82 fprintf(stream, "%s [OPTION]\n"
83 "\t-f\tprotocol family\n"
84 "\t\t 4 : IPv4\n"
85 "\t\t 6 : IPv6\n"
86 "\t-p\tport number\n"
87 "\t\tthe port number specified by -p option would be the first port number\n"
88 "\t-b\twork in the background\n"
89 "\t-o\tfilename where the server infomation is outputted\n"
90 "\t-d\twork in the debug mode\n"
91 "\t-h\tdisplay this usage\n"
92 "" "*) Server works till it receives SIGHUP\n", program_name);
93 exit(exit_value);
94 }
95
96 /*
97 * Function: set_signal_flag()
98 *
99 * Description:
100 * This function sets global variable according to the signal.
101 * Once a signal is caught, the signal is ignored after that.
102 *
103 * Argument:
104 * type: type of signal
105 *
106 * Return value:
107 * None
108 */
set_signal_flag(int type)109 void set_signal_flag(int type)
110 {
111 /* Set SIG_IGN against the caught signal */
112 handler.sa_handler = SIG_IGN;
113 if (sigaction(type, &handler, NULL) < 0)
114 fatal_error("sigaction()");
115
116 if (debug)
117 fprintf(stderr, "Catch signal. type is %d\n", type);
118
119 switch (type) {
120 case SIGHUP:
121 catch_sighup = 1;
122 break;
123 default:
124 fprintf(stderr, "Unexpected signal (%d) is caught\n", type);
125 exit(EXIT_FAILURE);
126 }
127 }
128
129 /*
130 * Function: respond_to_client()
131 *
132 * Description:
133 * Recieve the client data. Then, return the data to client.
134 *
135 * Argument:
136 * sock_fd: socket file descriptor
137 *
138 * Return value:
139 * None
140 */
respond_to_client(sock_fd)141 void respond_to_client(sock_fd)
142 {
143 char *msgbuf; /* Pointer to the message */
144 size_t msgbuf_size; /* size of msgbuf */
145 ssize_t msglen; /* the length of message */
146 socklen_t sock_optlen; /* size of the result parameter */
147 struct sockaddr_storage client_addr; /* address of a client */
148 socklen_t client_addr_len; /* length of `client_addr' */
149
150 sock_optlen = sizeof(sock_optlen);
151 if (getsockopt(sock_fd, SOL_SOCKET, SO_RCVBUF,
152 &msgbuf_size, &sock_optlen) < 0) {
153 perror("getsockopt()");
154 close(sock_fd);
155 exit(EXIT_FAILURE);
156 }
157
158 /* Allocate the memory for a message */
159 msgbuf = malloc(msgbuf_size + 1);
160 if (msgbuf == NULL) {
161 fprintf(stderr, "malloc() is failed.\n");
162 close(sock_fd);
163 exit(EXIT_FAILURE);
164 }
165
166 /* Receive a message */
167 client_addr_len = sizeof(client_addr);
168 if ((msglen = recvfrom(sock_fd, msgbuf, msgbuf_size, 0,
169 (struct sockaddr *)&client_addr,
170 &client_addr_len)) < 0)
171 fatal_error("recvfrom()");
172 msgbuf[msglen] = '\0';
173
174 if (debug)
175 fprintf(stderr, "Message is %s\n", msgbuf);
176
177 /* Return the message to the client */
178 if (sendto(sock_fd, msgbuf, msglen, 0,
179 (struct sockaddr *)&client_addr,
180 sizeof(client_addr)) != msglen)
181 fatal_error("sendto()");
182 free(msgbuf);
183 }
184
185 /*
186 *
187 * Function: main()
188 *
189 */
main(int argc,char * argv[])190 int main(int argc, char *argv[])
191 {
192 char *program_name = argv[0];
193 int optc; /* option */
194 sa_family_t family; /* protocol family */
195 char *portnum = NULL; /* port number */
196 int sock_fd; /* socket binded open ports */
197 int background = 0; /* work in the background if non-zero */
198 fd_set read_fds; /* list of file descriptor for reading */
199 int max_read_fd = 0; /* maximum number in the read fds */
200 FILE *info_fp = stdout; /* FILE pointer to a information file */
201 int on; /* on/off at an socket option */
202 int err; /* return value of getaddrinfo */
203 struct addrinfo hints; /* hints for getaddrinfo() */
204 struct addrinfo *res; /* pointer to addrinfo */
205
206 debug = 0;
207 family = PF_UNSPEC;
208
209 /* Retrieve the options */
210 while ((optc = getopt(argc, argv, "f:p:bo:dh")) != EOF) {
211 switch (optc) {
212 case 'f':
213 if (strncmp(optarg, "4", 1) == 0)
214 family = PF_INET; /* IPv4 */
215 else if (strncmp(optarg, "6", 1) == 0)
216 family = PF_INET6; /* IPv6 */
217 else {
218 fprintf(stderr,
219 "protocol family should be 4 or 6.\n");
220 usage(program_name, EXIT_FAILURE);
221 }
222 break;
223
224 case 'p':
225 {
226 unsigned long int num;
227 num = strtoul(optarg, NULL, 0);
228 if (num < PORTNUMMIN || PORTNUMMAX < num) {
229 fprintf(stderr,
230 "The range of port is from %u to %u\n",
231 PORTNUMMIN, PORTNUMMAX);
232 usage(program_name, EXIT_FAILURE);
233 }
234 portnum = strdup(optarg);
235 }
236 break;
237
238 case 'b':
239 background = 1;
240 break;
241
242 case 'o':
243 if ((info_fp = fopen(optarg, "w")) == NULL) {
244 fprintf(stderr, "Cannot open %s\n", optarg);
245 exit(EXIT_FAILURE);
246 }
247 break;
248
249 case 'd':
250 debug = 1;
251 break;
252
253 case 'h':
254 usage(program_name, EXIT_SUCCESS);
255 break;
256
257 default:
258 usage(program_name, EXIT_FAILURE);
259 }
260 }
261
262 /* Check the family is spefied. */
263 if (family == PF_UNSPEC) {
264 fprintf(stderr, "protocol family should be specified.\n");
265 usage(program_name, EXIT_FAILURE);
266 }
267
268 /* At first, SIGHUP is ignored. */
269 handler.sa_handler = SIG_IGN;
270 if (sigfillset(&handler.sa_mask) < 0)
271 fatal_error("sigfillset()");
272 handler.sa_flags = 0;
273
274 if (sigaction(SIGHUP, &handler, NULL) < 0)
275 fatal_error("sigaction()");
276
277 /* Set the hints to addrinfo() */
278 memset(&hints, '\0', sizeof(struct addrinfo));
279 hints.ai_family = family;
280 hints.ai_socktype = SOCK_DGRAM;
281 hints.ai_protocol = IPPROTO_UDP;
282 hints.ai_flags = AI_PASSIVE;
283
284 /* Translate the network and service information of the server */
285 err = getaddrinfo(NULL, portnum, &hints, &res);
286 if (err) {
287 fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(err));
288 exit(EXIT_FAILURE);
289 }
290 if (res->ai_next) {
291 fprintf(stderr, "getaddrinfo(): multiple address is found.");
292 exit(EXIT_FAILURE);
293 }
294
295 /* Create a socket for listening. */
296 sock_fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
297 if (sock_fd < 0)
298 fatal_error("socket()");
299
300 #ifdef IPV6_V6ONLY
301 /* Don't accept IPv4 mapped address if the protocol family is IPv6 */
302 if (res->ai_family == PF_INET6) {
303 on = 1;
304 if (setsockopt
305 (sock_fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(int)))
306 fatal_error("setsockopt()");
307 }
308 #endif
309
310 /* Enable to reuse the socket */
311 on = 1;
312 if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int)))
313 fatal_error("setsockopt()");
314
315 /* Bind to the local address */
316 if (bind(sock_fd, res->ai_addr, res->ai_addrlen) < 0)
317 fatal_error("bind()");
318
319 freeaddrinfo(res);
320
321 /* If -b option is specified, work as a daemon */
322 if (background)
323 if (daemon(0, 0) < 0)
324 fatal_error("daemon()");
325
326 /* Output any server information to the information file */
327 fprintf(info_fp, "PID: %u\n", getpid());
328 fflush(info_fp);
329 if (info_fp != stdout)
330 if (fclose(info_fp))
331 fatal_error("fclose()");
332
333 /* Catch SIGHUP */
334 handler.sa_handler = set_signal_flag;
335 if (sigaction(SIGHUP, &handler, NULL) < 0)
336 fatal_error("sigaction()");
337
338 /* Loop to wait a client access */
339 FD_ZERO(&read_fds);
340 FD_SET(sock_fd, &read_fds);
341 max_read_fd = sock_fd;
342 for (;;) {
343 int select_ret; /* return value of select() */
344 fd_set active_fds; /* list of the active file descriptor */
345 struct timeval select_timeout; /* timeout for select() */
346
347 /* When catch SIGHUP, exit the loop */
348 if (catch_sighup)
349 break;
350
351 active_fds = read_fds;
352 select_timeout.tv_sec = 0; /* 0.5 sec */
353 select_timeout.tv_usec = 500000;
354
355 select_ret = select(max_read_fd + 1, &active_fds,
356 NULL, NULL, &select_timeout);
357 if (select_ret < 0) {
358 if (catch_sighup)
359 break;
360 else
361 fatal_error("select()");
362 } else if (select_ret == 0) {
363 continue;
364 } else {
365 if (FD_ISSET(sock_fd, &active_fds))
366 respond_to_client(sock_fd);
367 }
368 }
369
370 /* Close the sockets */
371 if (close(sock_fd))
372 fatal_error("close()");
373
374 exit(EXIT_SUCCESS);
375 }
376