blob: 3f6c23136356437785f234858b73bcb9a1b9e993 [file] [log] [blame]
Ben Lindstromb6434ae2000-12-05 01:15:09 +00001/*
2 * Copyright 1995, 1996 by David Mazieres <dm@lcs.mit.edu>.
3 *
4 * Modification and redistribution in source and binary forms is
5 * permitted provided that due credit is given to the author and the
6 * OpenBSD project (for instance by leaving this copyright notice
7 * intact).
8 */
9
10#include "includes.h"
Ben Lindstrome21c4ad2001-03-07 01:23:30 +000011RCSID("$OpenBSD: ssh-keyscan.c,v 1.22 2001/03/06 06:11:18 deraadt Exp $");
Ben Lindstromb6434ae2000-12-05 01:15:09 +000012
Kevin Steves28a7f262001-02-05 15:43:59 +000013#if defined(HAVE_SYS_QUEUE_H) && !defined(HAVE_BOGUS_SYS_QUEUE_H)
Ben Lindstromb6434ae2000-12-05 01:15:09 +000014#include <sys/queue.h>
Kevin Steves2c65ada2000-12-06 22:25:40 +000015#else
Kevin Steves54f15b62001-03-14 18:37:13 +000016#include "openbsd-compat/fake-queue.h"
Kevin Steves2c65ada2000-12-06 22:25:40 +000017#endif
Ben Lindstromb6434ae2000-12-05 01:15:09 +000018#include <errno.h>
19
20#include <openssl/bn.h>
Ben Lindstromb6434ae2000-12-05 01:15:09 +000021
22#include "xmalloc.h"
23#include "ssh.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000024#include "ssh1.h"
Ben Lindstromb6434ae2000-12-05 01:15:09 +000025#include "key.h"
26#include "buffer.h"
27#include "bufaux.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000028#include "log.h"
Ben Lindstromd20b8552001-03-05 07:01:18 +000029#include "atomicio.h"
Ben Lindstromb6434ae2000-12-05 01:15:09 +000030
31static int argno = 1; /* Number of argument currently being parsed */
32
33int family = AF_UNSPEC; /* IPv4, IPv6 or both */
34
Ben Lindstromb6434ae2000-12-05 01:15:09 +000035#define MAXMAXFD 256
36
37/* The number of seconds after which to give up on a TCP connection */
38int timeout = 5;
39
40int maxfd;
Ben Lindstromd20b8552001-03-05 07:01:18 +000041#define MAXCON (maxfd - 10)
Ben Lindstromb6434ae2000-12-05 01:15:09 +000042
Kevin Stevesec84dc12000-12-13 17:45:15 +000043#ifdef HAVE___PROGNAME
44extern char *__progname;
45#else
46char *__progname;
47#endif
Ben Lindstromc1e04212001-03-05 07:04:38 +000048fd_set *read_wait;
49size_t read_wait_size;
Ben Lindstromb6434ae2000-12-05 01:15:09 +000050int ncon;
51
52/*
53 * Keep a connection structure for each file descriptor. The state
54 * associated with file descriptor n is held in fdcon[n].
55 */
56typedef struct Connection {
Ben Lindstrom46c16222000-12-22 01:43:59 +000057 u_char c_status; /* State of connection on this file desc. */
Ben Lindstromb6434ae2000-12-05 01:15:09 +000058#define CS_UNUSED 0 /* File descriptor unused */
59#define CS_CON 1 /* Waiting to connect/read greeting */
60#define CS_SIZE 2 /* Waiting to read initial packet size */
61#define CS_KEYS 3 /* Waiting to read public key packet */
62 int c_fd; /* Quick lookup: c->c_fd == c - fdcon */
63 int c_plen; /* Packet length field for ssh packet */
64 int c_len; /* Total bytes which must be read. */
65 int c_off; /* Length of data read so far. */
66 char *c_namebase; /* Address to free for c_name and c_namelist */
67 char *c_name; /* Hostname of connection for errors */
68 char *c_namelist; /* Pointer to other possible addresses */
69 char *c_output_name; /* Hostname of connection for output */
70 char *c_data; /* Data read from this fd */
71 struct timeval c_tv; /* Time at which connection gets aborted */
72 TAILQ_ENTRY(Connection) c_link; /* List of connections in timeout order. */
73} con;
74
75TAILQ_HEAD(conlist, Connection) tq; /* Timeout Queue */
76con *fdcon;
77
78/*
79 * This is just a wrapper around fgets() to make it usable.
80 */
81
82/* Stress-test. Increase this later. */
83#define LINEBUF_SIZE 16
84
85typedef struct {
86 char *buf;
Ben Lindstrom46c16222000-12-22 01:43:59 +000087 u_int size;
Ben Lindstromb6434ae2000-12-05 01:15:09 +000088 int lineno;
89 const char *filename;
90 FILE *stream;
91 void (*errfun) (const char *,...);
92} Linebuf;
93
Kevin Steves935aa242001-03-05 19:46:37 +000094Linebuf *
Ben Lindstromb6434ae2000-12-05 01:15:09 +000095Linebuf_alloc(const char *filename, void (*errfun) (const char *,...))
96{
97 Linebuf *lb;
98
99 if (!(lb = malloc(sizeof(*lb)))) {
100 if (errfun)
101 (*errfun) ("linebuf (%s): malloc failed\n", lb->filename);
102 return (NULL);
103 }
104 if (filename) {
105 lb->filename = filename;
106 if (!(lb->stream = fopen(filename, "r"))) {
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000107 xfree(lb);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000108 if (errfun)
109 (*errfun) ("%s: %s\n", filename, strerror(errno));
110 return (NULL);
111 }
112 } else {
113 lb->filename = "(stdin)";
114 lb->stream = stdin;
115 }
116
117 if (!(lb->buf = malloc(lb->size = LINEBUF_SIZE))) {
118 if (errfun)
119 (*errfun) ("linebuf (%s): malloc failed\n", lb->filename);
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000120 xfree(lb);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000121 return (NULL);
122 }
123 lb->errfun = errfun;
124 lb->lineno = 0;
125 return (lb);
126}
127
Kevin Steves935aa242001-03-05 19:46:37 +0000128void
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000129Linebuf_free(Linebuf * lb)
130{
131 fclose(lb->stream);
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000132 xfree(lb->buf);
133 xfree(lb);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000134}
135
Kevin Steves935aa242001-03-05 19:46:37 +0000136void
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000137Linebuf_restart(Linebuf * lb)
138{
139 clearerr(lb->stream);
140 rewind(lb->stream);
141 lb->lineno = 0;
142}
143
Kevin Steves935aa242001-03-05 19:46:37 +0000144int
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000145Linebuf_lineno(Linebuf * lb)
146{
147 return (lb->lineno);
148}
149
Kevin Steves935aa242001-03-05 19:46:37 +0000150char *
Ben Lindstromc791beb2001-02-10 23:18:11 +0000151Linebuf_getline(Linebuf * lb)
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000152{
153 int n = 0;
154
155 lb->lineno++;
156 for (;;) {
157 /* Read a line */
158 if (!fgets(&lb->buf[n], lb->size - n, lb->stream)) {
159 if (ferror(lb->stream) && lb->errfun)
Ben Lindstromb0a4cd82001-03-05 04:54:49 +0000160 (*lb->errfun) ("%s: %s\n", lb->filename,
161 strerror(errno));
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000162 return (NULL);
163 }
164 n = strlen(lb->buf);
165
166 /* Return it or an error if it fits */
167 if (n > 0 && lb->buf[n - 1] == '\n') {
168 lb->buf[n - 1] = '\0';
169 return (lb->buf);
170 }
171 if (n != lb->size - 1) {
172 if (lb->errfun)
Ben Lindstromb0a4cd82001-03-05 04:54:49 +0000173 (*lb->errfun) ("%s: skipping incomplete last line\n",
174 lb->filename);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000175 return (NULL);
176 }
177 /* Double the buffer if we need more space */
178 if (!(lb->buf = realloc(lb->buf, (lb->size *= 2)))) {
179 if (lb->errfun)
Ben Lindstromb0a4cd82001-03-05 04:54:49 +0000180 (*lb->errfun) ("linebuf (%s): realloc failed\n",
181 lb->filename);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000182 return (NULL);
183 }
184 }
185}
186
Kevin Steves935aa242001-03-05 19:46:37 +0000187int
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000188fdlim_get(int hard)
189{
Ben Lindstrom5adbad22000-12-27 07:06:21 +0000190#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE)
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000191 struct rlimit rlfd;
Ben Lindstromb0a4cd82001-03-05 04:54:49 +0000192
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000193 if (getrlimit(RLIMIT_NOFILE, &rlfd) < 0)
194 return (-1);
195 if ((hard ? rlfd.rlim_max : rlfd.rlim_cur) == RLIM_INFINITY)
196 return 10000;
197 else
198 return hard ? rlfd.rlim_max : rlfd.rlim_cur;
Ben Lindstrom2c467a22000-12-27 04:57:41 +0000199#elif defined (HAVE_SYSCONF)
200 return sysconf (_SC_OPEN_MAX);
201#else
202 return 10000;
203#endif
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000204}
205
Kevin Steves935aa242001-03-05 19:46:37 +0000206int
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000207fdlim_set(int lim)
208{
Ben Lindstrom5adbad22000-12-27 07:06:21 +0000209#if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000210 struct rlimit rlfd;
Ben Lindstrom2c467a22000-12-27 04:57:41 +0000211#endif
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000212 if (lim <= 0)
213 return (-1);
Ben Lindstrom5adbad22000-12-27 07:06:21 +0000214#if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000215 if (getrlimit(RLIMIT_NOFILE, &rlfd) < 0)
216 return (-1);
217 rlfd.rlim_cur = lim;
218 if (setrlimit(RLIMIT_NOFILE, &rlfd) < 0)
219 return (-1);
Ben Lindstrom2c467a22000-12-27 04:57:41 +0000220#elif defined (HAVE_SETDTABLESIZE)
Kevin Steves28a7f262001-02-05 15:43:59 +0000221 setdtablesize(lim);
Ben Lindstrom2c467a22000-12-27 04:57:41 +0000222#endif
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000223 return (0);
224}
225
226/*
227 * This is an strsep function that returns a null field for adjacent
228 * separators. This is the same as the 4.4BSD strsep, but different from the
229 * one in the GNU libc.
230 */
Kevin Steves935aa242001-03-05 19:46:37 +0000231char *
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000232xstrsep(char **str, const char *delim)
233{
234 char *s, *e;
235
236 if (!**str)
237 return (NULL);
238
239 s = *str;
240 e = s + strcspn(s, delim);
241
242 if (*e != '\0')
243 *e++ = '\0';
244 *str = e;
245
246 return (s);
247}
248
249/*
250 * Get the next non-null token (like GNU strsep). Strsep() will return a
251 * null token for two adjacent separators, so we may have to loop.
252 */
253char *
254strnnsep(char **stringp, char *delim)
255{
256 char *tok;
257
258 do {
259 tok = xstrsep(stringp, delim);
260 } while (tok && *tok == '\0');
261 return (tok);
262}
263
264void
265keyprint(char *host, char *output_name, char *kd, int len)
266{
267 static Key *rsa;
268 static Buffer msg;
269
270 if (rsa == NULL) {
271 buffer_init(&msg);
272 rsa = key_new(KEY_RSA1);
273 }
274 buffer_append(&msg, kd, len);
275 buffer_consume(&msg, 8 - (len & 7)); /* padding */
276 if (buffer_get_char(&msg) != (int) SSH_SMSG_PUBLIC_KEY) {
277 error("%s: invalid packet type", host);
278 buffer_clear(&msg);
279 return;
280 }
281 buffer_consume(&msg, 8); /* cookie */
282
283 /* server key */
284 (void) buffer_get_int(&msg);
285 buffer_get_bignum(&msg, rsa->rsa->e);
286 buffer_get_bignum(&msg, rsa->rsa->n);
287
288 /* host key */
289 (void) buffer_get_int(&msg);
290 buffer_get_bignum(&msg, rsa->rsa->e);
291 buffer_get_bignum(&msg, rsa->rsa->n);
292 buffer_clear(&msg);
293
294 fprintf(stdout, "%s ", output_name ? output_name : host);
295 key_write(rsa, stdout);
296 fputs("\n", stdout);
297}
298
299int
300tcpconnect(char *host)
301{
302 struct addrinfo hints, *ai, *aitop;
303 char strport[NI_MAXSERV];
304 int gaierr, s = -1;
305
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000306 snprintf(strport, sizeof strport, "%d", SSH_DEFAULT_PORT);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000307 memset(&hints, 0, sizeof(hints));
308 hints.ai_family = family;
309 hints.ai_socktype = SOCK_STREAM;
310 if ((gaierr = getaddrinfo(host, strport, &hints, &aitop)) != 0)
311 fatal("getaddrinfo %s: %s", host, gai_strerror(gaierr));
312 for (ai = aitop; ai; ai = ai->ai_next) {
313 s = socket(ai->ai_family, SOCK_STREAM, 0);
314 if (s < 0) {
315 error("socket: %s", strerror(errno));
316 continue;
317 }
Ben Lindstrom48bd7c12001-01-09 00:35:42 +0000318 if (fcntl(s, F_SETFL, O_NONBLOCK) < 0)
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000319 fatal("F_SETFL: %s", strerror(errno));
320 if (connect(s, ai->ai_addr, ai->ai_addrlen) < 0 &&
321 errno != EINPROGRESS)
322 error("connect (`%s'): %s", host, strerror(errno));
323 else
324 break;
325 close(s);
326 s = -1;
327 }
328 freeaddrinfo(aitop);
329 return s;
330}
331
332int
333conalloc(char *iname, char *oname)
334{
335 int s;
336 char *namebase, *name, *namelist;
337
338 namebase = namelist = xstrdup(iname);
339
340 do {
341 name = xstrsep(&namelist, ",");
342 if (!name) {
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000343 xfree(namebase);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000344 return (-1);
345 }
346 } while ((s = tcpconnect(name)) < 0);
347
348 if (s >= maxfd)
Kevin Stevesfa72dda2000-12-15 18:39:12 +0000349 fatal("conalloc: fdno %d too high", s);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000350 if (fdcon[s].c_status)
Kevin Stevesfa72dda2000-12-15 18:39:12 +0000351 fatal("conalloc: attempt to reuse fdno %d", s);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000352
353 fdcon[s].c_fd = s;
354 fdcon[s].c_status = CS_CON;
355 fdcon[s].c_namebase = namebase;
356 fdcon[s].c_name = name;
357 fdcon[s].c_namelist = namelist;
358 fdcon[s].c_output_name = xstrdup(oname);
359 fdcon[s].c_data = (char *) &fdcon[s].c_plen;
360 fdcon[s].c_len = 4;
361 fdcon[s].c_off = 0;
362 gettimeofday(&fdcon[s].c_tv, NULL);
363 fdcon[s].c_tv.tv_sec += timeout;
364 TAILQ_INSERT_TAIL(&tq, &fdcon[s], c_link);
Ben Lindstromc1e04212001-03-05 07:04:38 +0000365 FD_SET(s, read_wait);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000366 ncon++;
367 return (s);
368}
369
370void
371confree(int s)
372{
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000373 if (s >= maxfd || fdcon[s].c_status == CS_UNUSED)
Kevin Stevesfa72dda2000-12-15 18:39:12 +0000374 fatal("confree: attempt to free bad fdno %d", s);
Ben Lindstromd20b8552001-03-05 07:01:18 +0000375 close(s);
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000376 xfree(fdcon[s].c_namebase);
377 xfree(fdcon[s].c_output_name);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000378 if (fdcon[s].c_status == CS_KEYS)
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000379 xfree(fdcon[s].c_data);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000380 fdcon[s].c_status = CS_UNUSED;
381 TAILQ_REMOVE(&tq, &fdcon[s], c_link);
Ben Lindstromc1e04212001-03-05 07:04:38 +0000382 FD_CLR(s, read_wait);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000383 ncon--;
384}
385
386void
387contouch(int s)
388{
389 TAILQ_REMOVE(&tq, &fdcon[s], c_link);
390 gettimeofday(&fdcon[s].c_tv, NULL);
391 fdcon[s].c_tv.tv_sec += timeout;
392 TAILQ_INSERT_TAIL(&tq, &fdcon[s], c_link);
393}
394
395int
396conrecycle(int s)
397{
398 int ret;
399 con *c = &fdcon[s];
400 char *iname, *oname;
401
402 iname = xstrdup(c->c_namelist);
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000403 oname = xstrdup(c->c_output_name);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000404 confree(s);
405 ret = conalloc(iname, oname);
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000406 xfree(iname);
407 xfree(oname);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000408 return (ret);
409}
410
411void
412congreet(int s)
413{
Ben Lindstrom884a4ac2001-03-06 03:33:04 +0000414 char buf[80], *cp;
415 size_t bufsiz;
Ben Lindstrome21c4ad2001-03-07 01:23:30 +0000416 int n = 0;
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000417 con *c = &fdcon[s];
418
Ben Lindstrom884a4ac2001-03-06 03:33:04 +0000419 bufsiz = sizeof(buf);
420 cp = buf;
421 while (bufsiz-- && (n = read(s, cp, 1)) == 1 && *cp != '\n' && *cp != '\r')
422 cp++;
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000423 if (n < 0) {
424 if (errno != ECONNREFUSED)
425 error("read (%s): %s", c->c_name, strerror(errno));
426 conrecycle(s);
427 return;
428 }
Ben Lindstrom884a4ac2001-03-06 03:33:04 +0000429 if (*cp != '\n' && *cp != '\r') {
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000430 error("%s: bad greeting", c->c_name);
431 confree(s);
432 return;
433 }
Ben Lindstrom884a4ac2001-03-06 03:33:04 +0000434 *cp = '\0';
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000435 fprintf(stderr, "# %s %s\n", c->c_name, buf);
436 n = snprintf(buf, sizeof buf, "SSH-1.5-OpenSSH-keyscan\r\n");
Ben Lindstromd20b8552001-03-05 07:01:18 +0000437 if (atomicio(write, s, buf, n) != n) {
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000438 error("write (%s): %s", c->c_name, strerror(errno));
439 confree(s);
440 return;
441 }
442 c->c_status = CS_SIZE;
443 contouch(s);
444}
445
446void
447conread(int s)
448{
449 int n;
450 con *c = &fdcon[s];
451
452 if (c->c_status == CS_CON) {
453 congreet(s);
454 return;
455 }
456 n = read(s, c->c_data + c->c_off, c->c_len - c->c_off);
457 if (n < 0) {
458 error("read (%s): %s", c->c_name, strerror(errno));
459 confree(s);
460 return;
461 }
462 c->c_off += n;
463
464 if (c->c_off == c->c_len)
465 switch (c->c_status) {
466 case CS_SIZE:
467 c->c_plen = htonl(c->c_plen);
468 c->c_len = c->c_plen + 8 - (c->c_plen & 7);
469 c->c_off = 0;
470 c->c_data = xmalloc(c->c_len);
471 c->c_status = CS_KEYS;
472 break;
473 case CS_KEYS:
474 keyprint(c->c_name, c->c_output_name, c->c_data, c->c_plen);
475 confree(s);
476 return;
477 break;
478 default:
Kevin Stevesfa72dda2000-12-15 18:39:12 +0000479 fatal("conread: invalid status %d", c->c_status);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000480 break;
481 }
482
483 contouch(s);
484}
485
486void
487conloop(void)
488{
Ben Lindstromc1e04212001-03-05 07:04:38 +0000489 fd_set *r, *e;
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000490 struct timeval seltime, now;
491 int i;
492 con *c;
493
494 gettimeofday(&now, NULL);
495 c = tq.tqh_first;
496
Ben Lindstromd20b8552001-03-05 07:01:18 +0000497 if (c && (c->c_tv.tv_sec > now.tv_sec ||
498 (c->c_tv.tv_sec == now.tv_sec && c->c_tv.tv_usec > now.tv_usec))) {
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000499 seltime = c->c_tv;
500 seltime.tv_sec -= now.tv_sec;
501 seltime.tv_usec -= now.tv_usec;
Ben Lindstromc791beb2001-02-10 23:18:11 +0000502 if (seltime.tv_usec < 0) {
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000503 seltime.tv_usec += 1000000;
504 seltime.tv_sec--;
505 }
506 } else
507 seltime.tv_sec = seltime.tv_usec = 0;
508
Ben Lindstromc1e04212001-03-05 07:04:38 +0000509 r = xmalloc(read_wait_size);
510 memcpy(r, read_wait, read_wait_size);
511 e = xmalloc(read_wait_size);
512 memcpy(e, read_wait, read_wait_size);
513
514 while (select(maxfd, r, NULL, e, &seltime) == -1 &&
Ben Lindstromf9452512001-02-15 03:12:08 +0000515 (errno == EAGAIN || errno == EINTR))
516 ;
517
Ben Lindstromd20b8552001-03-05 07:01:18 +0000518 for (i = 0; i < maxfd; i++) {
Ben Lindstromc1e04212001-03-05 07:04:38 +0000519 if (FD_ISSET(i, e)) {
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000520 error("%s: exception!", fdcon[i].c_name);
521 confree(i);
Ben Lindstromc1e04212001-03-05 07:04:38 +0000522 } else if (FD_ISSET(i, r))
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000523 conread(i);
Ben Lindstromd20b8552001-03-05 07:01:18 +0000524 }
Ben Lindstromc1e04212001-03-05 07:04:38 +0000525 xfree(r);
526 xfree(e);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000527
528 c = tq.tqh_first;
Ben Lindstromd20b8552001-03-05 07:01:18 +0000529 while (c && (c->c_tv.tv_sec < now.tv_sec ||
530 (c->c_tv.tv_sec == now.tv_sec && c->c_tv.tv_usec < now.tv_usec))) {
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000531 int s = c->c_fd;
Ben Lindstromd20b8552001-03-05 07:01:18 +0000532
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000533 c = c->c_link.tqe_next;
534 conrecycle(s);
535 }
536}
537
538char *
539nexthost(int argc, char **argv)
540{
541 static Linebuf *lb;
542
543 for (;;) {
544 if (!lb) {
545 if (argno >= argc)
546 return (NULL);
547 if (argv[argno][0] != '-')
548 return (argv[argno++]);
549 if (!strcmp(argv[argno], "--")) {
550 if (++argno >= argc)
551 return (NULL);
552 return (argv[argno++]);
553 } else if (!strncmp(argv[argno], "-f", 2)) {
554 char *fname;
Ben Lindstromd20b8552001-03-05 07:01:18 +0000555
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000556 if (argv[argno][2])
557 fname = &argv[argno++][2];
558 else if (++argno >= argc) {
559 error("missing filename for `-f'");
560 return (NULL);
561 } else
562 fname = argv[argno++];
563 if (!strcmp(fname, "-"))
564 fname = NULL;
Kevin Stevesfc74af42000-12-06 22:47:55 +0000565 lb = Linebuf_alloc(fname, error);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000566 } else
Ben Lindstromd20b8552001-03-05 07:01:18 +0000567 error("ignoring invalid/misplaced option `%s'",
568 argv[argno++]);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000569 } else {
570 char *line;
Ben Lindstromd20b8552001-03-05 07:01:18 +0000571
Ben Lindstromc791beb2001-02-10 23:18:11 +0000572 line = Linebuf_getline(lb);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000573 if (line)
574 return (line);
575 Linebuf_free(lb);
576 lb = NULL;
577 }
578 }
579}
580
Kevin Steves935aa242001-03-05 19:46:37 +0000581void
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000582usage(void)
583{
Kevin Stevesfa72dda2000-12-15 18:39:12 +0000584 fatal("usage: %s [-t timeout] { [--] host | -f file } ...", __progname);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000585 return;
586}
587
588int
589main(int argc, char **argv)
590{
591 char *host = NULL;
592
Kevin Stevesec84dc12000-12-13 17:45:15 +0000593 __progname = get_progname(argv[0]);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000594 TAILQ_INIT(&tq);
595
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000596 if (argc <= argno)
597 usage();
598
599 if (argv[1][0] == '-' && argv[1][1] == 't') {
600 argno++;
601 if (argv[1][2])
602 timeout = atoi(&argv[1][2]);
603 else {
604 if (argno >= argc)
605 usage();
606 timeout = atoi(argv[argno++]);
607 }
608 if (timeout <= 0)
609 usage();
610 }
611 if (argc <= argno)
612 usage();
613
614 maxfd = fdlim_get(1);
615 if (maxfd < 0)
Kevin Stevesfa72dda2000-12-15 18:39:12 +0000616 fatal("%s: fdlim_get: bad value", __progname);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000617 if (maxfd > MAXMAXFD)
618 maxfd = MAXMAXFD;
Ben Lindstromd20b8552001-03-05 07:01:18 +0000619 if (MAXCON <= 0)
Kevin Stevesfa72dda2000-12-15 18:39:12 +0000620 fatal("%s: not enough file descriptors", __progname);
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000621 if (maxfd > fdlim_get(0))
622 fdlim_set(maxfd);
623 fdcon = xmalloc(maxfd * sizeof(con));
Ben Lindstromc791beb2001-02-10 23:18:11 +0000624 memset(fdcon, 0, maxfd * sizeof(con));
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000625
Ben Lindstromc1e04212001-03-05 07:04:38 +0000626 read_wait_size = howmany(maxfd, NFDBITS) * sizeof(fd_mask);
627 read_wait = xmalloc(read_wait_size);
628 memset(read_wait, 0, read_wait_size);
629
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000630 do {
Ben Lindstromd20b8552001-03-05 07:01:18 +0000631 while (ncon < MAXCON) {
Ben Lindstromb6434ae2000-12-05 01:15:09 +0000632 char *name;
633
634 host = nexthost(argc, argv);
635 if (host == NULL)
636 break;
637 name = strnnsep(&host, " \t\n");
638 conalloc(name, *host ? host : name);
639 }
640 conloop();
641 } while (host);
642 while (ncon > 0)
643 conloop();
644
645 return (0);
646}