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