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