socket.c

   1 /*
   2    Copyright (C) Andrew Tridgell 1998
   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., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 /*
  20   socket functions used in rsync
  21
  22   */
  23
  24 #include "rsync.h"
  25
  26 /* open a socket to a tcp remote host with the specified port
  27    based on code from Warren */
  28 int open_socket_out(char *host, int port)
  29 {
  30         int type = SOCK_STREAM;
  31         struct sockaddr_in sock_out;
  32         int res;
  33         struct hostent *hp;
  34
  35
  36         res = socket(PF_INET, type, 0);
  37         if (res == -1) {
  38                 return -1;
  39         }
  40
  41         hp = gethostbyname(host);
  42         if (!hp) {
  43                 rprintf(FERROR,"unknown host: %s\n", host);
  44                 return -1;
  45         }
  46
  47         memcpy(&sock_out.sin_addr, hp->h_addr, hp->h_length);
  48         sock_out.sin_port = htons(port);
  49         sock_out.sin_family = PF_INET;
  50
  51         if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
  52                 close(res);
  53                 rprintf(FERROR,"failed to connect to %s - %s\n", host, strerror(errno));
  54                 return -1;
  55         }
  56
  57         return res;
  58 }
  59
  60
  61 /****************************************************************************
  62 open a socket of the specified type, port and address for incoming data
  63 ****************************************************************************/
  64 static int open_socket_in(int type, int port)
  65 {
  66         struct hostent *hp;
  67         struct sockaddr_in sock;
  68         char host_name[200];
  69         int res;
  70         int one=1;
  71
  72         /* get my host name */
  73         if (gethostname(host_name, sizeof(host_name)) == -1) {
  74                 rprintf(FERROR,"gethostname failed\n");
  75                 return -1;
  76         }
  77
  78         /* get host info */
  79         if ((hp = gethostbyname(host_name)) == 0) {
  80                 rprintf(FERROR,"gethostbyname: Unknown host %s\n",host_name);
  81                 return -1;
  82         }
  83
  84         bzero((char *)&sock,sizeof(sock));
  85         memcpy((char *)&sock.sin_addr,(char *)hp->h_addr, hp->h_length);
  86         sock.sin_port = htons(port);
  87         sock.sin_family = hp->h_addrtype;
  88         sock.sin_addr.s_addr = INADDR_ANY;
  89         res = socket(hp->h_addrtype, type, 0);
  90         if (res == -1) {
  91                 rprintf(FERROR,"socket failed\n");
  92                 return -1;
  93         }
  94
  95         setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&one,sizeof(one));
  96
  97         /* now we've got a socket - we need to bind it */
  98         if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) == -1) {
  99                 rprintf(FERROR,"bind failed on port %d\n", port);
 100                 close(res);
 101                 return -1;
 102         }
 103
 104         return res;
 105 }
 106
 107
 108 /****************************************************************************
 109 determine if a file descriptor is in fact a socket
 110 ****************************************************************************/
 111 int is_a_socket(int fd)
 112 {
 113   int v,l;
 114   l = sizeof(int);
 115   return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
 116 }
 117
 118
 119 int start_accept_loop(int port, int (*fn)(int ))
 120 {
 121         int s;
 122
 123         signal(SIGCLD, SIG_IGN);
 124
 125         /* open an incoming socket */
 126         s = open_socket_in(SOCK_STREAM, port);
 127         if (s == -1)
 128                 return(-1);
 129
 130         /* ready to listen */
 131         if (listen(s, 5) == -1) {
 132                 close(s);
 133                 return -1;
 134         }
 135
 136
 137         /* now accept incoming connections - forking a new process
 138            for each incoming connection */
 139         while (1) {
 140                 fd_set fds;
 141                 int fd;
 142                 struct sockaddr addr;
 143                 int in_addrlen = sizeof(addr);
 144
 145                 FD_ZERO(&fds);
 146                 FD_SET(s, &fds);
 147
 148                 if (select(s+1, &fds, NULL, NULL, NULL) != 1) {
 149                         continue;
 150                 }
 151
 152                 if(!FD_ISSET(s, &fds)) continue;
 153
 154                 fd = accept(s,&addr,&in_addrlen);
 155
 156                 if (fd == -1) continue;
 157
 158                 if (fork()==0) {
 159                         close(s);
 160
 161                         _exit(fn(fd));
 162                 }
 163
 164                 close(fd);
 165         }
 166         return 0;
 167 }
 168
 169
 170 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
 171
 172 struct
 173 {
 174   char *name;
 175   int level;
 176   int option;
 177   int value;
 178   int opttype;
 179 } socket_options[] = {
 180   {"SO_KEEPALIVE",      SOL_SOCKET,    SO_KEEPALIVE,    0,                 OPT_BOOL},
 181   {"SO_REUSEADDR",      SOL_SOCKET,    SO_REUSEADDR,    0,                 OPT_BOOL},
 182   {"SO_BROADCAST",      SOL_SOCKET,    SO_BROADCAST,    0,                 OPT_BOOL},
 183 #ifdef TCP_NODELAY
 184   {"TCP_NODELAY",       IPPROTO_TCP,   TCP_NODELAY,     0,                 OPT_BOOL},
 185 #endif
 186 #ifdef IPTOS_LOWDELAY
 187   {"IPTOS_LOWDELAY",    IPPROTO_IP,    IP_TOS,          IPTOS_LOWDELAY,    OPT_ON},
 188 #endif
 189 #ifdef IPTOS_THROUGHPUT
 190   {"IPTOS_THROUGHPUT",  IPPROTO_IP,    IP_TOS,          IPTOS_THROUGHPUT,  OPT_ON},
 191 #endif
 192 #ifdef SO_SNDBUF
 193   {"SO_SNDBUF",         SOL_SOCKET,    SO_SNDBUF,       0,                 OPT_INT},
 194 #endif
 195 #ifdef SO_RCVBUF
 196   {"SO_RCVBUF",         SOL_SOCKET,    SO_RCVBUF,       0,                 OPT_INT},
 197 #endif
 198 #ifdef SO_SNDLOWAT
 199   {"SO_SNDLOWAT",       SOL_SOCKET,    SO_SNDLOWAT,     0,                 OPT_INT},
 200 #endif
 201 #ifdef SO_RCVLOWAT
 202   {"SO_RCVLOWAT",       SOL_SOCKET,    SO_RCVLOWAT,     0,                 OPT_INT},
 203 #endif
 204 #ifdef SO_SNDTIMEO
 205   {"SO_SNDTIMEO",       SOL_SOCKET,    SO_SNDTIMEO,     0,                 OPT_INT},
 206 #endif
 207 #ifdef SO_RCVTIMEO
 208   {"SO_RCVTIMEO",       SOL_SOCKET,    SO_RCVTIMEO,     0,                 OPT_INT},
 209 #endif
 210   {NULL,0,0,0,0}};
 211
 212
 213
 214 /****************************************************************************
 215 set user socket options
 216 ****************************************************************************/
 217 void set_socket_options(int fd, char *options)
 218 {
 219         char *tok;
 220         options = strdup(options);
 221
 222         if (!options) out_of_memory("set_socket_options");
 223
 224         for (tok=strtok(options, " \t,"); tok; tok=strtok(NULL," \t,")) {
 225                 int ret=0,i;
 226                 int value = 1;
 227                 char *p;
 228                 int got_value = 0;
 229
 230                 if ((p = strchr(tok,'='))) {
 231                         *p = 0;
 232                         value = atoi(p+1);
 233                         got_value = 1;
 234                 }
 235
 236                 for (i=0;socket_options[i].name;i++)
 237                         if (strcmp(socket_options[i].name,tok)==0)
 238                                 break;
 239
 240                 if (!socket_options[i].name) {
 241                         rprintf(FERROR,"Unknown socket option %s\n",tok);
 242                         continue;
 243                 }
 244
 245                 switch (socket_options[i].opttype) {
 246                 case OPT_BOOL:
 247                 case OPT_INT:
 248                         ret = setsockopt(fd,socket_options[i].level,
 249                                          socket_options[i].option,(char *)&value,sizeof(int));
 250                         break;
 251
 252                 case OPT_ON:
 253                         if (got_value)
 254                                 rprintf(FERROR,"syntax error - %s does not take a value\n",tok);
 255
 256                         {
 257                                 int on = socket_options[i].value;
 258                                 ret = setsockopt(fd,socket_options[i].level,
 259                                                  socket_options[i].option,(char *)&on,sizeof(int));
 260                         }
 261                         break;
 262                 }
 263
 264                 if (ret != 0)
 265                         rprintf(FERROR,"Failed to set socket option %s\n",tok);
 266         }
 267
 268         free(options);
 269 }
 270
 271 /****************************************************************************
 272 become a daemon, discarding the controlling terminal
 273 ****************************************************************************/
 274 void become_daemon(void)
 275 {
 276         if (fork())
 277                 _exit(0);
 278
 279         /* detach from the terminal */
 280 #ifdef HAVE_SETSID
 281         setsid();
 282 #else
 283 #ifdef TIOCNOTTY
 284         {
 285                 int i = open("/dev/tty", O_RDWR);
 286                 if (i >= 0)
 287                         {
 288                                 ioctl(i, (int) TIOCNOTTY, (char *)0);
 289                                 close(i);
 290                         }
 291         }
 292 #endif /* TIOCNOTTY */
 293 #endif
 294         close(0);
 295         close(1);
 296         close(2);
 297 }