Correzioni
[gapil.git] / sources / TCP_echod_fifth.c
1 /* TCP_echod_fifth.c
2  * 
3  * Copyright (C) 2001-2004 Simone Piccardi
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 (at
8  * your option) any later version.
9  * 
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
18  */
19 /****************************************************************
20  *
21  * Program echod 
22  * Elementary TCP server for echo service (port 7)
23  * Fifth version
24  *
25  * Author: Simone Piccardi
26  * Jun. 2001
27  *
28  * Usage: echod -h give all info
29  *
30  ****************************************************************/
31 /* 
32  * Include needed headers
33  */
34 #include <sys/types.h>   /* primitive system data types */
35 #include <unistd.h>      /* unix standard library */
36 #include <arpa/inet.h>   /* IP addresses conversion utilities */
37 #include <sys/socket.h>  /* socket constants, types and functions */
38 #include <stdio.h>       /* standard I/O library */
39 #include <time.h>        /* date and time constants, types and functions */
40 #include <syslog.h>      /* syslog system functions */
41 #include <signal.h>      /* signal constants, types and functions */
42 #include <errno.h>       /* error definitions and routines */
43 #include <string.h>      /* C strings library */
44 #include <stdlib.h>      /* C standard library */
45
46 #include "Gapil.h"
47
48 #define BACKLOG 10
49 #define MAXLINE 256
50 int demonize  = 1;  /* daemon use option: default is daemon */
51 int debugging = 0;  /* debug info printing option: default is no debug */
52 /* Subroutines declaration */
53 void usage(void);
54 void ServEcho(int sockfd);
55 void PrintErr(char * error);
56 /* Program beginning */
57 int main(int argc, char *argv[])
58 {
59 /* 
60  * Variables definition  
61  */
62     int list_fd, conn_fd;
63     int waiting = 0;
64     int keepalive = 0; 
65     int reuse = 0;
66     int compat = 0;
67     pid_t pid;
68     struct sockaddr_in cli_add;
69     socklen_t len;
70     char debug[MAXLINE], ipaddr[20];
71     /*
72      * Input section: decode parameters passed in the calling 
73      * Use getopt function
74      */
75     int i;
76     opterr = 0;  /* don't want writing to stderr */
77     while ( (i = getopt(argc, argv, "hkrdicw:")) != -1) {
78         switch (i) {
79         /* 
80          * Handling options 
81          */ 
82         case 'h':  
83             printf("Wrong -h option use\n");
84             usage();
85             return(0);
86             break;
87         case 'i':
88             demonize = 0;
89             break;
90         case 'k':
91             keepalive = 1;
92             break;
93         case 'r':
94             reuse = 1;
95             break;
96         case 'c':
97             compat = 1;
98             break;
99         case 'd':
100             debugging = 1;
101             break;
102         case 'w':
103             waiting = strtol(optarg, NULL, 10);
104             break;
105         case '?':   /* unrecognized options */
106             printf("Unrecognized options -%c\n",optopt);
107             usage();
108         default:    /* should not reached */
109             usage();
110         }
111     }
112     /* ***********************************************************
113      * 
114      *           Options processing completed
115      *
116      *                Main code beginning
117      * 
118      * ***********************************************************/
119     /* Main code begin here */
120     if (compat) {                             /* install signal handler */
121         Signal(SIGCHLD, HandSigCHLD);         /* non restarting handler */
122     } else {
123         SignalRestart(SIGCHLD, HandSigCHLD);  /* restarting handler */
124     }
125     /* create and bind socket */
126     if ( (list_fd = sockbindopt(argv[optind], "echo", 6, 
127                                 SOCK_STREAM, reuse)) < 0) {
128         return 1;
129     }   
130     /* release privileges and go daemon */
131     if (setgid(65534) !=0) { /* first give away group privileges */
132         perror("cannot give away group privileges");
133         exit(1);
134     }
135     if (setuid(65534) !=0) { /* and only after user ... */
136         perror("cannot give away user privileges");
137         exit(1);
138     }
139     if (demonize) {          /* go daemon */
140         openlog(argv[0], 0, LOG_DAEMON); /* open logging */
141         if (daemon(0, 0) != 0) {
142             perror("cannot start as daemon");
143             exit(1);
144         }
145     }
146     /* main body */
147     if (listen(list_fd, BACKLOG) < 0 ) {
148         PrintErr("listen error");
149         exit(1);
150     }
151     if (waiting) sleep(waiting);
152     /* handle echo to client */
153     while (1) {
154         /* accept connection */
155         len = sizeof(cli_add);
156         while (((conn_fd = accept(list_fd, (struct sockaddr *)&cli_add, &len)) 
157                 < 0) && (errno == EINTR)); 
158         if (conn_fd < 0) {
159             PrintErr("accept error");
160             exit(1);
161         }
162         if (debugging) {
163             inet_ntop(AF_INET, &cli_add.sin_addr, ipaddr, sizeof(ipaddr));
164             snprintf(debug, MAXLINE, "Accepted connection form %s\n", ipaddr);
165             if (demonize) {
166                 syslog(LOG_DEBUG, debug);
167             } else {
168                 printf("%s", debug);
169             }
170         }
171         /* fork to handle connection */
172         if ( (pid = fork()) < 0 ){
173             PrintErr("fork error");
174             exit(1);
175         }
176         if (pid == 0) {      /* child */
177             close(list_fd);          /* close listening socket */   
178             if (keepalive) {         /* enable keepalive ? */
179                 setsockopt(conn_fd, SOL_SOCKET, SO_KEEPALIVE, 
180                            &keepalive, sizeof(keepalive));
181             }
182             ServEcho(conn_fd);       /* handle echo */
183             if (debugging) {
184                 snprintf(debug, MAXLINE, "Closed connection %s\n", ipaddr);
185                 if (demonize) {
186                     syslog(LOG_DEBUG, debug);
187                 } else {
188                     printf("%s", debug);
189                 }
190             }
191             exit(0);
192         } else {             /* parent */
193             close(conn_fd);          /* close connected socket */
194         }
195     }
196     /* normal exit, never reached */
197     exit(0);
198 }
199 /*
200  * routine to print usage info and exit
201  */
202 void usage(void) {
203     printf("Elementary echo server\n");
204     printf("Usage:\n");
205     printf("  echod [-h] \n");
206     printf("  -h           print this help\n");
207     printf("  -d           write debug info\n");
208     printf("  -k           enable SO_KEEPALIVE\n");
209     printf("  -r           enable SO_REUSEADDR\n");
210     printf("  -i           use interactively\n");
211     printf("  -c           disable BSD semantics\n");
212     printf("  -w N         wait N sec. before calling accept\n");
213     exit(1);
214 }
215 /*
216  * routine to handle echo for connection
217  */
218 void ServEcho(int sockfd) {
219     char buffer[MAXLINE];
220     int nread, nwrite;
221     char debug[MAXLINE+20];
222     /* main loop, reading 0 char means client close connection */
223     while ( (nread = read(sockfd, buffer, MAXLINE)) != 0) {
224         if (nread < 0) {
225             PrintErr("Errore in lettura");
226             return;
227         }
228         nwrite = FullWrite(sockfd, buffer, nread);
229         if (nwrite) {
230             PrintErr("Errore in scrittura");
231             return;
232         }
233         if (debugging) {
234             buffer[nread] = 0;
235             snprintf(debug, MAXLINE+20, "Letti %d byte, %s", nread, buffer);
236             if (demonize) {          /* daemon mode */
237                 syslog(LOG_DEBUG, debug);
238             } else {
239                 printf("%s", debug);
240             }
241         }
242     }
243     return;
244 }
245 /*
246  * routine to print error on stout or syslog
247  */
248 void PrintErr(char * error) {
249     if (demonize) {                       /* daemon mode */
250         syslog(LOG_ERR, "%s: %m", error); /* log string and error message */
251     } else {
252         perror(error);
253     }
254     return;
255 }