cgit.sxemacs.org Git - riece/blob - dcc/dcc.c

   1 /* dcc.c
   2  * Copyright (C) 1998-2003  Daiki Ueno
   3  *
   4  * This file is part of Riece.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  */
  20
  21 #include <sys/types.h>
  22 #include <sys/time.h>
  23 #include <sys/socket.h>
  24 #include <sys/file.h>
  25 #include <sys/ioctl.h>
  26 #include <sys/stat.h>
  27 #include <sys/time.h>
  28 #include <netdb.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <signal.h>
  32 #include <fcntl.h>
  33 #include <netinet/in.h>
  34 #define _GNU_SOURCE
  35 #include <getopt.h>
  36
  37 #ifndef MAXHOSTNAMELEN
  38 # define MAXHOSTNAMELEN 31
  39 #endif
  40
  41 #ifdef HAVE_SYS_SELECT_H
  42 # include <sys/select.h>
  43 #endif
  44
  45 #ifdef HAVE_MEMMOVE
  46 # ifdef HAVE_LIBGEN_H
  47 #  include <libgen.h>
  48 #  ifdef basename
  49 #   undef basename
  50 #  endif
  51 # endif
  52 # include <string.h>
  53 #else
  54 # define memmove(x,y,z) bcopy((y), (x), (z))
  55 #endif
  56
  57 #ifndef HAVE_BASENAME
  58 # define basename(path) (rindex((path), '/') + 1)
  59 #endif
  60
  61 static void usage();
  62 static int prepare_listen_port();
  63 static int prepare_connect_port();
  64
  65 static int receive_file();
  66 static int send_file();
  67 static int select_loop();
  68 static int chat_listen();
  69 static int chat_connect();
  70
  71 static u_long primary_address_of();
  72 static u_long extract_addr_of_string();
  73 static u_long get_address_externally();
  74
  75 static char *progname;
  76
  77 void version () {
  78         fprintf(stderr,
  79                                         "%s (%s) %s\n"
  80                                         "Copyright (C) 1998-2003 Daiki Ueno\n"
  81                                         "This is free software; see the source for copying conditions.  There is NO\n"
  82                                         "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",
  83                                         progname, PACKAGE, VERSION);
  84 }
  85
  86 void usage () {
  87   fprintf(stderr,
  88                                         "Usage: %s [global-options] command [arguments...]\n"
  89                                         "where global-options are -v, -h, etc.\n"
  90                                         "where command is one of send, receive, chat, resolve.\n"
  91                                         "where arguments depend on the specific command.\n\n"
  92                                         "send <port> <filename>\n"
  93                                         "receive <host> <port> <size> <filename>\n"
  94                                         "chat listen <port>\n"
  95                                         "chat connect <host> <port>\n"
  96                                         "resolve [hosts ...]\n",
  97                                         progname);
  98 }
  99
 100 int prepare_listen_port (int ip_port) {
 101   int sock, tries;
 102   int opt = 1;
 103   static struct sockaddr_in server;
 104
 105
 106   if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 107     perror("opening stream socket");
 108     exit(1);
 109   }
 110
 111 #ifdef SO_REUSEADDR
 112   if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
 113                  (char *)&opt, sizeof (opt)) < 0) {
 114     perror ("setsockopt SO_REUSEADDR");
 115   }
 116 #endif
 117
 118   /* Bind a port to listen for new connections */
 119
 120   server.sin_family = AF_INET;
 121   server.sin_addr.s_addr = INADDR_ANY;
 122   server.sin_port = htons (ip_port);
 123   for (tries = 0; tries < 10; tries++) {
 124     if (bind (sock, (struct sockaddr *) &server, sizeof (server))) {
 125       if (tries >= 9) {
 126         perror ("binding stream socket");
 127         exit (1);
 128       }
 129       perror ("binding stream socket. retry in 20 seconds");
 130       sleep (20);               /* wait 20 seconds and try again */
 131     } else
 132       break;
 133   }
 134   listen (sock, 64);
 135   return (sock);
 136 }
 137
 138 u_long get_address_externally(char *ircserver) {
 139   int i, len, dummy;
 140   u_long addr;
 141   struct hostent *hp;
 142   struct sockaddr_in server, client;
 143
 144   addr = 0xc6290004;                          /* dummy addr --- rootA */
 145   if (ircserver && (hp = gethostbyname(ircserver)) != NULL) {
 146     addr = ntohl(((struct in_addr *)hp->h_addr_list[0])->s_addr);
 147   }
 148   if ((dummy = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 149     perror("opening stream socket");
 150     return -1;
 151   }
 152   server.sin_family = AF_INET;
 153   server.sin_addr.s_addr = htonl(addr);
 154   server.sin_port = htons(7);                 /* dummy port --- echo */
 155   for (i = 0; i < 8; i++) {
 156     server.sin_zero[i] = 0;
 157   }
 158   if (connect(dummy, (struct sockaddr *)&server, sizeof(server)) < 0) {
 159     perror ("connecting remote socket");
 160     return -1;
 161   }
 162   len = sizeof(client);
 163   if (getsockname(dummy, (struct sockaddr *)&client, &len) < 0)
 164     return -1;
 165   close(dummy);
 166   return ntohl(client.sin_addr.s_addr);
 167 }
 168
 169 \f
 170 /*
 171  * send_file(int port, char *ifile)
 172  * listens to connections to port, and when connection established
 173  * sends ifile to that socket
 174  */
 175 int send_file (int port, char *ifile) {
 176   int sock, ifd, ofd, len;
 177   u_long addr, bytessent = 0;
 178   char buf[ BUFSIZ * 8 ];
 179   fd_set readfds, writefds, fdset;
 180   struct stat statbuf;
 181   char namebuf[ MAXHOSTNAMELEN ];
 182   struct hostent *hp;
 183   struct sockaddr_in sin;
 184
 185   if ((ifd = open (ifile, O_RDONLY)) < 0) {
 186     /* error in opening file to send */
 187     close(ofd);
 188     return 1;
 189   }
 190
 191   gethostname(namebuf, sizeof (namebuf));
 192   fstat (ifd, &statbuf);
 193
 194   sock = prepare_listen_port(port);
 195   len = sizeof (struct sockaddr_in);
 196   if (getsockname(sock, (struct sockaddr *)&sin, &len) == 0)
 197     port = ntohs(sin.sin_port);
 198
 199         if ((addr = get_address_externally (NULL)) < 0) {
 200                 gethostname(namebuf, sizeof (namebuf));
 201                 if (hp = gethostbyname(namebuf))
 202                         addr = ((struct in_addr *) (hp->h_addr_list)[0])->s_addr;
 203                 else
 204                         return 2;
 205         }
 206
 207         printf ("DCC send %s %d %u %d\n", ifile, port, addr, statbuf.st_size);
 208
 209   ofd = accept(sock, (struct sockaddr *) 0, (int *) 0);
 210
 211   while ((len = read (ifd, buf, sizeof (buf))) > 0) {
 212     write (ofd, buf, len);
 213     bytessent += len;
 214     while ((len = read (ofd, buf, sizeof (u_long))) &&
 215            ntohl (*(u_long *) buf) != bytessent);
 216   }
 217   close (ofd);
 218   close (ifd);
 219   printf ("*** DCC file %s sent\n", ifile);
 220
 221   return 0;
 222 }
 223
 224 /*
 225  * receive_file(u_long host, int port, char *ifile)
 226  * connects to (host,port) and reads everything send from there
 227  * for every packet received gives back how much actually got
 228  * puts everything in ifile
 229  */
 230 int receive_file (u_long host, int port, int size, char *ifile) {
 231   int sock, ifd, ofd, len, bytesreceived = 0, toread, prev = 0;
 232   char buf[ BUFSIZ * 8 ];
 233   fd_set readfds, writefds, fdset;
 234   u_long netsize;
 235
 236   if ((ofd = open(ifile, O_WRONLY|O_CREAT|O_TRUNC, 0600)) < 0) {
 237     fprintf(stderr, "open: opening file: %s\n", ifile);
 238     return 1;
 239   }
 240   ifd = prepare_connect_port (host, port);
 241   if ((toread = sizeof (buf)) > size)
 242     toread = size;
 243   while (bytesreceived < size && (len = read (ifd, buf, toread)) > 0) {
 244     write (ofd, buf, len);
 245     bytesreceived += len;
 246     netsize = htonl (bytesreceived);
 247     lseek (ifd, 0, 2);
 248     write (ifd, &netsize, 4);
 249     lseek (ifd, 0, 2);
 250     if (toread > size - bytesreceived)
 251       toread = size - bytesreceived;
 252     if (bytesreceived - prev > size / 5) {
 253       printf ("DCC %s %d%% (%d/%d bytes) received\n", ifile,
 254               100 * bytesreceived / size, bytesreceived, size);
 255       prev = bytesreceived;
 256     }
 257   }
 258   printf ("*** DCC file %s received\n", ifile);
 259   close (ifd);
 260   close (ofd);
 261
 262   return 0;
 263 }
 264
 265 /*
 266  * select_loop(int sfd)
 267  * listens fd given, reads stdin and sends it to socket
 268  * anything read from socket is send to stdout
 269  */
 270 int select_loop (int sfd) {
 271   int ofd, len, bytesreceived = 0;
 272   char buf[ BUFSIZ * 8 ];
 273   fd_set readfds, writefds, fdset;
 274
 275   for (;;) {
 276     FD_ZERO (&readfds);
 277     FD_SET (sfd, &readfds);
 278     FD_SET (0, &readfds);
 279     if (select (32, &readfds, 0, 0, 0) < 0) {
 280       perror ("select");
 281       close (sfd);
 282       return 1;
 283     }
 284
 285     if (FD_ISSET (sfd, &readfds)) {
 286       if ((len = read(sfd, buf, sizeof (buf))) == 0) {
 287         close (sfd);
 288         return 0;
 289       }
 290       write (1, buf, len);
 291       FD_CLR (sfd, &readfds);
 292     }
 293     if (FD_ISSET (0, &readfds)) {
 294       if ((len = read (0, buf, sizeof (buf))) == 0) {
 295         close (sfd);
 296         return 0;
 297       }
 298       write(sfd, buf, len);
 299       FD_CLR (ofd, &readfds);
 300     }
 301   }
 302 }
 303
 304 int prepare_connect_port (u_long host, int port) {
 305   int sock;
 306   static struct hostent *hp;
 307   static struct sockaddr_in server;
 308
 309   sock = socket (AF_INET, SOCK_STREAM, 0);
 310   if (sock < 0) {
 311     perror ("opening stream socket");
 312     exit (1);
 313   }
 314   server.sin_family = AF_INET;
 315
 316   server.sin_addr.s_addr = ntohl (host);
 317   server.sin_port = htons (port);
 318
 319   if (connect(sock, (struct sockaddr *) &server, sizeof (server)) < 0) {
 320     perror ("connecting remote socket");
 321     return 0;
 322   }
 323
 324   return sock;
 325 }
 326
 327 u_long extract_addr_of_string (char *str) {
 328   u_long result = 0;
 329
 330 #ifndef HAVE_STRTOUL
 331   while (*str++)
 332     result = result * 10 + *str - '0';
 333 #else /* !HAVE_STRTOUL */
 334   result = strtoul(str, NULL, 10);
 335 #endif /* HAVE_STRTOUL */
 336   return result;
 337 }
 338
 339 u_long primary_address_of (char *host) {
 340   struct hostent *hp;
 341   u_long addr;
 342
 343   if ((hp = gethostbyname(host)) == NULL)
 344     addr = inet_addr(host);
 345   else
 346     memmove(&addr, hp->h_addr_list[ 0 ], 4);
 347
 348   return ntohl(addr);
 349 }
 350
 351 int chat_listen(int port) {
 352   struct sockaddr_in sin;
 353   struct hostent *hp;
 354         u_long addr;
 355   int sock, len;
 356   char namebuf[ MAXHOSTNAMELEN ];
 357
 358   sock = prepare_listen_port (port);
 359
 360   len = sizeof (struct sockaddr_in);
 361   if (getsockname(sock, (struct sockaddr *)&sin, &len) == 0)
 362     port = ntohs(sin.sin_port);
 363
 364         if ((addr = get_address_externally (NULL)) < 0) {
 365                 gethostname(namebuf, sizeof (namebuf));
 366                 if (hp = gethostbyname(namebuf))
 367                         addr = ((struct in_addr *) (hp->h_addr_list)[0])->s_addr;
 368                 else
 369                         return 2;
 370         }
 371
 372         printf("DCC chat %u %d\n", addr, port);
 373
 374   if ((sock = accept(sock, (struct sockaddr *) 0, (int *) 0)) > -1) {
 375                 printf("DCC chat established\n");
 376     return select_loop(sock);
 377         }
 378
 379   return 1;
 380 }
 381
 382 int chat_connect(u_long host, int port) {
 383   int sock;
 384
 385   if ((sock = prepare_connect_port(host, port)) > -1) {
 386     printf("DCC chat established\n");
 387     return select_loop(sock);
 388   }
 389
 390   return 1;
 391 }
 392
 393 \f
 394 int main (int argc, char **argv) {
 395   char *host = "localhost";
 396   char *action;
 397   int c, status = 0;
 398
 399   progname = (char *)basename(argv[ 0 ]);
 400
 401         while (1)       {
 402                 int this_option_optind = optind ? optind : 1;
 403                 int option_index = 0;
 404                 static struct option long_options[] =   {
 405                         {"version", 0, 0, 'v'},
 406                         {"help", 0, 0, 'h'},
 407                         {0, 0, 0, 0}
 408                 };
 409
 410                 c = getopt_long (argc, argv, "vh", long_options, &option_index);
 411                 if (c == -1)
 412                         break;
 413
 414                 switch (c) {
 415                 case 'v':
 416                         version();
 417                         exit(0);
 418                         break;
 419                 case 'h':
 420                         usage();
 421                         exit(0);
 422                         break;
 423                 default:
 424                         break;
 425                 }
 426         }
 427
 428   if (argc > 1) {
 429     action = argv[ 1 ];
 430   } else {
 431     usage();
 432     exit(1);
 433   }
 434
 435   if (!strcmp(action, "resolve")) {
 436     if (argc < 3) {
 437       usage();
 438       exit(1);
 439     } else {
 440       u_long i, addr;
 441       for (i = 2; i < argc; i++) {
 442         addr = primary_address_of(argv[i]);
 443         if (addr != -1)
 444           printf("%u\n", addr);
 445         else
 446           printf("0\n");
 447       }
 448       status = 0;
 449     }
 450   }
 451
 452   if (!strcmp(action, "send")) {
 453     if (argc != 4) {
 454       usage();
 455       exit(1);
 456     }
 457     status = send_file (atoi(argv[ 2 ]), argv[ 3 ]);
 458   } else if (!strcmp(action, "receive")) {
 459     if (argc != 6) {
 460       usage();
 461       exit(1);
 462     }
 463     status =
 464       receive_file (extract_addr_of_string(argv[ 2 ]),
 465                     atoi(argv[ 3 ]), atoi(argv[ 4 ]), argv[ 5 ]);
 466   } else if (!strcmp(action, "chat")) {
 467     if (argc > 3) {
 468       if (!strcmp(argv[ 2 ], "listen")) {
 469         if (argc != 4) {
 470           usage();
 471           exit(1);
 472         }
 473         status = chat_listen(atoi(argv[ 3 ]));
 474       } else if (!strcmp(argv[ 2 ], "connect")) {
 475         if (argc != 5) {
 476           usage();
 477           exit(1);
 478         }
 479         status = chat_connect(extract_addr_of_string(argv[ 3 ]),
 480                               atoi(argv[ 4 ]));
 481       } else {
 482         usage();
 483         exit(1);
 484       }
 485     }
 486   } else {
 487     usage();
 488     exit(1);
 489   }
 490
 491   return status;
 492 }
 493
 494 /*
 495  * Local variables:
 496  *  compile-command: "gcc -DHAVE_STRTOUL -Wall -O6 -o dcc dcc.c"
 497  *  c-indent-level: 2
 498  *  c-basic-offset: 2
 499  *  tab-width: 2
 500  * End:
 501  */