1 |
/* |
2 |
* Copyright (c) 1985, 1989, 1993, 1994 |
3 |
* The Regents of the University of California. All rights reserved. |
4 |
* |
5 |
* Redistribution and use in source and binary forms, with or without |
6 |
* modification, are permitted provided that the following conditions |
7 |
* are met: |
8 |
* 1. Redistributions of source code must retain the above copyright |
9 |
* notice, this list of conditions and the following disclaimer. |
10 |
* 2. Redistributions in binary form must reproduce the above copyright |
11 |
* notice, this list of conditions and the following disclaimer in the |
12 |
* documentation and/or other materials provided with the distribution. |
13 |
* 3. All advertising materials mentioning features or use of this software |
14 |
* must display the following acknowledgement: |
15 |
* This product includes software developed by the University of |
16 |
* California, Berkeley and its contributors. |
17 |
* 4. Neither the name of the University nor the names of its contributors |
18 |
* may be used to endorse or promote products derived from this software |
19 |
* without specific prior written permission. |
20 |
* |
21 |
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
22 |
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
23 |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
24 |
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
25 |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
26 |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
27 |
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
28 |
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
29 |
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
30 |
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
31 |
* SUCH DAMAGE. |
32 |
*/ |
33 |
|
34 |
#include "ftp_locl.h" |
35 |
RCSID ("$Id$"); |
36 |
|
37 |
struct sockaddr_storage hisctladdr_ss; |
38 |
struct sockaddr *hisctladdr = (struct sockaddr *)&hisctladdr_ss; |
39 |
struct sockaddr_storage data_addr_ss; |
40 |
struct sockaddr *data_addr = (struct sockaddr *)&data_addr_ss; |
41 |
struct sockaddr_storage myctladdr_ss; |
42 |
struct sockaddr *myctladdr = (struct sockaddr *)&myctladdr_ss; |
43 |
int data = -1; |
44 |
int abrtflag = 0; |
45 |
jmp_buf ptabort; |
46 |
int ptabflg; |
47 |
int ptflag = 0; |
48 |
off_t restart_point = 0; |
49 |
|
50 |
|
51 |
FILE *cin, *cout; |
52 |
|
53 |
typedef void (*sighand) (int); |
54 |
|
55 |
char * |
56 |
hookup (const char *host, int port) |
57 |
{ |
58 |
static char hostnamebuf[MaxHostNameLen]; |
59 |
struct addrinfo *ai, *a; |
60 |
struct addrinfo hints; |
61 |
int error; |
62 |
char portstr[NI_MAXSERV]; |
63 |
socklen_t len; |
64 |
int s; |
65 |
|
66 |
memset (&hints, 0, sizeof(hints)); |
67 |
hints.ai_socktype = SOCK_STREAM; |
68 |
hints.ai_protocol = IPPROTO_TCP; |
69 |
hints.ai_flags = AI_CANONNAME; |
70 |
|
71 |
snprintf (portstr, sizeof(portstr), "%u", ntohs(port)); |
72 |
|
73 |
error = getaddrinfo (host, portstr, &hints, &ai); |
74 |
if (error) { |
75 |
warnx ("%s: %s", host, gai_strerror(error)); |
76 |
code = -1; |
77 |
return NULL; |
78 |
} |
79 |
strlcpy (hostnamebuf, host, sizeof(hostnamebuf)); |
80 |
hostname = hostnamebuf; |
81 |
|
82 |
s = -1; |
83 |
for (a = ai; a != NULL; a = a->ai_next) { |
84 |
s = socket (a->ai_family, a->ai_socktype, a->ai_protocol); |
85 |
if (s < 0) |
86 |
continue; |
87 |
|
88 |
if (a->ai_canonname != NULL) |
89 |
strlcpy (hostnamebuf, a->ai_canonname, sizeof(hostnamebuf)); |
90 |
|
91 |
memcpy (hisctladdr, a->ai_addr, a->ai_addrlen); |
92 |
|
93 |
error = connect (s, a->ai_addr, a->ai_addrlen); |
94 |
if (error < 0) { |
95 |
char addrstr[256]; |
96 |
|
97 |
if (getnameinfo (a->ai_addr, a->ai_addrlen, |
98 |
addrstr, sizeof(addrstr), |
99 |
NULL, 0, NI_NUMERICHOST) != 0) |
100 |
strlcpy (addrstr, "unknown address", sizeof(addrstr)); |
101 |
|
102 |
warn ("connect %s", addrstr); |
103 |
close (s); |
104 |
s = -1; |
105 |
continue; |
106 |
} |
107 |
break; |
108 |
} |
109 |
freeaddrinfo (ai); |
110 |
if (s < 0) { |
111 |
warnx ("failed to contact %s", host); |
112 |
code = -1; |
113 |
return NULL; |
114 |
} |
115 |
|
116 |
len = sizeof(myctladdr_ss); |
117 |
if (getsockname (s, myctladdr, &len) < 0) { |
118 |
warn ("getsockname"); |
119 |
code = -1; |
120 |
close (s); |
121 |
return NULL; |
122 |
} |
123 |
#ifdef IPTOS_LOWDELAY |
124 |
socket_set_tos (s, IPTOS_LOWDELAY); |
125 |
#endif |
126 |
cin = fdopen (s, "r"); |
127 |
cout = fdopen (s, "w"); |
128 |
if (cin == NULL || cout == NULL) { |
129 |
warnx ("fdopen failed."); |
130 |
if (cin) |
131 |
fclose (cin); |
132 |
if (cout) |
133 |
fclose (cout); |
134 |
code = -1; |
135 |
goto bad; |
136 |
} |
137 |
if (verbose) |
138 |
printf ("Connected to %s.\n", hostname); |
139 |
if (getreply (0) > 2) { /* read startup message from server */ |
140 |
if (cin) |
141 |
fclose (cin); |
142 |
if (cout) |
143 |
fclose (cout); |
144 |
code = -1; |
145 |
goto bad; |
146 |
} |
147 |
#if defined(SO_OOBINLINE) && defined(HAVE_SETSOCKOPT) |
148 |
{ |
149 |
int on = 1; |
150 |
|
151 |
if (setsockopt (s, SOL_SOCKET, SO_OOBINLINE, (char *) &on, sizeof (on)) |
152 |
< 0 && debug) { |
153 |
warn ("setsockopt"); |
154 |
} |
155 |
} |
156 |
#endif /* SO_OOBINLINE */ |
157 |
|
158 |
return (hostname); |
159 |
bad: |
160 |
close (s); |
161 |
return NULL; |
162 |
} |
163 |
|
164 |
int |
165 |
login (char *host) |
166 |
{ |
167 |
char tmp[80]; |
168 |
char defaultpass[128]; |
169 |
char *userstr, *pass, *acctstr; |
170 |
char *ruserstr, *rpass, *racctstr; |
171 |
int n, aflag = 0; |
172 |
|
173 |
char *myname = NULL; |
174 |
struct passwd *pw = k_getpwuid(getuid()); |
175 |
|
176 |
if (pw != NULL) |
177 |
myname = pw->pw_name; |
178 |
|
179 |
ruserstr = rpass = racctstr = NULL; |
180 |
|
181 |
if(sec_login(host)) |
182 |
printf("\n*** Using plaintext user and password ***\n\n"); |
183 |
else{ |
184 |
printf("Authentication successful.\n\n"); |
185 |
} |
186 |
|
187 |
if (ruserpassword (host, &ruserstr, &rpass, &racctstr) < 0) { |
188 |
code = -1; |
189 |
return (0); |
190 |
} |
191 |
userstr = ruserstr; |
192 |
pass = rpass; |
193 |
acctstr = racctstr; |
194 |
|
195 |
while (userstr == NULL) { |
196 |
if (myname) |
197 |
printf ("Name (%s:%s): ", host, myname); |
198 |
else |
199 |
printf ("Name (%s): ", host); |
200 |
*tmp = '\0'; |
201 |
if (fgets (tmp, sizeof (tmp) - 1, stdin) != NULL) |
202 |
tmp[strlen (tmp) - 1] = '\0'; |
203 |
if (*tmp == '\0') |
204 |
userstr = myname; |
205 |
else |
206 |
userstr = tmp; |
207 |
} |
208 |
strlcpy(username, userstr, sizeof(username)); |
209 |
if (ruserstr) |
210 |
free(ruserstr); |
211 |
|
212 |
n = command("USER %s", userstr); |
213 |
if (n == COMPLETE) |
214 |
n = command("PASS dummy"); /* DK: Compatibility with gssftp daemon */ |
215 |
else if(n == CONTINUE) { |
216 |
if (pass == NULL) { |
217 |
char prompt[128]; |
218 |
if(myname && |
219 |
(!strcmp(userstr, "ftp") || !strcmp(userstr, "anonymous"))) { |
220 |
snprintf(defaultpass, sizeof(defaultpass), |
221 |
"%s@%s", myname, mydomain); |
222 |
snprintf(prompt, sizeof(prompt), |
223 |
"Password (%s): ", defaultpass); |
224 |
} else if (sec_complete) { |
225 |
pass = myname; |
226 |
} else { |
227 |
*defaultpass = '\0'; |
228 |
snprintf(prompt, sizeof(prompt), "Password: "); |
229 |
} |
230 |
if (pass == NULL) { |
231 |
pass = defaultpass; |
232 |
UI_UTIL_read_pw_string (tmp, sizeof (tmp), prompt, 0); |
233 |
if (tmp[0]) |
234 |
pass = tmp; |
235 |
} |
236 |
} |
237 |
n = command ("PASS %s", pass); |
238 |
if (rpass) |
239 |
free(rpass); |
240 |
} |
241 |
if (n == CONTINUE) { |
242 |
aflag++; |
243 |
UI_UTIL_read_pw_string (tmp, sizeof(tmp), "Account:", 0); |
244 |
acctstr = tmp; |
245 |
n = command ("ACCT %s", acctstr); |
246 |
} |
247 |
if (n != COMPLETE) { |
248 |
if (racctstr) |
249 |
free(racctstr); |
250 |
warnx ("Login failed."); |
251 |
return (0); |
252 |
} |
253 |
if (!aflag && acctstr != NULL) |
254 |
command ("ACCT %s", acctstr); |
255 |
if (racctstr) |
256 |
free(racctstr); |
257 |
if (proxy) |
258 |
return (1); |
259 |
for (n = 0; n < macnum; ++n) { |
260 |
if (!strcmp("init", macros[n].mac_name)) { |
261 |
strlcpy (line, "$init", sizeof (line)); |
262 |
makeargv(); |
263 |
domacro(margc, margv); |
264 |
break; |
265 |
} |
266 |
} |
267 |
sec_set_protection_level (); |
268 |
return (1); |
269 |
} |
270 |
|
271 |
void |
272 |
cmdabort (int sig) |
273 |
{ |
274 |
|
275 |
printf ("\n"); |
276 |
fflush (stdout); |
277 |
abrtflag++; |
278 |
if (ptflag) |
279 |
longjmp (ptabort, 1); |
280 |
} |
281 |
|
282 |
int |
283 |
command (char *fmt,...) |
284 |
{ |
285 |
va_list ap; |
286 |
int r; |
287 |
sighand oldintr; |
288 |
|
289 |
abrtflag = 0; |
290 |
if (cout == NULL) { |
291 |
warn ("No control connection for command"); |
292 |
code = -1; |
293 |
return (0); |
294 |
} |
295 |
oldintr = signal(SIGINT, cmdabort); |
296 |
if(debug){ |
297 |
printf("---> "); |
298 |
if (strncmp("PASS ", fmt, 5) == 0) |
299 |
printf("PASS XXXX"); |
300 |
else { |
301 |
va_start(ap, fmt); |
302 |
vfprintf(stdout, fmt, ap); |
303 |
va_end(ap); |
304 |
} |
305 |
} |
306 |
va_start(ap, fmt); |
307 |
sec_vfprintf(cout, fmt, ap); |
308 |
va_end(ap); |
309 |
if(debug){ |
310 |
printf("\n"); |
311 |
fflush(stdout); |
312 |
} |
313 |
fprintf (cout, "\r\n"); |
314 |
fflush (cout); |
315 |
cpend = 1; |
316 |
r = getreply (!strcmp (fmt, "QUIT")); |
317 |
if (abrtflag && oldintr != SIG_IGN) |
318 |
(*oldintr) (SIGINT); |
319 |
signal (SIGINT, oldintr); |
320 |
return (r); |
321 |
} |
322 |
|
323 |
char reply_string[BUFSIZ]; /* last line of previous reply */ |
324 |
|
325 |
int |
326 |
getreply (int expecteof) |
327 |
{ |
328 |
char *p; |
329 |
char *lead_string; |
330 |
int c; |
331 |
struct sigaction sa, osa; |
332 |
char buf[8192]; |
333 |
int reply_code; |
334 |
int long_warn = 0; |
335 |
|
336 |
sigemptyset (&sa.sa_mask); |
337 |
sa.sa_flags = 0; |
338 |
sa.sa_handler = cmdabort; |
339 |
sigaction (SIGINT, &sa, &osa); |
340 |
|
341 |
p = buf; |
342 |
|
343 |
reply_code = 0; |
344 |
while (1) { |
345 |
c = getc (cin); |
346 |
switch (c) { |
347 |
case EOF: |
348 |
if (expecteof) { |
349 |
sigaction (SIGINT, &osa, NULL); |
350 |
code = 221; |
351 |
return 0; |
352 |
} |
353 |
lostpeer (0); |
354 |
if (verbose) { |
355 |
printf ("421 Service not available, " |
356 |
"remote server has closed connection\n"); |
357 |
fflush (stdout); |
358 |
} |
359 |
code = 421; |
360 |
return (4); |
361 |
case IAC: |
362 |
c = getc (cin); |
363 |
if (c == WILL || c == WONT) |
364 |
fprintf (cout, "%c%c%c", IAC, DONT, getc (cin)); |
365 |
if (c == DO || c == DONT) |
366 |
fprintf (cout, "%c%c%c", IAC, WONT, getc (cin)); |
367 |
continue; |
368 |
case '\n': |
369 |
*p++ = '\0'; |
370 |
if(isdigit((unsigned char)buf[0])){ |
371 |
sscanf(buf, "%d", &code); |
372 |
if(code == 631){ |
373 |
code = 0; |
374 |
sec_read_msg(buf, prot_safe); |
375 |
sscanf(buf, "%d", &code); |
376 |
lead_string = "S:"; |
377 |
} else if(code == 632){ |
378 |
code = 0; |
379 |
sec_read_msg(buf, prot_private); |
380 |
sscanf(buf, "%d", &code); |
381 |
lead_string = "P:"; |
382 |
}else if(code == 633){ |
383 |
code = 0; |
384 |
sec_read_msg(buf, prot_confidential); |
385 |
sscanf(buf, "%d", &code); |
386 |
lead_string = "C:"; |
387 |
}else if(sec_complete) |
388 |
lead_string = "!!"; |
389 |
else |
390 |
lead_string = ""; |
391 |
if(code != 0 && reply_code == 0) |
392 |
reply_code = code; |
393 |
if (verbose > 0 || (verbose > -1 && code > 499)) |
394 |
fprintf (stdout, "%s%s\n", lead_string, buf); |
395 |
if (code == reply_code && buf[3] == ' ') { |
396 |
strlcpy (reply_string, buf, sizeof(reply_string)); |
397 |
if (code >= 200) |
398 |
cpend = 0; |
399 |
sigaction (SIGINT, &osa, NULL); |
400 |
if (code == 421) |
401 |
lostpeer (0); |
402 |
#if 1 |
403 |
if (abrtflag && |
404 |
osa.sa_handler != cmdabort && |
405 |
osa.sa_handler != SIG_IGN) |
406 |
osa.sa_handler (SIGINT); |
407 |
#endif |
408 |
if (code == 227 || code == 229) { |
409 |
char *q; |
410 |
|
411 |
q = strchr (reply_string, '('); |
412 |
if (q) { |
413 |
q++; |
414 |
strlcpy(pasv, q, sizeof(pasv)); |
415 |
q = strrchr(pasv, ')'); |
416 |
if (q) |
417 |
*q = '\0'; |
418 |
} |
419 |
} |
420 |
return code / 100; |
421 |
} |
422 |
}else{ |
423 |
if(verbose > 0 || (verbose > -1 && code > 499)){ |
424 |
if(sec_complete) |
425 |
fprintf(stdout, "!!"); |
426 |
fprintf(stdout, "%s\n", buf); |
427 |
} |
428 |
} |
429 |
p = buf; |
430 |
long_warn = 0; |
431 |
continue; |
432 |
default: |
433 |
if(p < buf + sizeof(buf) - 1) |
434 |
*p++ = c; |
435 |
else if(long_warn == 0) { |
436 |
fprintf(stderr, "WARNING: incredibly long line received\n"); |
437 |
long_warn = 1; |
438 |
} |
439 |
} |
440 |
} |
441 |
|
442 |
} |
443 |
|
444 |
|
445 |
#if 0 |
446 |
int |
447 |
getreply (int expecteof) |
448 |
{ |
449 |
int c, n; |
450 |
int dig; |
451 |
int originalcode = 0, continuation = 0; |
452 |
sighand oldintr; |
453 |
int pflag = 0; |
454 |
char *cp, *pt = pasv; |
455 |
|
456 |
oldintr = signal (SIGINT, cmdabort); |
457 |
for (;;) { |
458 |
dig = n = code = 0; |
459 |
cp = reply_string; |
460 |
while ((c = getc (cin)) != '\n') { |
461 |
if (c == IAC) { /* handle telnet commands */ |
462 |
switch (c = getc (cin)) { |
463 |
case WILL: |
464 |
case WONT: |
465 |
c = getc (cin); |
466 |
fprintf (cout, "%c%c%c", IAC, DONT, c); |
467 |
fflush (cout); |
468 |
break; |
469 |
case DO: |
470 |
case DONT: |
471 |
c = getc (cin); |
472 |
fprintf (cout, "%c%c%c", IAC, WONT, c); |
473 |
fflush (cout); |
474 |
break; |
475 |
default: |
476 |
break; |
477 |
} |
478 |
continue; |
479 |
} |
480 |
dig++; |
481 |
if (c == EOF) { |
482 |
if (expecteof) { |
483 |
signal (SIGINT, oldintr); |
484 |
code = 221; |
485 |
return (0); |
486 |
} |
487 |
lostpeer (0); |
488 |
if (verbose) { |
489 |
printf ("421 Service not available, remote server has closed connection\n"); |
490 |
fflush (stdout); |
491 |
} |
492 |
code = 421; |
493 |
return (4); |
494 |
} |
495 |
if (c != '\r' && (verbose > 0 || |
496 |
(verbose > -1 && n == '5' && dig > 4))) { |
497 |
if (proxflag && |
498 |
(dig == 1 || dig == 5 && verbose == 0)) |
499 |
printf ("%s:", hostname); |
500 |
putchar (c); |
501 |
} |
502 |
if (dig < 4 && isdigit (c)) |
503 |
code = code * 10 + (c - '0'); |
504 |
if (!pflag && code == 227) |
505 |
pflag = 1; |
506 |
if (dig > 4 && pflag == 1 && isdigit (c)) |
507 |
pflag = 2; |
508 |
if (pflag == 2) { |
509 |
if (c != '\r' && c != ')') |
510 |
*pt++ = c; |
511 |
else { |
512 |
*pt = '\0'; |
513 |
pflag = 3; |
514 |
} |
515 |
} |
516 |
if (dig == 4 && c == '-') { |
517 |
if (continuation) |
518 |
code = 0; |
519 |
continuation++; |
520 |
} |
521 |
if (n == 0) |
522 |
n = c; |
523 |
if (cp < &reply_string[sizeof (reply_string) - 1]) |
524 |
*cp++ = c; |
525 |
} |
526 |
if (verbose > 0 || verbose > -1 && n == '5') { |
527 |
putchar (c); |
528 |
fflush (stdout); |
529 |
} |
530 |
if (continuation && code != originalcode) { |
531 |
if (originalcode == 0) |
532 |
originalcode = code; |
533 |
continue; |
534 |
} |
535 |
*cp = '\0'; |
536 |
if(sec_complete){ |
537 |
if(code == 631) |
538 |
sec_read_msg(reply_string, prot_safe); |
539 |
else if(code == 632) |
540 |
sec_read_msg(reply_string, prot_private); |
541 |
else if(code == 633) |
542 |
sec_read_msg(reply_string, prot_confidential); |
543 |
n = code / 100 + '0'; |
544 |
} |
545 |
if (n != '1') |
546 |
cpend = 0; |
547 |
signal (SIGINT, oldintr); |
548 |
if (code == 421 || originalcode == 421) |
549 |
lostpeer (0); |
550 |
if (abrtflag && oldintr != cmdabort && oldintr != SIG_IGN) |
551 |
(*oldintr) (SIGINT); |
552 |
return (n - '0'); |
553 |
} |
554 |
} |
555 |
|
556 |
#endif |
557 |
|
558 |
int |
559 |
empty (fd_set * mask, int sec) |
560 |
{ |
561 |
struct timeval t; |
562 |
|
563 |
t.tv_sec = sec; |
564 |
t.tv_usec = 0; |
565 |
return (select (FD_SETSIZE, mask, NULL, NULL, &t)); |
566 |
} |
567 |
|
568 |
jmp_buf sendabort; |
569 |
|
570 |
static RETSIGTYPE |
571 |
abortsend (int sig) |
572 |
{ |
573 |
|
574 |
mflag = 0; |
575 |
abrtflag = 0; |
576 |
printf ("\nsend aborted\nwaiting for remote to finish abort\n"); |
577 |
fflush (stdout); |
578 |
longjmp (sendabort, 1); |
579 |
} |
580 |
|
581 |
#define HASHBYTES 1024 |
582 |
|
583 |
static int |
584 |
copy_stream (FILE * from, FILE * to) |
585 |
{ |
586 |
static size_t bufsize; |
587 |
static char *buf; |
588 |
int n; |
589 |
int bytes = 0; |
590 |
int werr = 0; |
591 |
int hashbytes = HASHBYTES; |
592 |
struct stat st; |
593 |
|
594 |
#if defined(HAVE_MMAP) && !defined(NO_MMAP) |
595 |
void *chunk; |
596 |
size_t off; |
597 |
|
598 |
#define BLOCKSIZE (1024 * 1024 * 10) |
599 |
|
600 |
#ifndef MAP_FAILED |
601 |
#define MAP_FAILED (-1) |
602 |
#endif |
603 |
|
604 |
if (fstat (fileno (from), &st) == 0 && S_ISREG (st.st_mode)) { |
605 |
/* |
606 |
* mmap zero bytes has potential of loosing, don't do it. |
607 |
*/ |
608 |
if (st.st_size == 0) |
609 |
return 0; |
610 |
off = 0; |
611 |
while (off != st.st_size) { |
612 |
size_t len; |
613 |
ssize_t res; |
614 |
|
615 |
len = st.st_size - off; |
616 |
if (len > BLOCKSIZE) |
617 |
len = BLOCKSIZE; |
618 |
|
619 |
chunk = mmap (0, len, PROT_READ, MAP_SHARED, fileno (from), off); |
620 |
if (chunk == (void *) MAP_FAILED) { |
621 |
if (off == 0) /* try read if mmap doesn't work */ |
622 |
goto try_read; |
623 |
break; |
624 |
} |
625 |
|
626 |
res = sec_write (fileno (to), chunk, len); |
627 |
if (msync (chunk, len, MS_ASYNC)) |
628 |
warn ("msync"); |
629 |
if (munmap (chunk, len) < 0) |
630 |
warn ("munmap"); |
631 |
sec_fflush (to); |
632 |
if (res != len) |
633 |
return off; |
634 |
off += len; |
635 |
} |
636 |
return off; |
637 |
} |
638 |
try_read: |
639 |
#endif |
640 |
|
641 |
buf = alloc_buffer (buf, &bufsize, |
642 |
fstat (fileno (from), &st) >= 0 ? &st : NULL); |
643 |
if (buf == NULL) |
644 |
return -1; |
645 |
|
646 |
while ((n = read (fileno (from), buf, bufsize)) > 0) { |
647 |
werr = sec_write (fileno (to), buf, n); |
648 |
if (werr < 0) |
649 |
break; |
650 |
bytes += werr; |
651 |
while (hash && bytes > hashbytes) { |
652 |
putchar ('#'); |
653 |
hashbytes += HASHBYTES; |
654 |
} |
655 |
} |
656 |
sec_fflush (to); |
657 |
if (n < 0) |
658 |
warn ("local"); |
659 |
|
660 |
if (werr < 0) { |
661 |
if (errno != EPIPE) |
662 |
warn ("netout"); |
663 |
bytes = -1; |
664 |
} |
665 |
return bytes; |
666 |
} |
667 |
|
668 |
void |
669 |
sendrequest (char *cmd, char *local, char *remote, char *lmode, int printnames) |
670 |
{ |
671 |
struct stat st; |
672 |
struct timeval start, stop; |
673 |
int c, d; |
674 |
FILE *fin, *dout = 0; |
675 |
int (*closefunc) (FILE *); |
676 |
RETSIGTYPE (*oldintr)(int), (*oldintp)(int); |
677 |
long bytes = 0, hashbytes = HASHBYTES; |
678 |
char *rmode = "w"; |
679 |
|
680 |
if (verbose && printnames) { |
681 |
if (strcmp (local, "-") != 0) |
682 |
printf ("local: %s ", local); |
683 |
if (remote) |
684 |
printf ("remote: %s\n", remote); |
685 |
} |
686 |
if (proxy) { |
687 |
proxtrans (cmd, local, remote); |
688 |
return; |
689 |
} |
690 |
if (curtype != type) |
691 |
changetype (type, 0); |
692 |
closefunc = NULL; |
693 |
oldintr = NULL; |
694 |
oldintp = NULL; |
695 |
|
696 |
if (setjmp (sendabort)) { |
697 |
while (cpend) { |
698 |
getreply (0); |
699 |
} |
700 |
if (data >= 0) { |
701 |
close (data); |
702 |
data = -1; |
703 |
} |
704 |
if (oldintr) |
705 |
signal (SIGINT, oldintr); |
706 |
if (oldintp) |
707 |
signal (SIGPIPE, oldintp); |
708 |
code = -1; |
709 |
return; |
710 |
} |
711 |
oldintr = signal (SIGINT, abortsend); |
712 |
if (strcmp (local, "-") == 0) |
713 |
fin = stdin; |
714 |
else if (*local == '|') { |
715 |
oldintp = signal (SIGPIPE, SIG_IGN); |
716 |
fin = popen (local + 1, lmode); |
717 |
if (fin == NULL) { |
718 |
warn ("%s", local + 1); |
719 |
signal (SIGINT, oldintr); |
720 |
signal (SIGPIPE, oldintp); |
721 |
code = -1; |
722 |
return; |
723 |
} |
724 |
closefunc = pclose; |
725 |
} else { |
726 |
fin = fopen (local, lmode); |
727 |
if (fin == NULL) { |
728 |
warn ("local: %s", local); |
729 |
signal (SIGINT, oldintr); |
730 |
code = -1; |
731 |
return; |
732 |
} |
733 |
closefunc = fclose; |
734 |
if (fstat (fileno (fin), &st) < 0 || !S_ISREG(st.st_mode)) { |
735 |
fprintf (stdout, "%s: not a plain file.\n", local); |
736 |
signal (SIGINT, oldintr); |
737 |
fclose (fin); |
738 |
code = -1; |
739 |
return; |
740 |
} |
741 |
} |
742 |
if (initconn ()) { |
743 |
signal (SIGINT, oldintr); |
744 |
if (oldintp) |
745 |
signal (SIGPIPE, oldintp); |
746 |
code = -1; |
747 |
if (closefunc != NULL) |
748 |
(*closefunc) (fin); |
749 |
return; |
750 |
} |
751 |
if (setjmp (sendabort)) |
752 |
goto abort; |
753 |
|
754 |
if (restart_point && |
755 |
(strcmp (cmd, "STOR") == 0 || strcmp (cmd, "APPE") == 0)) { |
756 |
int rc; |
757 |
|
758 |
switch (curtype) { |
759 |
case TYPE_A: |
760 |
rc = fseek (fin, (long) restart_point, SEEK_SET); |
761 |
break; |
762 |
case TYPE_I: |
763 |
case TYPE_L: |
764 |
rc = lseek (fileno (fin), restart_point, SEEK_SET); |
765 |
break; |
766 |
default: |
767 |
abort(); |
768 |
} |
769 |
if (rc < 0) { |
770 |
warn ("local: %s", local); |
771 |
restart_point = 0; |
772 |
if (closefunc != NULL) |
773 |
(*closefunc) (fin); |
774 |
return; |
775 |
} |
776 |
if (command ("REST %ld", (long) restart_point) |
777 |
!= CONTINUE) { |
778 |
restart_point = 0; |
779 |
if (closefunc != NULL) |
780 |
(*closefunc) (fin); |
781 |
return; |
782 |
} |
783 |
restart_point = 0; |
784 |
rmode = "r+w"; |
785 |
} |
786 |
if (remote) { |
787 |
if (command ("%s %s", cmd, remote) != PRELIM) { |
788 |
signal (SIGINT, oldintr); |
789 |
if (oldintp) |
790 |
signal (SIGPIPE, oldintp); |
791 |
if (closefunc != NULL) |
792 |
(*closefunc) (fin); |
793 |
return; |
794 |
} |
795 |
} else if (command ("%s", cmd) != PRELIM) { |
796 |
signal(SIGINT, oldintr); |
797 |
if (oldintp) |
798 |
signal(SIGPIPE, oldintp); |
799 |
if (closefunc != NULL) |
800 |
(*closefunc)(fin); |
801 |
return; |
802 |
} |
803 |
dout = dataconn(rmode); |
804 |
if (dout == NULL) |
805 |
goto abort; |
806 |
set_buffer_size (fileno (dout), 0); |
807 |
gettimeofday (&start, (struct timezone *) 0); |
808 |
oldintp = signal (SIGPIPE, SIG_IGN); |
809 |
switch (curtype) { |
810 |
|
811 |
case TYPE_I: |
812 |
case TYPE_L: |
813 |
errno = d = c = 0; |
814 |
bytes = copy_stream (fin, dout); |
815 |
break; |
816 |
|
817 |
case TYPE_A: |
818 |
while ((c = getc (fin)) != EOF) { |
819 |
if (c == '\n') { |
820 |
while (hash && (bytes >= hashbytes)) { |
821 |
putchar ('#'); |
822 |
fflush (stdout); |
823 |
hashbytes += HASHBYTES; |
824 |
} |
825 |
if (ferror (dout)) |
826 |
break; |
827 |
sec_putc ('\r', dout); |
828 |
bytes++; |
829 |
} |
830 |
sec_putc (c, dout); |
831 |
bytes++; |
832 |
} |
833 |
sec_fflush (dout); |
834 |
if (hash) { |
835 |
if (bytes < hashbytes) |
836 |
putchar ('#'); |
837 |
putchar ('\n'); |
838 |
fflush (stdout); |
839 |
} |
840 |
if (ferror (fin)) |
841 |
warn ("local: %s", local); |
842 |
if (ferror (dout)) { |
843 |
if (errno != EPIPE) |
844 |
warn ("netout"); |
845 |
bytes = -1; |
846 |
} |
847 |
break; |
848 |
} |
849 |
if (closefunc != NULL) |
850 |
(*closefunc) (fin); |
851 |
fclose (dout); |
852 |
gettimeofday (&stop, (struct timezone *) 0); |
853 |
getreply (0); |
854 |
signal (SIGINT, oldintr); |
855 |
if (oldintp) |
856 |
signal (SIGPIPE, oldintp); |
857 |
if (bytes > 0) |
858 |
ptransfer ("sent", bytes, &start, &stop); |
859 |
return; |
860 |
abort: |
861 |
signal (SIGINT, oldintr); |
862 |
if (oldintp) |
863 |
signal (SIGPIPE, oldintp); |
864 |
if (!cpend) { |
865 |
code = -1; |
866 |
return; |
867 |
} |
868 |
if (data >= 0) { |
869 |
close (data); |
870 |
data = -1; |
871 |
} |
872 |
if (dout) |
873 |
fclose (dout); |
874 |
getreply (0); |
875 |
code = -1; |
876 |
if (closefunc != NULL && fin != NULL) |
877 |
(*closefunc) (fin); |
878 |
gettimeofday (&stop, (struct timezone *) 0); |
879 |
if (bytes > 0) |
880 |
ptransfer ("sent", bytes, &start, &stop); |
881 |
} |
882 |
|
883 |
jmp_buf recvabort; |
884 |
|
885 |
void |
886 |
abortrecv (int sig) |
887 |
{ |
888 |
|
889 |
mflag = 0; |
890 |
abrtflag = 0; |
891 |
printf ("\nreceive aborted\nwaiting for remote to finish abort\n"); |
892 |
fflush (stdout); |
893 |
longjmp (recvabort, 1); |
894 |
} |
895 |
|
896 |
void |
897 |
recvrequest (char *cmd, char *local, char *remote, |
898 |
char *lmode, int printnames, int local_given) |
899 |
{ |
900 |
FILE *fout = NULL, *din = NULL; |
901 |
int (*closefunc) (FILE *); |
902 |
sighand oldintr, oldintp; |
903 |
int c, d, is_retr, tcrflag, bare_lfs = 0; |
904 |
static size_t bufsize; |
905 |
static char *buf; |
906 |
long bytes = 0, hashbytes = HASHBYTES; |
907 |
struct timeval start, stop; |
908 |
struct stat st; |
909 |
|
910 |
is_retr = strcmp (cmd, "RETR") == 0; |
911 |
if (is_retr && verbose && printnames) { |
912 |
if (strcmp (local, "-") != 0) |
913 |
printf ("local: %s ", local); |
914 |
if (remote) |
915 |
printf ("remote: %s\n", remote); |
916 |
} |
917 |
if (proxy && is_retr) { |
918 |
proxtrans (cmd, local, remote); |
919 |
return; |
920 |
} |
921 |
closefunc = NULL; |
922 |
oldintr = NULL; |
923 |
oldintp = NULL; |
924 |
tcrflag = !crflag && is_retr; |
925 |
if (setjmp (recvabort)) { |
926 |
while (cpend) { |
927 |
getreply (0); |
928 |
} |
929 |
if (data >= 0) { |
930 |
close (data); |
931 |
data = -1; |
932 |
} |
933 |
if (oldintr) |
934 |
signal (SIGINT, oldintr); |
935 |
code = -1; |
936 |
return; |
937 |
} |
938 |
oldintr = signal (SIGINT, abortrecv); |
939 |
if (!local_given || (strcmp(local, "-") && *local != '|')) { |
940 |
if (access (local, 2) < 0) { |
941 |
char *dir = strrchr (local, '/'); |
942 |
|
943 |
if (errno != ENOENT && errno != EACCES) { |
944 |
warn ("local: %s", local); |
945 |
signal (SIGINT, oldintr); |
946 |
code = -1; |
947 |
return; |
948 |
} |
949 |
if (dir != NULL) |
950 |
*dir = 0; |
951 |
d = access (dir ? local : ".", 2); |
952 |
if (dir != NULL) |
953 |
*dir = '/'; |
954 |
if (d < 0) { |
955 |
warn ("local: %s", local); |
956 |
signal (SIGINT, oldintr); |
957 |
code = -1; |
958 |
return; |
959 |
} |
960 |
if (!runique && errno == EACCES && |
961 |
chmod (local, 0600) < 0) { |
962 |
warn ("local: %s", local); |
963 |
signal (SIGINT, oldintr); |
964 |
signal (SIGINT, oldintr); |
965 |
code = -1; |
966 |
return; |
967 |
} |
968 |
if (runique && errno == EACCES && |
969 |
(local = gunique (local)) == NULL) { |
970 |
signal (SIGINT, oldintr); |
971 |
code = -1; |
972 |
return; |
973 |
} |
974 |
} else if (runique && (local = gunique (local)) == NULL) { |
975 |
signal(SIGINT, oldintr); |
976 |
code = -1; |
977 |
return; |
978 |
} |
979 |
} |
980 |
if (!is_retr) { |
981 |
if (curtype != TYPE_A) |
982 |
changetype (TYPE_A, 0); |
983 |
} else if (curtype != type) |
984 |
changetype (type, 0); |
985 |
if (initconn ()) { |
986 |
signal (SIGINT, oldintr); |
987 |
code = -1; |
988 |
return; |
989 |
} |
990 |
if (setjmp (recvabort)) |
991 |
goto abort; |
992 |
if (is_retr && restart_point && |
993 |
command ("REST %ld", (long) restart_point) != CONTINUE) |
994 |
return; |
995 |
if (remote) { |
996 |
if (command ("%s %s", cmd, remote) != PRELIM) { |
997 |
signal (SIGINT, oldintr); |
998 |
return; |
999 |
} |
1000 |
} else { |
1001 |
if (command ("%s", cmd) != PRELIM) { |
1002 |
signal (SIGINT, oldintr); |
1003 |
return; |
1004 |
} |
1005 |
} |
1006 |
din = dataconn ("r"); |
1007 |
if (din == NULL) |
1008 |
goto abort; |
1009 |
set_buffer_size (fileno (din), 1); |
1010 |
if (local_given && strcmp (local, "-") == 0) |
1011 |
fout = stdout; |
1012 |
else if (local_given && *local == '|') { |
1013 |
oldintp = signal (SIGPIPE, SIG_IGN); |
1014 |
fout = popen (local + 1, "w"); |
1015 |
if (fout == NULL) { |
1016 |
warn ("%s", local + 1); |
1017 |
goto abort; |
1018 |
} |
1019 |
closefunc = pclose; |
1020 |
} else { |
1021 |
fout = fopen (local, lmode); |
1022 |
if (fout == NULL) { |
1023 |
warn ("local: %s", local); |
1024 |
goto abort; |
1025 |
} |
1026 |
closefunc = fclose; |
1027 |
} |
1028 |
buf = alloc_buffer (buf, &bufsize, |
1029 |
fstat (fileno (fout), &st) >= 0 ? &st : NULL); |
1030 |
if (buf == NULL) |
1031 |
goto abort; |
1032 |
|
1033 |
gettimeofday (&start, (struct timezone *) 0); |
1034 |
switch (curtype) { |
1035 |
|
1036 |
case TYPE_I: |
1037 |
case TYPE_L: |
1038 |
if (restart_point && |
1039 |
lseek (fileno (fout), restart_point, SEEK_SET) < 0) { |
1040 |
warn ("local: %s", local); |
1041 |
if (closefunc != NULL) |
1042 |
(*closefunc) (fout); |
1043 |
return; |
1044 |
} |
1045 |
errno = d = 0; |
1046 |
while ((c = sec_read (fileno (din), buf, bufsize)) > 0) { |
1047 |
if ((d = write (fileno (fout), buf, c)) != c) |
1048 |
break; |
1049 |
bytes += c; |
1050 |
if (hash) { |
1051 |
while (bytes >= hashbytes) { |
1052 |
putchar ('#'); |
1053 |
hashbytes += HASHBYTES; |
1054 |
} |
1055 |
fflush (stdout); |
1056 |
} |
1057 |
} |
1058 |
if (hash && bytes > 0) { |
1059 |
if (bytes < HASHBYTES) |
1060 |
putchar ('#'); |
1061 |
putchar ('\n'); |
1062 |
fflush (stdout); |
1063 |
} |
1064 |
if (c < 0) { |
1065 |
if (errno != EPIPE) |
1066 |
warn ("netin"); |
1067 |
bytes = -1; |
1068 |
} |
1069 |
if (d < c) { |
1070 |
if (d < 0) |
1071 |
warn ("local: %s", local); |
1072 |
else |
1073 |
warnx ("%s: short write", local); |
1074 |
} |
1075 |
break; |
1076 |
|
1077 |
case TYPE_A: |
1078 |
if (restart_point) { |
1079 |
int i, n, ch; |
1080 |
|
1081 |
if (fseek (fout, 0L, SEEK_SET) < 0) |
1082 |
goto done; |
1083 |
n = restart_point; |
1084 |
for (i = 0; i++ < n;) { |
1085 |
if ((ch = sec_getc (fout)) == EOF) |
1086 |
goto done; |
1087 |
if (ch == '\n') |
1088 |
i++; |
1089 |
} |
1090 |
if (fseek (fout, 0L, SEEK_CUR) < 0) { |
1091 |
done: |
1092 |
warn ("local: %s", local); |
1093 |
if (closefunc != NULL) |
1094 |
(*closefunc) (fout); |
1095 |
return; |
1096 |
} |
1097 |
} |
1098 |
while ((c = sec_getc(din)) != EOF) { |
1099 |
if (c == '\n') |
1100 |
bare_lfs++; |
1101 |
while (c == '\r') { |
1102 |
while (hash && (bytes >= hashbytes)) { |
1103 |
putchar ('#'); |
1104 |
fflush (stdout); |
1105 |
hashbytes += HASHBYTES; |
1106 |
} |
1107 |
bytes++; |
1108 |
if ((c = sec_getc (din)) != '\n' || tcrflag) { |
1109 |
if (ferror (fout)) |
1110 |
goto break2; |
1111 |
putc ('\r', fout); |
1112 |
if (c == '\0') { |
1113 |
bytes++; |
1114 |
goto contin2; |
1115 |
} |
1116 |
if (c == EOF) |
1117 |
goto contin2; |
1118 |
} |
1119 |
} |
1120 |
putc (c, fout); |
1121 |
bytes++; |
1122 |
contin2:; |
1123 |
} |
1124 |
break2: |
1125 |
if (bare_lfs) { |
1126 |
printf ("WARNING! %d bare linefeeds received in ASCII mode\n", |
1127 |
bare_lfs); |
1128 |
printf ("File may not have transferred correctly.\n"); |
1129 |
} |
1130 |
if (hash) { |
1131 |
if (bytes < hashbytes) |
1132 |
putchar ('#'); |
1133 |
putchar ('\n'); |
1134 |
fflush (stdout); |
1135 |
} |
1136 |
if (ferror (din)) { |
1137 |
if (errno != EPIPE) |
1138 |
warn ("netin"); |
1139 |
bytes = -1; |
1140 |
} |
1141 |
if (ferror (fout)) |
1142 |
warn ("local: %s", local); |
1143 |
break; |
1144 |
} |
1145 |
if (closefunc != NULL) |
1146 |
(*closefunc) (fout); |
1147 |
signal (SIGINT, oldintr); |
1148 |
if (oldintp) |
1149 |
signal (SIGPIPE, oldintp); |
1150 |
fclose (din); |
1151 |
gettimeofday (&stop, (struct timezone *) 0); |
1152 |
getreply (0); |
1153 |
if (bytes > 0 && is_retr) |
1154 |
ptransfer ("received", bytes, &start, &stop); |
1155 |
return; |
1156 |
abort: |
1157 |
|
1158 |
/* abort using RFC959 recommended IP,SYNC sequence */ |
1159 |
|
1160 |
if (oldintp) |
1161 |
signal (SIGPIPE, oldintr); |
1162 |
signal (SIGINT, SIG_IGN); |
1163 |
if (!cpend) { |
1164 |
code = -1; |
1165 |
signal (SIGINT, oldintr); |
1166 |
return; |
1167 |
} |
1168 |
abort_remote(din); |
1169 |
code = -1; |
1170 |
if (data >= 0) { |
1171 |
close (data); |
1172 |
data = -1; |
1173 |
} |
1174 |
if (closefunc != NULL && fout != NULL) |
1175 |
(*closefunc) (fout); |
1176 |
if (din) |
1177 |
fclose (din); |
1178 |
gettimeofday (&stop, (struct timezone *) 0); |
1179 |
if (bytes > 0) |
1180 |
ptransfer ("received", bytes, &start, &stop); |
1181 |
signal (SIGINT, oldintr); |
1182 |
} |
1183 |
|
1184 |
static int |
1185 |
parse_epsv (const char *str) |
1186 |
{ |
1187 |
char sep; |
1188 |
char *end; |
1189 |
int port; |
1190 |
|
1191 |
if (*str == '\0') |
1192 |
return -1; |
1193 |
sep = *str++; |
1194 |
if (sep != *str++) |
1195 |
return -1; |
1196 |
if (sep != *str++) |
1197 |
return -1; |
1198 |
port = strtol (str, &end, 0); |
1199 |
if (str == end) |
1200 |
return -1; |
1201 |
if (end[0] != sep || end[1] != '\0') |
1202 |
return -1; |
1203 |
return htons(port); |
1204 |
} |
1205 |
|
1206 |
static int |
1207 |
parse_pasv (struct sockaddr_in *sin4, const char *str) |
1208 |
{ |
1209 |
int a0, a1, a2, a3, p0, p1; |
1210 |
|
1211 |
/* |
1212 |
* What we've got at this point is a string of comma separated |
1213 |
* one-byte unsigned integer values. The first four are the an IP |
1214 |
* address. The fifth is the MSB of the port number, the sixth is the |
1215 |
* LSB. From that we'll prepare a sockaddr_in. |
1216 |
*/ |
1217 |
|
1218 |
if (sscanf (str, "%d,%d,%d,%d,%d,%d", |
1219 |
&a0, &a1, &a2, &a3, &p0, &p1) != 6) { |
1220 |
printf ("Passive mode address scan failure. " |
1221 |
"Shouldn't happen!\n"); |
1222 |
return -1; |
1223 |
} |
1224 |
if (a0 < 0 || a0 > 255 || |
1225 |
a1 < 0 || a1 > 255 || |
1226 |
a2 < 0 || a2 > 255 || |
1227 |
a3 < 0 || a3 > 255 || |
1228 |
p0 < 0 || p0 > 255 || |
1229 |
p1 < 0 || p1 > 255) { |
1230 |
printf ("Can't parse passive mode string.\n"); |
1231 |
return -1; |
1232 |
} |
1233 |
memset (sin4, 0, sizeof(*sin4)); |
1234 |
sin4->sin_family = AF_INET; |
1235 |
sin4->sin_addr.s_addr = htonl ((a0 << 24) | (a1 << 16) | |
1236 |
(a2 << 8) | a3); |
1237 |
sin4->sin_port = htons ((p0 << 8) | p1); |
1238 |
return 0; |
1239 |
} |
1240 |
|
1241 |
static int |
1242 |
passive_mode (void) |
1243 |
{ |
1244 |
int port; |
1245 |
|
1246 |
data = socket (myctladdr->sa_family, SOCK_STREAM, 0); |
1247 |
if (data < 0) { |
1248 |
warn ("socket"); |
1249 |
return (1); |
1250 |
} |
1251 |
if (options & SO_DEBUG) |
1252 |
socket_set_debug (data); |
1253 |
if (command ("EPSV") != COMPLETE) { |
1254 |
if (command ("PASV") != COMPLETE) { |
1255 |
printf ("Passive mode refused.\n"); |
1256 |
goto bad; |
1257 |
} |
1258 |
} |
1259 |
|
1260 |
/* |
1261 |
* Parse the reply to EPSV or PASV |
1262 |
*/ |
1263 |
|
1264 |
port = parse_epsv (pasv); |
1265 |
if (port > 0) { |
1266 |
data_addr->sa_family = myctladdr->sa_family; |
1267 |
socket_set_address_and_port (data_addr, |
1268 |
socket_get_address (hisctladdr), |
1269 |
port); |
1270 |
} else { |
1271 |
if (parse_pasv ((struct sockaddr_in *)data_addr, pasv) < 0) |
1272 |
goto bad; |
1273 |
} |
1274 |
|
1275 |
if (connect (data, data_addr, socket_sockaddr_size (data_addr)) < 0) { |
1276 |
warn ("connect"); |
1277 |
goto bad; |
1278 |
} |
1279 |
#ifdef IPTOS_THROUGHPUT |
1280 |
socket_set_tos (data, IPTOS_THROUGHPUT); |
1281 |
#endif |
1282 |
return (0); |
1283 |
bad: |
1284 |
close (data); |
1285 |
data = -1; |
1286 |
sendport = 1; |
1287 |
return (1); |
1288 |
} |
1289 |
|
1290 |
|
1291 |
static int |
1292 |
active_mode (void) |
1293 |
{ |
1294 |
int tmpno = 0; |
1295 |
socklen_t len; |
1296 |
int result; |
1297 |
|
1298 |
noport: |
1299 |
data_addr->sa_family = myctladdr->sa_family; |
1300 |
socket_set_address_and_port (data_addr, socket_get_address (myctladdr), |
1301 |
sendport ? 0 : socket_get_port (myctladdr)); |
1302 |
|
1303 |
if (data != -1) |
1304 |
close (data); |
1305 |
data = socket (data_addr->sa_family, SOCK_STREAM, 0); |
1306 |
if (data < 0) { |
1307 |
warn ("socket"); |
1308 |
if (tmpno) |
1309 |
sendport = 1; |
1310 |
return (1); |
1311 |
} |
1312 |
if (!sendport) |
1313 |
socket_set_reuseaddr (data, 1); |
1314 |
if (bind (data, data_addr, socket_sockaddr_size (data_addr)) < 0) { |
1315 |
warn ("bind"); |
1316 |
goto bad; |
1317 |
} |
1318 |
if (options & SO_DEBUG) |
1319 |
socket_set_debug (data); |
1320 |
len = sizeof (data_addr_ss); |
1321 |
if (getsockname (data, data_addr, &len) < 0) { |
1322 |
warn ("getsockname"); |
1323 |
goto bad; |
1324 |
} |
1325 |
if (listen (data, 1) < 0) |
1326 |
warn ("listen"); |
1327 |
if (sendport) { |
1328 |
char addr_str[256]; |
1329 |
int inet_af; |
1330 |
int overbose; |
1331 |
|
1332 |
if (inet_ntop (data_addr->sa_family, socket_get_address (data_addr), |
1333 |
addr_str, sizeof(addr_str)) == NULL) |
1334 |
errx (1, "inet_ntop failed"); |
1335 |
switch (data_addr->sa_family) { |
1336 |
case AF_INET : |
1337 |
inet_af = 1; |
1338 |
break; |
1339 |
#ifdef HAVE_IPV6 |
1340 |
case AF_INET6 : |
1341 |
inet_af = 2; |
1342 |
break; |
1343 |
#endif |
1344 |
default : |
1345 |
errx (1, "bad address family %d", data_addr->sa_family); |
1346 |
} |
1347 |
|
1348 |
|
1349 |
overbose = verbose; |
1350 |
if (debug == 0) |
1351 |
verbose = -1; |
1352 |
|
1353 |
result = command ("EPRT |%d|%s|%d|", |
1354 |
inet_af, addr_str, |
1355 |
ntohs(socket_get_port (data_addr))); |
1356 |
verbose = overbose; |
1357 |
|
1358 |
if (result == ERROR) { |
1359 |
struct sockaddr_in *sin4 = (struct sockaddr_in *)data_addr; |
1360 |
|
1361 |
unsigned int a = ntohl(sin4->sin_addr.s_addr); |
1362 |
unsigned int p = ntohs(sin4->sin_port); |
1363 |
|
1364 |
if (data_addr->sa_family != AF_INET) { |
1365 |
warnx ("remote server doesn't support EPRT"); |
1366 |
goto bad; |
1367 |
} |
1368 |
|
1369 |
result = command("PORT %d,%d,%d,%d,%d,%d", |
1370 |
(a >> 24) & 0xff, |
1371 |
(a >> 16) & 0xff, |
1372 |
(a >> 8) & 0xff, |
1373 |
a & 0xff, |
1374 |
(p >> 8) & 0xff, |
1375 |
p & 0xff); |
1376 |
if (result == ERROR && sendport == -1) { |
1377 |
sendport = 0; |
1378 |
tmpno = 1; |
1379 |
goto noport; |
1380 |
} |
1381 |
return (result != COMPLETE); |
1382 |
} |
1383 |
return result != COMPLETE; |
1384 |
} |
1385 |
if (tmpno) |
1386 |
sendport = 1; |
1387 |
|
1388 |
|
1389 |
#ifdef IPTOS_THROUGHPUT |
1390 |
socket_set_tos (data, IPTOS_THROUGHPUT); |
1391 |
#endif |
1392 |
return (0); |
1393 |
bad: |
1394 |
close (data); |
1395 |
data = -1; |
1396 |
if (tmpno) |
1397 |
sendport = 1; |
1398 |
return (1); |
1399 |
} |
1400 |
|
1401 |
/* |
1402 |
* Need to start a listen on the data channel before we send the command, |
1403 |
* otherwise the server's connect may fail. |
1404 |
*/ |
1405 |
int |
1406 |
initconn (void) |
1407 |
{ |
1408 |
if (passivemode) |
1409 |
return passive_mode (); |
1410 |
else |
1411 |
return active_mode (); |
1412 |
} |
1413 |
|
1414 |
FILE * |
1415 |
dataconn (const char *lmode) |
1416 |
{ |
1417 |
struct sockaddr_storage from_ss; |
1418 |
struct sockaddr *from = (struct sockaddr *)&from_ss; |
1419 |
socklen_t fromlen = sizeof(from_ss); |
1420 |
int s; |
1421 |
|
1422 |
if (passivemode) |
1423 |
return (fdopen (data, lmode)); |
1424 |
|
1425 |
s = accept (data, from, &fromlen); |
1426 |
if (s < 0) { |
1427 |
warn ("accept"); |
1428 |
close (data), data = -1; |
1429 |
return (NULL); |
1430 |
} |
1431 |
close (data); |
1432 |
data = s; |
1433 |
#ifdef IPTOS_THROUGHPUT |
1434 |
socket_set_tos (s, IPTOS_THROUGHPUT); |
1435 |
#endif |
1436 |
return (fdopen (data, lmode)); |
1437 |
} |
1438 |
|
1439 |
void |
1440 |
ptransfer (char *direction, long int bytes, |
1441 |
struct timeval * t0, struct timeval * t1) |
1442 |
{ |
1443 |
struct timeval td; |
1444 |
float s; |
1445 |
float bs; |
1446 |
int prec; |
1447 |
char *unit; |
1448 |
|
1449 |
if (verbose) { |
1450 |
td.tv_sec = t1->tv_sec - t0->tv_sec; |
1451 |
td.tv_usec = t1->tv_usec - t0->tv_usec; |
1452 |
if (td.tv_usec < 0) { |
1453 |
td.tv_sec--; |
1454 |
td.tv_usec += 1000000; |
1455 |
} |
1456 |
s = td.tv_sec + (td.tv_usec / 1000000.); |
1457 |
bs = bytes / (s ? s : 1); |
1458 |
if (bs >= 1048576) { |
1459 |
bs /= 1048576; |
1460 |
unit = "M"; |
1461 |
prec = 2; |
1462 |
} else if (bs >= 1024) { |
1463 |
bs /= 1024; |
1464 |
unit = "k"; |
1465 |
prec = 1; |
1466 |
} else { |
1467 |
unit = ""; |
1468 |
prec = 0; |
1469 |
} |
1470 |
|
1471 |
printf ("%ld bytes %s in %.3g seconds (%.*f %sbyte/s)\n", |
1472 |
bytes, direction, s, prec, bs, unit); |
1473 |
} |
1474 |
} |
1475 |
|
1476 |
void |
1477 |
psabort (int sig) |
1478 |
{ |
1479 |
|
1480 |
abrtflag++; |
1481 |
} |
1482 |
|
1483 |
void |
1484 |
pswitch (int flag) |
1485 |
{ |
1486 |
sighand oldintr; |
1487 |
static struct comvars { |
1488 |
int connect; |
1489 |
char name[MaxHostNameLen]; |
1490 |
struct sockaddr_storage mctl; |
1491 |
struct sockaddr_storage hctl; |
1492 |
FILE *in; |
1493 |
FILE *out; |
1494 |
int tpe; |
1495 |
int curtpe; |
1496 |
int cpnd; |
1497 |
int sunqe; |
1498 |
int runqe; |
1499 |
int mcse; |
1500 |
int ntflg; |
1501 |
char nti[17]; |
1502 |
char nto[17]; |
1503 |
int mapflg; |
1504 |
char mi[MaxPathLen]; |
1505 |
char mo[MaxPathLen]; |
1506 |
} proxstruct, tmpstruct; |
1507 |
struct comvars *ip, *op; |
1508 |
|
1509 |
abrtflag = 0; |
1510 |
oldintr = signal (SIGINT, psabort); |
1511 |
if (flag) { |
1512 |
if (proxy) |
1513 |
return; |
1514 |
ip = &tmpstruct; |
1515 |
op = &proxstruct; |
1516 |
proxy++; |
1517 |
} else { |
1518 |
if (!proxy) |
1519 |
return; |
1520 |
ip = &proxstruct; |
1521 |
op = &tmpstruct; |
1522 |
proxy = 0; |
1523 |
} |
1524 |
ip->connect = connected; |
1525 |
connected = op->connect; |
1526 |
if (hostname) { |
1527 |
strlcpy (ip->name, hostname, sizeof (ip->name)); |
1528 |
} else |
1529 |
ip->name[0] = 0; |
1530 |
hostname = op->name; |
1531 |
ip->hctl = hisctladdr_ss; |
1532 |
hisctladdr_ss = op->hctl; |
1533 |
ip->mctl = myctladdr_ss; |
1534 |
myctladdr_ss = op->mctl; |
1535 |
ip->in = cin; |
1536 |
cin = op->in; |
1537 |
ip->out = cout; |
1538 |
cout = op->out; |
1539 |
ip->tpe = type; |
1540 |
type = op->tpe; |
1541 |
ip->curtpe = curtype; |
1542 |
curtype = op->curtpe; |
1543 |
ip->cpnd = cpend; |
1544 |
cpend = op->cpnd; |
1545 |
ip->sunqe = sunique; |
1546 |
sunique = op->sunqe; |
1547 |
ip->runqe = runique; |
1548 |
runique = op->runqe; |
1549 |
ip->mcse = mcase; |
1550 |
mcase = op->mcse; |
1551 |
ip->ntflg = ntflag; |
1552 |
ntflag = op->ntflg; |
1553 |
strlcpy (ip->nti, ntin, sizeof (ip->nti)); |
1554 |
strlcpy (ntin, op->nti, 17); |
1555 |
strlcpy (ip->nto, ntout, sizeof (ip->nto)); |
1556 |
strlcpy (ntout, op->nto, 17); |
1557 |
ip->mapflg = mapflag; |
1558 |
mapflag = op->mapflg; |
1559 |
strlcpy (ip->mi, mapin, MaxPathLen); |
1560 |
strlcpy (mapin, op->mi, MaxPathLen); |
1561 |
strlcpy (ip->mo, mapout, MaxPathLen); |
1562 |
strlcpy (mapout, op->mo, MaxPathLen); |
1563 |
signal(SIGINT, oldintr); |
1564 |
if (abrtflag) { |
1565 |
abrtflag = 0; |
1566 |
(*oldintr) (SIGINT); |
1567 |
} |
1568 |
} |
1569 |
|
1570 |
void |
1571 |
abortpt (int sig) |
1572 |
{ |
1573 |
|
1574 |
printf ("\n"); |
1575 |
fflush (stdout); |
1576 |
ptabflg++; |
1577 |
mflag = 0; |
1578 |
abrtflag = 0; |
1579 |
longjmp (ptabort, 1); |
1580 |
} |
1581 |
|
1582 |
void |
1583 |
proxtrans (char *cmd, char *local, char *remote) |
1584 |
{ |
1585 |
sighand oldintr = NULL; |
1586 |
int secndflag = 0, prox_type, nfnd; |
1587 |
char *cmd2; |
1588 |
fd_set mask; |
1589 |
|
1590 |
if (strcmp (cmd, "RETR")) |
1591 |
cmd2 = "RETR"; |
1592 |
else |
1593 |
cmd2 = runique ? "STOU" : "STOR"; |
1594 |
if ((prox_type = type) == 0) { |
1595 |
if (unix_server && unix_proxy) |
1596 |
prox_type = TYPE_I; |
1597 |
else |
1598 |
prox_type = TYPE_A; |
1599 |
} |
1600 |
if (curtype != prox_type) |
1601 |
changetype (prox_type, 1); |
1602 |
if (command ("PASV") != COMPLETE) { |
1603 |
printf ("proxy server does not support third party transfers.\n"); |
1604 |
return; |
1605 |
} |
1606 |
pswitch (0); |
1607 |
if (!connected) { |
1608 |
printf ("No primary connection\n"); |
1609 |
pswitch (1); |
1610 |
code = -1; |
1611 |
return; |
1612 |
} |
1613 |
if (curtype != prox_type) |
1614 |
changetype (prox_type, 1); |
1615 |
if (command ("PORT %s", pasv) != COMPLETE) { |
1616 |
pswitch (1); |
1617 |
return; |
1618 |
} |
1619 |
if (setjmp (ptabort)) |
1620 |
goto abort; |
1621 |
oldintr = signal (SIGINT, abortpt); |
1622 |
if (command ("%s %s", cmd, remote) != PRELIM) { |
1623 |
signal (SIGINT, oldintr); |
1624 |
pswitch (1); |
1625 |
return; |
1626 |
} |
1627 |
sleep (2); |
1628 |
pswitch (1); |
1629 |
secndflag++; |
1630 |
if (command ("%s %s", cmd2, local) != PRELIM) |
1631 |
goto abort; |
1632 |
ptflag++; |
1633 |
getreply (0); |
1634 |
pswitch (0); |
1635 |
getreply (0); |
1636 |
signal (SIGINT, oldintr); |
1637 |
pswitch (1); |
1638 |
ptflag = 0; |
1639 |
printf ("local: %s remote: %s\n", local, remote); |
1640 |
return; |
1641 |
abort: |
1642 |
signal (SIGINT, SIG_IGN); |
1643 |
ptflag = 0; |
1644 |
if (strcmp (cmd, "RETR") && !proxy) |
1645 |
pswitch (1); |
1646 |
else if (!strcmp (cmd, "RETR") && proxy) |
1647 |
pswitch (0); |
1648 |
if (!cpend && !secndflag) { /* only here if cmd = "STOR" (proxy=1) */ |
1649 |
if (command ("%s %s", cmd2, local) != PRELIM) { |
1650 |
pswitch (0); |
1651 |
if (cpend) |
1652 |
abort_remote ((FILE *) NULL); |
1653 |
} |
1654 |
pswitch (1); |
1655 |
if (ptabflg) |
1656 |
code = -1; |
1657 |
if (oldintr) |
1658 |
signal (SIGINT, oldintr); |
1659 |
return; |
1660 |
} |
1661 |
if (cpend) |
1662 |
abort_remote ((FILE *) NULL); |
1663 |
pswitch (!proxy); |
1664 |
if (!cpend && !secndflag) { /* only if cmd = "RETR" (proxy=1) */ |
1665 |
if (command ("%s %s", cmd2, local) != PRELIM) { |
1666 |
pswitch (0); |
1667 |
if (cpend) |
1668 |
abort_remote ((FILE *) NULL); |
1669 |
pswitch (1); |
1670 |
if (ptabflg) |
1671 |
code = -1; |
1672 |
signal (SIGINT, oldintr); |
1673 |
return; |
1674 |
} |
1675 |
} |
1676 |
if (cpend) |
1677 |
abort_remote ((FILE *) NULL); |
1678 |
pswitch (!proxy); |
1679 |
if (cpend) { |
1680 |
FD_ZERO (&mask); |
1681 |
if (fileno(cin) >= FD_SETSIZE) |
1682 |
errx (1, "fd too large"); |
1683 |
FD_SET (fileno (cin), &mask); |
1684 |
if ((nfnd = empty (&mask, 10)) <= 0) { |
1685 |
if (nfnd < 0) { |
1686 |
warn ("abort"); |
1687 |
} |
1688 |
if (ptabflg) |
1689 |
code = -1; |
1690 |
lostpeer (0); |
1691 |
} |
1692 |
getreply (0); |
1693 |
getreply (0); |
1694 |
} |
1695 |
if (proxy) |
1696 |
pswitch (0); |
1697 |
pswitch (1); |
1698 |
if (ptabflg) |
1699 |
code = -1; |
1700 |
signal (SIGINT, oldintr); |
1701 |
} |
1702 |
|
1703 |
void |
1704 |
reset (int argc, char **argv) |
1705 |
{ |
1706 |
fd_set mask; |
1707 |
int nfnd = 1; |
1708 |
|
1709 |
FD_ZERO (&mask); |
1710 |
while (nfnd > 0) { |
1711 |
if (fileno (cin) >= FD_SETSIZE) |
1712 |
errx (1, "fd too large"); |
1713 |
FD_SET (fileno (cin), &mask); |
1714 |
if ((nfnd = empty (&mask, 0)) < 0) { |
1715 |
warn ("reset"); |
1716 |
code = -1; |
1717 |
lostpeer(0); |
1718 |
} else if (nfnd) { |
1719 |
getreply(0); |
1720 |
} |
1721 |
} |
1722 |
} |
1723 |
|
1724 |
char * |
1725 |
gunique (char *local) |
1726 |
{ |
1727 |
static char new[MaxPathLen]; |
1728 |
char *cp = strrchr (local, '/'); |
1729 |
int d, count = 0; |
1730 |
char ext = '1'; |
1731 |
|
1732 |
if (cp) |
1733 |
*cp = '\0'; |
1734 |
d = access (cp ? local : ".", 2); |
1735 |
if (cp) |
1736 |
*cp = '/'; |
1737 |
if (d < 0) { |
1738 |
warn ("local: %s", local); |
1739 |
return NULL; |
1740 |
} |
1741 |
strlcpy (new, local, sizeof(new)); |
1742 |
cp = new + strlen(new); |
1743 |
*cp++ = '.'; |
1744 |
while (!d) { |
1745 |
if (++count == 100) { |
1746 |
printf ("runique: can't find unique file name.\n"); |
1747 |
return NULL; |
1748 |
} |
1749 |
*cp++ = ext; |
1750 |
*cp = '\0'; |
1751 |
if (ext == '9') |
1752 |
ext = '0'; |
1753 |
else |
1754 |
ext++; |
1755 |
if ((d = access (new, 0)) < 0) |
1756 |
break; |
1757 |
if (ext != '0') |
1758 |
cp--; |
1759 |
else if (*(cp - 2) == '.') |
1760 |
*(cp - 1) = '1'; |
1761 |
else { |
1762 |
*(cp - 2) = *(cp - 2) + 1; |
1763 |
cp--; |
1764 |
} |
1765 |
} |
1766 |
return (new); |
1767 |
} |
1768 |
|
1769 |
void |
1770 |
abort_remote (FILE * din) |
1771 |
{ |
1772 |
char buf[BUFSIZ]; |
1773 |
int nfnd; |
1774 |
fd_set mask; |
1775 |
|
1776 |
/* |
1777 |
* send IAC in urgent mode instead of DM because 4.3BSD places oob mark |
1778 |
* after urgent byte rather than before as is protocol now |
1779 |
*/ |
1780 |
snprintf (buf, sizeof (buf), "%c%c%c", IAC, IP, IAC); |
1781 |
if (send (fileno (cout), buf, 3, MSG_OOB) != 3) |
1782 |
warn ("abort"); |
1783 |
fprintf (cout, "%c", DM); |
1784 |
sec_fprintf(cout, "ABOR"); |
1785 |
sec_fflush (cout); |
1786 |
fprintf (cout, "\r\n"); |
1787 |
fflush(cout); |
1788 |
FD_ZERO (&mask); |
1789 |
if (fileno (cin) >= FD_SETSIZE) |
1790 |
errx (1, "fd too large"); |
1791 |
FD_SET (fileno (cin), &mask); |
1792 |
if (din) { |
1793 |
if (fileno (din) >= FD_SETSIZE) |
1794 |
errx (1, "fd too large"); |
1795 |
FD_SET (fileno (din), &mask); |
1796 |
} |
1797 |
if ((nfnd = empty (&mask, 10)) <= 0) { |
1798 |
if (nfnd < 0) { |
1799 |
warn ("abort"); |
1800 |
} |
1801 |
if (ptabflg) |
1802 |
code = -1; |
1803 |
lostpeer (0); |
1804 |
} |
1805 |
if (din && FD_ISSET (fileno (din), &mask)) { |
1806 |
while (read (fileno (din), buf, BUFSIZ) > 0) |
1807 |
/* LOOP */ ; |
1808 |
} |
1809 |
if (getreply (0) == ERROR && code == 552) { |
1810 |
/* 552 needed for nic style abort */ |
1811 |
getreply (0); |
1812 |
} |
1813 |
getreply (0); |
1814 |
} |