Correzioni
[gapil.git] / sources / TCP_echod_second.c
1 /* TCP_echod_second.c
2  * 
3  * Copyright (C) 2001-2003 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  * Second 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 compat = 0;
65     pid_t pid;
66     struct sockaddr_in serv_add, cli_add;
67     socklen_t len;
68     char debug[MAXLINE], ipaddr[20];
69     /*
70      * Input section: decode parameters passed in the calling 
71      * Use getopt function
72      */
73     int i;
74     opterr = 0;  /* don't want writing to stderr */
75     while ( (i = getopt(argc, argv, "hdicw:")) != -1) {
76         switch (i) {
77         /* 
78          * Handling options 
79          */ 
80         case 'h':  
81             printf("Wrong -h option use\n");
82             usage();
83             return(0);
84             break;
85         case 'i':
86             demonize = 0;
87             break;
88         case 'c':
89             compat = 1;
90             break;
91         case 'd':
92             debugging = 1;
93             break;
94         case 'w':
95             waiting = strtol(optarg, NULL, 10);
96             break;
97         case '?':   /* unrecognized options */
98             printf("Unrecognized options -%c\n",optopt);
99             usage();
100         default:    /* should not reached */
101             usage();
102         }
103     }
104     /* ***********************************************************
105      * 
106      *           Options processing completed
107      *
108      *                Main code beginning
109      * 
110      * ***********************************************************/
111     /* Main code begin here */
112     if (compat) {                             /* install signal handler */
113         Signal(SIGCHLD, HandSigCHLD);         /* non restarting handler */
114     } else {
115         SignalRestart(SIGCHLD, HandSigCHLD);  /* restarting handler */
116     }
117     /* create socket */
118     if ( (list_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
119         perror("Socket creation error");
120         exit(1);
121     }
122     /* initialize address */
123     memset((void *)&serv_add, 0, sizeof(serv_add)); /* clear server address */
124     serv_add.sin_family = AF_INET;                  /* address type is INET */
125     serv_add.sin_port = htons(7);                   /* echo port is 7 */
126     serv_add.sin_addr.s_addr = htonl(INADDR_ANY);   /* connect from anywhere */
127     /* bind socket */
128     if (bind(list_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
129         perror("bind error");
130         exit(1);
131     }
132     /* release privileges and go daemon */
133     if (setgid(65534) !=0) { /* first give away group privileges */
134         perror("cannot give away group privileges");
135         exit(1);
136     }
137     if (setuid(65534) !=0) { /* and only after user ... */
138         perror("cannot give away user privileges");
139         exit(1);
140     }
141     if (demonize) {          /* go daemon */
142         openlog(argv[0], 0, LOG_DAEMON); /* open logging */
143         if (daemon(0, 0) != 0) {
144             perror("cannot start as daemon");
145             exit(1);
146         }
147     }
148     /* main body */
149     if (listen(list_fd, BACKLOG) < 0 ) {
150         PrintErr("listen error");
151         exit(1);
152     }
153     if (waiting) sleep(waiting);
154     /* handle echo to client */
155     while (1) {
156         /* accept connection */
157         len = sizeof(cli_add);
158         while (((conn_fd = accept(list_fd, (struct sockaddr *)&cli_add, &len)) 
159                 < 0) && (errno == EINTR)); 
160         if (conn_fd < 0) {
161             PrintErr("accept error");
162             exit(1);
163         }
164         if (debugging) {
165             inet_ntop(AF_INET, &cli_add.sin_addr, ipaddr, sizeof(ipaddr));
166             snprintf(debug, MAXLINE, "Accepted connection form %s\n", ipaddr);
167             if (demonize) {
168                 syslog(LOG_DEBUG, debug);
169             } else {
170                 printf("%s", debug);
171             }
172         }
173         /* fork to handle connection */
174         if ( (pid = fork()) < 0 ){
175             PrintErr("fork error");
176             exit(1);
177         }
178         if (pid == 0) {      /* child */
179             close(list_fd);          /* close listening socket */   
180             ServEcho(conn_fd);       /* handle echo */
181             if (debugging) {
182                 snprintf(debug, MAXLINE, "Closed connection %s\n", ipaddr);
183                 if (demonize) {
184                     syslog(LOG_DEBUG, debug);
185                 } else {
186                     printf("%s", debug);
187                 }
188             }
189             exit(0);
190         } else {             /* parent */
191             close(conn_fd);          /* close connected socket */
192         }
193     }
194     /* normal exit, never reached */
195     exit(0);
196 }
197 /*
198  * routine to print usage info and exit
199  */
200 void usage(void) {
201     printf("Elementary echo server\n");
202     printf("Usage:\n");
203     printf("  echod [-h] \n");
204     printf("  -h           print this help\n");
205     printf("  -d           write debug info\n");
206     printf("  -i           use interactively\n");
207     printf("  -c           disable BSD semantics\n");
208     printf("  -w N         wait N sec. before calling accept\n");
209     exit(1);
210 }
211 /*
212  * routine to handle echo for connection
213  */
214 void ServEcho(int sockfd) {
215     char buffer[MAXLINE];
216     int nread, nwrite;
217     char debug[MAXLINE+20];
218     /* main loop, reading 0 char means client close connection */
219     while ( (nread = read(sockfd, buffer, MAXLINE)) != 0) {
220         if (nread < 0) {
221             PrintErr("Errore in lettura");
222             return;
223         }
224         nwrite = FullWrite(sockfd, buffer, nread);
225         if (nwrite) {
226             PrintErr("Errore in scrittura");
227             return;
228         }
229         if (debugging) {
230             buffer[nread] = 0;
231             snprintf(debug, MAXLINE+20, "Letti %d byte, %s", nread, buffer);
232             if (demonize) {          /* daemon mode */
233                 syslog(LOG_DEBUG, debug);
234             } else {
235                 printf("%s", debug);
236             }
237         }
238     }
239     return;
240 }
241 /*
242  * routine to print error on stout or syslog
243  */
244 void PrintErr(char * error) {
245     if (demonize) {                       /* daemon mode */
246         syslog(LOG_ERR, "%s: %m", error); /* log string and error message */
247     } else {
248         perror(error);
249     }
250     return;
251 }