?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / usr.bin / tftp / tftp.c
blob831b4d335a630c460d12c31bf05c97ce838a2efc
1 /* $NetBSD: tftp.c,v 1.29 2008/12/11 18:40:02 seanb Exp $ */
2
3 /*
4 * Copyright (c) 1983, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 #ifndef lint
34 #if 0
35 static char sccsid[] = "@(#)tftp.c 8.1 (Berkeley) 6/6/93";
36 #else
37 __RCSID("$NetBSD: tftp.c,v 1.29 2008/12/11 18:40:02 seanb Exp $");
38 #endif
39 #endif /* not lint */
40
41 /* Many bug fixes are from Jim Guyton <guyton@rand-unix> */
42
43 /*
44 * TFTP User Program -- Protocol Machines
45 */
46 #include <sys/types.h>
47 #include <sys/param.h>
48 #include <sys/socket.h>
49 #include <sys/stat.h>
50 #include <sys/time.h>
51
52 #include <netinet/in.h>
53
54 #include <arpa/tftp.h>
55 #include <arpa/inet.h>
56
57 #include <err.h>
58 #include <errno.h>
59 #include <setjmp.h>
60 #include <signal.h>
61 #include <stdio.h>
62 #include <stdlib.h>
63 #include <string.h>
64 #include <unistd.h>
65 #include <netdb.h>
66
67 #include "extern.h"
68 #include "tftpsubs.h"
69
70 char ackbuf[PKTSIZE];
71 int timeout;
72 jmp_buf toplevel;
73 jmp_buf timeoutbuf;
74
75 static void nak __P((int, struct sockaddr *));
76 static int makerequest __P((int, const char *, struct tftphdr *, const char *, off_t));
77 static void printstats __P((const char *, unsigned long));
78 static void startclock __P((void));
79 static void stopclock __P((void));
80 static void timer __P((int));
81 static void tpacket __P((const char *, struct tftphdr *, int));
82 static int cmpport __P((struct sockaddr *, struct sockaddr *));
83
84 static void get_options(struct tftphdr *, int);
85 static int tftp_igmp_join(void);
86 static void tftp_igmp_leave(int);
87
88 static void
89 get_options(struct tftphdr *ap, int size)
90 {
91 unsigned long val;
92 char *opt, *endp, *nextopt, *valp;
93 int l;
94
95 size -= 2; /* skip over opcode */
96 opt = ap->th_stuff;
97 endp = opt + size - 1;
98 *endp = '\0';
99
100 while (opt < endp) {
101 int ismulticast;
102 l = strlen(opt) + 1;
103 valp = opt + l;
104 ismulticast = !strcasecmp(opt, "multicast");
105 if (valp < endp) {
106 val = strtoul(valp, NULL, 10);
107 l = strlen(valp) + 1;
108 nextopt = valp + l;
109 if (!ismulticast) {
110 if (val == ULONG_MAX && errno == ERANGE) {
111 /* Report illegal value */
112 opt = nextopt;
113 continue;
114 }
115 }
116 } else {
117 /* Badly formed OACK */
118 break;
119 }
120 if (strcmp(opt, "tsize") == 0) {
121 /* cool, but we'll ignore it */
122 } else if (strcmp(opt, "timeout") == 0) {
123 if (val >= 1 && val <= 255) {
124 rexmtval = val;
125 } else {
126 /* Report error? */
127 }
128 } else if (strcmp(opt, "blksize") == 0) {
129 if (val >= 8 && val <= MAXSEGSIZE) {
130 blksize = val;
131 } else {
132 /* Report error? */
133 }
134 } else if (ismulticast) {
135 char multicast[24];
136 char *pmulticast;
137 char *addr;
138
139 strlcpy(multicast, valp, sizeof(multicast));
140 pmulticast = multicast;
141 addr = strsep(&pmulticast, ",");
142 if (pmulticast == NULL)
143 continue; /* Report error? */
144 mcport = atoi(strsep(&pmulticast, ","));
145 if (pmulticast == NULL)
146 continue; /* Report error? */
147 mcmasterslave = atoi(pmulticast);
148 mcaddr = inet_addr(addr);
149 if (mcaddr == INADDR_NONE)
150 continue; /* Report error? */
151 } else {
152 /* unknown option */
153 }
154 opt = nextopt;
155 }
156 }
157
158 static int
159 tftp_igmp_join(void)
160 {
161 struct ip_mreq req;
162 struct sockaddr_in s;
163 int fd, rv;
164
165 memset(&req, 0, sizeof(struct ip_mreq));
166 req.imr_multiaddr.s_addr = mcaddr;
167 req.imr_interface.s_addr = INADDR_ANY;
168
169 fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
170 if (fd < 0) {
171 perror("socket");
172 return fd;
173 }
174
175 memset(&s, 0, sizeof(struct sockaddr_in));
176 s.sin_family = AF_INET;
177 s.sin_port = htons(mcport);
178 s.sin_len = sizeof(struct sockaddr_in);
179 rv = bind(fd, (struct sockaddr *)&s, sizeof(struct sockaddr_in));
180 if (rv < 0) {
181 perror("bind");
182 close(fd);
183 return rv;
184 }
185
186 rv = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &req,
187 sizeof(struct ip_mreq));
188 if (rv < 0) {
189 perror("setsockopt");
190 close(fd);
191 return rv;
192 }
193
194 return fd;
195 }
196
197 static void
198 tftp_igmp_leave(int fd)
199 {
200 struct ip_mreq req;
201 int rv;
202
203 memset(&req, 0, sizeof(struct ip_mreq));
204 req.imr_multiaddr.s_addr = mcaddr;
205 req.imr_interface.s_addr = INADDR_ANY;
206
207 rv = setsockopt(fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, &req,
208 sizeof(struct ip_mreq));
209 if (rv < 0)
210 perror("setsockopt");
211
212 close(fd);
213
214 return;
215 }
216
217 /*
218 * Send the requested file.
219 */
220 void
221 sendfile(fd, name, mode)
222 int fd;
223 char *name;
224 char *mode;
225 {
226 struct tftphdr *ap; /* data and ack packets */
227 struct tftphdr *dp;
228 int j, n;
229 volatile unsigned int block;
230 volatile int size, convert;
231 volatile unsigned long amount;
232 struct sockaddr_storage from;
233 struct stat sbuf;
234 volatile off_t filesize = 0;
235 socklen_t fromlen;
236 FILE *file;
237 struct sockaddr_storage peer;
238 struct sockaddr_storage serv; /* valid server port number */
239
240 startclock(); /* start stat's clock */
241 dp = r_init(); /* reset fillbuf/read-ahead code */
242 ap = (struct tftphdr *)(void *)ackbuf;
243 if (tsize) {
244 if (fstat(fd, &sbuf) == 0) {
245 filesize = sbuf.st_size;
246 } else {
247 filesize = -1ULL;
248 }
249 }
250 file = fdopen(fd, "r");
251 convert = !strcmp(mode, "netascii");
252 block = 0;
253 amount = 0;
254 (void)memcpy(&peer, &peeraddr, (size_t)peeraddr.ss_len);
255 (void)memset(&serv, 0, sizeof(serv));
256
257 (void)signal(SIGALRM, timer);
258 do {
259 if (block == 0)
260 size = makerequest(WRQ, name, dp, mode, filesize) - 4;
261 else {
262 /* size = read(fd, dp->th_data, SEGSIZE); */
263 size = readit(file, &dp, blksize, convert);
264 if (size < 0) {
265 nak(errno + 100, (struct sockaddr *)(void *)&peer);
266 break;
267 }
268 dp->th_opcode = htons((u_short)DATA);
269 dp->th_block = htons((u_short)block);
270 }
271 timeout = 0;
272 (void) setjmp(timeoutbuf);
273 send_data:
274 if (trace)
275 tpacket("sent", dp, size + 4);
276 n = sendto(f, dp, (socklen_t)(size + 4), 0,
277 (struct sockaddr *)(void *)&peer, (socklen_t)peer.ss_len);
278 if (n != size + 4) {
279 warn("sendto");
280 goto abort;
281 }
282 if (block)
283 read_ahead(file, blksize, convert);
284 for ( ; ; ) {
285 (void)alarm(rexmtval);
286 do {
287 int curf;
288 fromlen = sizeof(from);
289 if (mcaddr != INADDR_NONE)
290 curf = mf;
291 else
292 curf = f;
293 n = recvfrom(curf, ackbuf, sizeof(ackbuf), 0,
294 (struct sockaddr *)(void *)&from, &fromlen);
295 } while (n <= 0);
296 (void)alarm(0);
297 if (n < 0) {
298 warn("recvfrom");
299 goto abort;
300 }
301 if (!serv.ss_family)
302 serv = from;
303 else if (!cmpport((struct sockaddr *)(void *)&serv,
304 (struct sockaddr *)(void *)&from)) {
305 warn("server port mismatch");
306 goto abort;
307 }
308 peer = from;
309 if (trace)
310 tpacket("received", ap, n);
311 /* should verify packet came from server */
312 ap->th_opcode = ntohs(ap->th_opcode);
313 if (ap->th_opcode == ERROR) {
314 (void)printf("Error code %d: %s\n", ap->th_code,
315 ap->th_msg);
316 goto abort;
317 }
318 if (ap->th_opcode == ACK) {
319 ap->th_block = ntohs(ap->th_block);
320
321 if (ap->th_block == 0) {
322 /*
323 * If the extended options are enabled,
324 * the server just refused 'em all.
325 * The only one that _really_
326 * matters is blksize, but we'll
327 * clear timeout and mcaddr, too.
328 */
329 blksize = def_blksize;
330 rexmtval = def_rexmtval;
331 mcaddr = INADDR_NONE;
332 }
333 if (ap->th_block == block) {
334 break;
335 }
336 /* On an error, try to synchronize
337 * both sides.
338 */
339 j = synchnet(f, blksize+4);
340 if (j && trace) {
341 (void)printf("discarded %d packets\n",
342 j);
343 }
344 if (ap->th_block == (block-1)) {
345 goto send_data;
346 }
347 }
348 if (ap->th_opcode == OACK) {
349 if (block == 0) {
350 blksize = def_blksize;
351 rexmtval = def_rexmtval;
352 mcaddr = INADDR_NONE;
353 get_options(ap, n);
354 break;
355 }
356 }
357 }
358 if (block > 0)
359 amount += size;
360 block++;
361 } while ((size_t)size == blksize || block == 1);
362 abort:
363 (void)fclose(file);
364 stopclock();
365 if (amount > 0)
366 printstats("Sent", amount);
367 }
368
369 /*
370 * Receive a file.
371 */
372 void
373 recvfile(fd, name, mode)
374 int fd;
375 char *name;
376 char *mode;
377 {
378 struct tftphdr *ap;
379 struct tftphdr *dp;
380 int j, n;
381 volatile int oack = 0;
382 volatile unsigned int block;
383 volatile int size, firsttrip;
384 volatile unsigned long amount;
385 struct sockaddr_storage from;
386 socklen_t fromlen;
387 volatile size_t readlen;
388 FILE *file;
389 volatile int convert; /* true if converting crlf -> lf */
390 struct sockaddr_storage peer;
391 struct sockaddr_storage serv; /* valid server port number */
392
393 startclock();
394 dp = w_init();
395 ap = (struct tftphdr *)(void *)ackbuf;
396 file = fdopen(fd, "w");
397 convert = !strcmp(mode, "netascii");
398 block = 1;
399 firsttrip = 1;
400 amount = 0;
401 (void)memcpy(&peer, &peeraddr, (size_t)peeraddr.ss_len);
402 (void)memset(&serv, 0, sizeof(serv));
403
404 (void)signal(SIGALRM, timer);
405 do {
406 if (firsttrip) {
407 size = makerequest(RRQ, name, ap, mode, (off_t)0);
408 readlen = PKTSIZE;
409 firsttrip = 0;
410 } else {
411 ap->th_opcode = htons((u_short)ACK);
412 ap->th_block = htons((u_short)(block));
413 readlen = blksize+4;
414 size = 4;
415 block++;
416 }
417 timeout = 0;
418 (void) setjmp(timeoutbuf);
419 send_ack:
420 if (trace)
421 tpacket("sent", ap, size);
422 if (sendto(f, ackbuf, (socklen_t)size, 0,
423 (struct sockaddr *)(void *)&peer,
424 (socklen_t)peer.ss_len) != size) {
425 (void)alarm(0);
426 warn("sendto");
427 goto abort;
428 }
429 skip_ack:
430 if (write_behind(file, convert) == -1)
431 goto abort;
432 for ( ; ; ) {
433 (void)alarm(rexmtval);
434 do {
435 int readfd;
436 if (mf > 0)
437 readfd = mf;
438 else
439 readfd = f;
440 fromlen = sizeof(from);
441 n = recvfrom(readfd, dp, readlen, 0,
442 (struct sockaddr *)(void *)&from, &fromlen);
443 } while (n <= 0);
444 (void)alarm(0);
445 if (n < 0) {
446 warn("recvfrom");
447 goto abort;
448 }
449 if (!serv.ss_family)
450 serv = from;
451 else if (!cmpport((struct sockaddr *)(void *)&serv,
452 (struct sockaddr *)(void *)&from)) {
453 warn("server port mismatch");
454 goto abort;
455 }
456 peer = from;
457 if (trace)
458 tpacket("received", dp, n);
459 /* should verify client address */
460 dp->th_opcode = ntohs(dp->th_opcode);
461 if (dp->th_opcode == ERROR) {
462 (void)printf("Error code %d: %s\n", dp->th_code,
463 dp->th_msg);
464 goto abort;
465 }
466 if (dp->th_opcode == DATA) {
467 dp->th_block = ntohs(dp->th_block);
468
469 if (dp->th_block == 1 && !oack) {
470 /* no OACK, revert to defaults */
471 blksize = def_blksize;
472 rexmtval = def_rexmtval;
473 }
474 if (dp->th_block == block) {
475 break; /* have next packet */
476 }
477 /* On an error, try to synchronize
478 * both sides.
479 */
480 j = synchnet(f, blksize);
481 if (j && trace) {
482 (void)printf("discarded %d packets\n", j);
483 }
484 if (dp->th_block == (block-1)) {
485 goto send_ack; /* resend ack */
486 }
487 }
488 if (dp->th_opcode == OACK) {
489 if (block == 1) {
490 oack = 1;
491 blksize = def_blksize;
492 rexmtval = def_rexmtval;
493 get_options(dp, n);
494 ap->th_opcode = htons(ACK);
495 ap->th_block = 0;
496 readlen = blksize+4;
497 size = 4;
498 if (mcaddr != INADDR_NONE) {
499 mf = tftp_igmp_join();
500 if (mf < 0)
501 goto abort;
502 if (mcmasterslave == 0)
503 goto skip_ack;
504 }
505 goto send_ack;
506 }
507 }
508 }
509 /* size = write(fd, dp->th_data, n - 4); */
510 size = writeit(file, &dp, n - 4, convert);
511 if (size < 0) {
512 nak(errno + 100, (struct sockaddr *)(void *)&peer);
513 break;
514 }
515 amount += size;
516 } while ((size_t)size == blksize);
517 abort: /* ok to ack, since user */
518 ap->th_opcode = htons((u_short)ACK); /* has seen err msg */
519 ap->th_block = htons((u_short)block);
520 if (mcaddr != INADDR_NONE && mf >= 0) {
521 tftp_igmp_leave(mf);
522 mf = -1;
523 }
524 (void) sendto(f, ackbuf, 4, 0, (struct sockaddr *)(void *)&peer,
525 (socklen_t)peer.ss_len);
526 /*
527 * flush last buffer
528 * We do not check for failure because last buffer
529 * can be empty, thus returning an error.
530 * XXX maybe we should fix 'write_behind' instead.
531 */
532 (void)write_behind(file, convert);
533 (void)fclose(file);
534 stopclock();
535 if (amount > 0)
536 printstats("Received", amount);
537 }
538
539 static int
540 makerequest(request, name, tp, mode, filesize)
541 int request;
542 const char *name;
543 struct tftphdr *tp;
544 const char *mode;
545 off_t filesize;
546 {
547 char *cp;
548
549 tp->th_opcode = htons((u_short)request);
550 #ifndef __SVR4
551 cp = tp->th_stuff;
552 #else
553 cp = (void *)&tp->th_stuff;
554 #endif
555 (void)strcpy(cp, name);
556 cp += strlen(name);
557 *cp++ = '\0';
558 (void)strcpy(cp, mode);
559 cp += strlen(mode);
560 *cp++ = '\0';
561 if (tsize) {
562 (void)strcpy(cp, "tsize");
563 cp += strlen(cp);
564 *cp++ = '\0';
565 (void)sprintf(cp, "%lu", (unsigned long) filesize);
566 cp += strlen(cp);
567 *cp++ = '\0';
568 }
569 if (tout) {
570 (void)strcpy(cp, "timeout");
571 cp += strlen(cp);
572 *cp++ = '\0';
573 (void)sprintf(cp, "%d", rexmtval);
574 cp += strlen(cp);
575 *cp++ = '\0';
576 }
577 if (blksize != SEGSIZE) {
578 (void)strcpy(cp, "blksize");
579 cp += strlen(cp);
580 *cp++ = '\0';
581 (void)sprintf(cp, "%zd", blksize);
582 cp += strlen(cp);
583 *cp++ = '\0';
584 }
585 return (cp - (char *)(void *)tp);
586 }
587
588 const struct errmsg {
589 int e_code;
590 const char *e_msg;
591 } errmsgs[] = {
592 { EUNDEF, "Undefined error code" },
593 { ENOTFOUND, "File not found" },
594 { EACCESS, "Access violation" },
595 { ENOSPACE, "Disk full or allocation exceeded" },
596 { EBADOP, "Illegal TFTP operation" },
597 { EBADID, "Unknown transfer ID" },
598 { EEXISTS, "File already exists" },
599 { ENOUSER, "No such user" },
600 { EOPTNEG, "Option negotiation failed" },
601 { -1, 0 }
602 };
603
604 /*
605 * Send a nak packet (error message).
606 * Error code passed in is one of the
607 * standard TFTP codes, or a UNIX errno
608 * offset by 100.
609 */
610 static void
611 nak(error, peer)
612 int error;
613 struct sockaddr *peer;
614 {
615 const struct errmsg *pe;
616 struct tftphdr *tp;
617 int length;
618 size_t msglen;
619
620 tp = (struct tftphdr *)(void *)ackbuf;
621 tp->th_opcode = htons((u_short)ERROR);
622 msglen = sizeof(ackbuf) - (&tp->th_msg[0] - ackbuf);
623 for (pe = errmsgs; pe->e_code >= 0; pe++)
624 if (pe->e_code == error)
625 break;
626 if (pe->e_code < 0) {
627 tp->th_code = EUNDEF;
628 (void)strlcpy(tp->th_msg, strerror(error - 100), msglen);
629 } else {
630 tp->th_code = htons((u_short)error);
631 (void)strlcpy(tp->th_msg, pe->e_msg, msglen);
632 }
633 length = strlen(tp->th_msg);
634 msglen = &tp->th_msg[length + 1] - ackbuf;
635 if (trace)
636 tpacket("sent", tp, (int)msglen);
637 if ((size_t)sendto(f, ackbuf, msglen, 0, peer, (socklen_t)peer->sa_len) != msglen)
638 warn("nak");
639 }
640
641 static void
642 tpacket(s, tp, n)
643 const char *s;
644 struct tftphdr *tp;
645 int n;
646 {
647 static const char *opcodes[] =
648 { "#0", "RRQ", "WRQ", "DATA", "ACK", "ERROR", "OACK" };
649 char *cp, *file, *endp, *opt = NULL;
650 const char *spc;
651 u_short op = ntohs(tp->th_opcode);
652 int i, o;
653
654 if (op < RRQ || op > OACK)
655 (void)printf("%s opcode=%x ", s, op);
656 else
657 (void)printf("%s %s ", s, opcodes[op]);
658 switch (op) {
659
660 case RRQ:
661 case WRQ:
662 n -= 2;
663 #ifndef __SVR4
664 cp = tp->th_stuff;
665 #else
666 cp = (void *) &tp->th_stuff;
667 #endif
668 endp = cp + n - 1;
669 if (*endp != '\0') { /* Shouldn't happen, but... */
670 *endp = '\0';
671 }
672 file = cp;
673 cp = strchr(cp, '\0') + 1;
674 (void)printf("<file=%s, mode=%s", file, cp);
675 cp = strchr(cp, '\0') + 1;
676 o = 0;
677 while (cp < endp) {
678 i = strlen(cp) + 1;
679 if (o) {
680 (void)printf(", %s=%s", opt, cp);
681 } else {
682 opt = cp;
683 }
684 o = (o+1) % 2;
685 cp += i;
686 }
687 (void)printf(">\n");
688 break;
689
690 case DATA:
691 (void)printf("<block=%d, %d bytes>\n", ntohs(tp->th_block), n - 4);
692 break;
693
694 case ACK:
695 (void)printf("<block=%d>\n", ntohs(tp->th_block));
696 break;
697
698 case ERROR:
699 (void)printf("<code=%d, msg=%s>\n", ntohs(tp->th_code), tp->th_msg);
700 break;
701
702 case OACK:
703 o = 0;
704 n -= 2;
705 cp = tp->th_stuff;
706 endp = cp + n - 1;
707 if (*endp != '\0') { /* Shouldn't happen, but... */
708 *endp = '\0';
709 }
710 (void)printf("<");
711 spc = "";
712 while (cp < endp) {
713 i = strlen(cp) + 1;
714 if (o) {
715 (void)printf("%s%s=%s", spc, opt, cp);
716 spc = ", ";
717 } else {
718 opt = cp;
719 }
720 o = (o+1) % 2;
721 cp += i;
722 }
723 (void)printf(">\n");
724 break;
725 }
726 }
727
728 struct timeval tstart;
729 struct timeval tstop;
730
731 static void
732 startclock()
733 {
734
735 (void)gettimeofday(&tstart, NULL);
736 }
737
738 static void
739 stopclock()
740 {
741
742 (void)gettimeofday(&tstop, NULL);
743 }
744
745 static void
746 printstats(direction, amount)
747 const char *direction;
748 unsigned long amount;
749 {
750 double delta;
751
752 /* compute delta in 1/10's second units */
753 delta = ((tstop.tv_sec*10.)+(tstop.tv_usec/100000)) -
754 ((tstart.tv_sec*10.)+(tstart.tv_usec/100000));
755 delta = delta/10.; /* back to seconds */
756 (void)printf("%s %ld bytes in %.1f seconds", direction, amount, delta);
757 if (verbose)
758 (void)printf(" [%.0f bits/sec]", (amount*8.)/delta);
759 (void)putchar('\n');
760 }
761
762 static void
763 /*ARGSUSED*/
764 timer(sig)
765 int sig;
766 {
767
768 timeout += rexmtval;
769 if (timeout >= maxtimeout) {
770 (void)printf("Transfer timed out.\n");
771 longjmp(toplevel, -1);
772 }
773 longjmp(timeoutbuf, 1);
774 }
775
776 static int
777 cmpport(sa, sb)
778 struct sockaddr *sa;
779 struct sockaddr *sb;
780 {
781 char a[NI_MAXSERV], b[NI_MAXSERV];
782
783 if (getnameinfo(sa, (socklen_t)sa->sa_len, NULL, 0, a, sizeof(a), NI_NUMERICSERV))
784 return 0;
785 if (getnameinfo(sb, (socklen_t)sb->sa_len, NULL, 0, b, sizeof(b), NI_NUMERICSERV))
786 return 0;
787 if (strcmp(a, b) != 0)
788 return 0;
789
790 return 1;
791 }
NetBSD on the FriendlyARM MINI2440