Annotation of libwww/Library/src/HTFTP.c, revision 1.1.1.1
1.1 timbl 1: /* File Transfer Protocol (FTP) Client
2: ** for a WorldWideWeb browser
3: ** ===================================
4: **
5: ** A cache of control connections is kept.
6: **
7: ** Note: Port allocation
8: **
9: ** It is essential that the port is allocated by the system, rather
10: ** than chosen in rotation by us (POLL_PORTS), or the following
11: ** problem occurs.
12: **
13: ** It seems that an attempt by the server to connect to a port which has
14: ** been used recently by a listen on the same socket, or by another
15: ** socket this or another process causes a hangup of (almost exactly)
16: ** one minute. Therefore, we have to use a rotating port number.
17: ** The problem remains that if the application is run twice in quick
18: ** succession, it will hang for what remains of a minute.
19: **
20: ** Authors
21: ** TBL Tim Berners-lee <timbl@info.cern.ch>
22: ** DD Denis DeLaRoca 310 825-4580 <CSP1DWD@mvs.oac.ucla.edu>
23: ** History:
24: ** 2 May 91 Written TBL, as a part of the WorldWideWeb project.
25: ** 15 Jan 92 Bug fix: close() was used for NETCLOSE for control soc
26: ** 10 Feb 92 Retry if cached connection times out or breaks
27: ** 8 Dec 92 Bug fix 921208 TBL after DD
28: ** 17 Dec 92 Anon FTP password now just WWWuser@ suggested by DD
29: **
30: ** Options:
31: ** LISTEN We listen, the other guy connects for data.
32: ** Otherwise, other way round, but problem finding our
33: ** internet address!
34: **
35: ** Bugs:
36: ** No binary mode! Always uses ASCII!
37: */
38:
39: #define LISTEN /* @@@@ Test */
40:
41: /*
42: BUGS: @@@ Limit connection cache size!
43: Error reporting to user.
44: 400 & 500 errors are acked by user with windows.
45: Use configuration file for user names
46: Prompt user for password
47:
48: ** Note for portablility this version does not use select() and
49: ** so does not watch the control and data channels at the
50: ** same time.
51: */
52:
53: #define REPEAT_PORT /* Give the port number for each file */
54: #define REPEAT_LISTEN /* Close each listen socket and open a new one */
55:
56: /* define POLL_PORTS If allocation does not work, poll ourselves.*/
57: #define LISTEN_BACKLOG 2 /* Number of pending connect requests (TCP)*/
58:
59: #define FIRST_TCP_PORT 1024 /* Region to try for a listening port */
60: #define LAST_TCP_PORT 5999
61:
62: #define LINE_LENGTH 256
63: #define COMMAND_LENGTH 256
64:
65: #include "HTParse.h"
66: #include "HTUtils.h"
67: #include "tcp.h"
68: #include "HTTCP.h"
69: #include "HTAnchor.h"
70: #include "HText.h"
71: #include "HTStyle.h"
72:
73: #include "HTFTP.h"
74:
75: #ifndef IPPORT_FTP
76: #define IPPORT_FTP 21
77: #endif
78:
79: extern HTStyleSheet * styleSheet;
80: PRIVATE HTStyle *h1Style; /* For heading level 1 */
81: PRIVATE HTStyle *h2Style; /* For heading level 2 */
82: PRIVATE HTStyle *textStyle; /* Text style */
83: PRIVATE HTStyle *dirStyle; /* Compact List style */
84:
85: #ifdef REMOVED_CODE
86: extern char *malloc();
87: extern void free();
88: extern char *strncpy();
89: #endif
90:
91: typedef struct _connection {
92: struct _connection * next; /* Link on list */
93: u_long addr; /* IP address */
94: int socket; /* Socket number for communication */
95: BOOL binary; /* Binary mode? */
96: } connection;
97:
98: #ifndef NIL
99: #define NIL 0
100: #endif
101:
102:
103: /* Module-Wide Variables
104: ** ---------------------
105: */
106: PRIVATE connection * connections =0; /* Linked list of connections */
107: PRIVATE char response_text[LINE_LENGTH+1];/* Last response from NewsHost */
108: PRIVATE connection * control; /* Current connection */
109: PRIVATE int data_soc = -1; /* Socket for data transfer =invalid */
110:
111: #ifdef POLL_PORTS
112: PRIVATE unsigned short port_number = FIRST_TCP_PORT;
113: #endif
114:
115: #ifdef LISTEN
116: PRIVATE int master_socket = -1; /* Listening socket = invalid */
117: PRIVATE char port_command[255]; /* Command for setting the port */
118: PRIVATE fd_set open_sockets; /* Mask of active channels */
119: PRIVATE int num_sockets; /* Number of sockets to scan */
120: #else
121: PRIVATE unsigned short passive_port; /* Port server specified for data */
122: #endif
123:
124:
125: #define NEXT_CHAR HTGetChararcter() /* Use function in HTFormat.c */
126:
127: #define DATA_BUFFER_SIZE 2048
128: PRIVATE char data_buffer[DATA_BUFFER_SIZE]; /* Input data buffer */
129: PRIVATE char * data_read_pointer;
130: PRIVATE char * data_write_pointer;
131: #define NEXT_DATA_CHAR next_data_char()
132:
133:
134: /* Procedure: Read a character from the data connection
135: ** ----------------------------------------------------
136: */
137: PRIVATE char next_data_char
138: NOARGS
139: {
140: int status;
141: if (data_read_pointer >= data_write_pointer) {
142: status = NETREAD(data_soc, data_buffer, DATA_BUFFER_SIZE);
143: /* Get some more data */
144: if (status <= 0) return (char)-1;
145: data_write_pointer = data_buffer + status;
146: data_read_pointer = data_buffer;
147: }
148: #ifdef NOT_ASCII
149: {
150: char c = *data_read_pointer++;
151: return FROMASCII(c);
152: }
153: #else
154: return *data_read_pointer++;
155: #endif
156: }
157:
158:
159: /* Close an individual connection
160: **
161: */
162: #ifdef __STDC__
163: PRIVATE int close_connection(connection * con)
164: #else
165: PRIVATE int close_connection(con)
166: connection *con;
167: #endif
168: {
169: connection * scan;
170: int status = NETCLOSE(con->socket);
171: if (TRACE) fprintf(stderr, "FTP: Closing control socket %d\n", con->socket);
172: if (connections==con) {
173: connections = con->next;
174: return status;
175: }
176: for(scan=connections; scan; scan=scan->next) {
177: if (scan->next == con) {
178: scan->next = con->next; /* Unlink */
179: if (control==con) control = (connection*)0;
180: return status;
181: } /*if */
182: } /* for */
183: return -1; /* very strange -- was not on list. */
184: }
185:
186:
187: /* Execute Command and get Response
188: ** --------------------------------
189: **
190: ** See the state machine illustrated in RFC959, p57. This implements
191: ** one command/reply sequence. It also interprets lines which are to
192: ** be continued, which are marked with a "-" immediately after the
193: ** status code.
194: **
195: ** On entry,
196: ** con points to the connection which is established.
197: ** cmd points to a command, or is NIL to just get the response.
198: **
199: ** The command is terminated with the CRLF pair.
200: **
201: ** On exit,
202: ** returns: The first digit of the reply type,
203: ** or negative for communication failure.
204: */
205: #ifdef __STDC__
206: PRIVATE int response(char * cmd)
207: #else
208: PRIVATE int response(cmd)
209: char * cmd;
210: #endif
211: {
212: int result; /* Three-digit decimal code */
213: char continuation;
214: int status;
215:
216: if (!control) {
217: if(TRACE) fprintf(stderr, "FTP: No control connection set up!!\n");
218: return -99;
219: }
220:
221: if (cmd) {
222:
223: if (TRACE) fprintf(stderr, " Tx: %s", cmd);
224:
225: #ifdef NOT_ASCII
226: {
227: char * p;
228: for(p=cmd; *p; p++) {
229: *p = TOASCII(*p);
230: }
231: }
232: #endif
233: status = NETWRITE(control->socket, cmd, (int)strlen(cmd));
234: if (status<0) {
235: if (TRACE) fprintf(stderr,
236: "FTP: Error %d sending command: closing socket %d\n",
237: status, control->socket);
238: close_connection(control);
239: return status;
240: }
241: }
242:
243: do {
244: char *p = response_text;
245: for(;;) {
246: if (((*p++=NEXT_CHAR) == '\n')
247: || (p == &response_text[LINE_LENGTH])) {
248: *p++=0; /* Terminate the string */
249: if (TRACE) fprintf(stderr, " Rx: %s", response_text);
250: sscanf(response_text, "%d%c", &result, &continuation);
251: break;
252: } /* if end of line */
253:
254: if (*(p-1) < 0) {
255: if(TRACE) fprintf(stderr, "Error on rx: closing socket %d\n",
256: control->socket);
257: strcpy(response_text, "000 *** TCP read error on response\n");
258: close_connection(control);
259: return -1; /* End of file on response */
260: }
261: } /* Loop over characters */
262:
263: } while (continuation == '-');
264:
265: if (result==421) {
266: if(TRACE) fprintf(stderr, "FTP: They close so we close socket %d\n",
267: control->socket);
268: close_connection(control);
269: return -1;
270: }
271: return result/100;
272: }
273:
274:
275: /* Get a valid connection to the host
276: ** ----------------------------------
277: **
278: ** On entry,
279: ** arg points to the name of the host in a hypertext address
280: ** On exit,
281: ** returns <0 if error
282: ** socket number if success
283: **
284: ** This routine takes care of managing timed-out connections, and
285: ** limiting the number of connections in use at any one time.
286: **
287: ** It ensures that all connections are logged in if they exist.
288: ** It ensures they have the port number transferred.
289: */
290: PRIVATE int get_connection ARGS1 (CONST char *,arg)
291: {
292: struct sockaddr_in soc_address; /* Binary network address */
293: struct sockaddr_in* sin = &soc_address;
294:
295: char * username=0;
296: char * password=0;
297:
298: if (!arg) return -1; /* Bad if no name sepcified */
299: if (!*arg) return -1; /* Bad if name had zero length */
300:
301: /* Set up defaults:
302: */
303: sin->sin_family = AF_INET; /* Family, host order */
304: sin->sin_port = htons(IPPORT_FTP); /* Well Known Number */
305:
306: if (TRACE) fprintf(stderr, "FTP: Looking for %s\n", arg);
307:
308: /* Get node name:
309: */
310: {
311: char *p1 = HTParse(arg, "", PARSE_HOST);
312: char *p2 = strchr(p1, '@'); /* user? */
313: char * pw;
314: if (p2) {
315: username = p1;
316: *p2=0; /* terminate */
317: p1 = p2+1; /* point to host */
318: pw = strchr(username, ':');
319: if (pw) {
320: *pw++ = 0;
321: password = pw;
322: }
323: }
324: if (HTParseInet(sin, p1)) { free(p1); return -1;} /* TBL 920622 */
325:
326: if (!username) free(p1);
327: } /* scope of p1 */
328:
329:
330: /* Now we check whether we already have a connection to that port.
331: */
332:
333: {
334: connection * scan;
335: for (scan=connections; scan; scan=scan->next) {
336: if (sin->sin_addr.s_addr == scan->addr) {
337: if (TRACE) fprintf(stderr,
338: "FTP: Already have connection for %d.%d.%d.%d.\n",
339: (int)*((unsigned char *)(&scan->addr)+0),
340: (int)*((unsigned char *)(&scan->addr)+1),
341: (int)*((unsigned char *)(&scan->addr)+2),
342: (int)*((unsigned char *)(&scan->addr)+3));
343: if (username) free(username);
344: return scan->socket; /* Good return */
345: } else {
346: if (TRACE) fprintf(stderr,
347: "FTP: Existing connection is %d.%d.%d.%d\n",
348: (int)*((unsigned char *)(&scan->addr)+0),
349: (int)*((unsigned char *)(&scan->addr)+1),
350: (int)*((unsigned char *)(&scan->addr)+2),
351: (int)*((unsigned char *)(&scan->addr)+3));
352: }
353: }
354: }
355:
356:
357: /* Now, let's get a socket set up from the server:
358: */
359: {
360: int status;
361: connection * con = (connection *)malloc(sizeof(*con));
362: if (con == NULL) outofmem(__FILE__, "get_connection");
363: con->addr = sin->sin_addr.s_addr; /* save it */
364: con->binary = NO;
365: status = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
366: if (status<0) {
367: (void) HTInetStatus("socket");
368: free(con);
369: if (username) free(username);
370: return status;
371: }
372: con->socket = status;
373:
374: status = connect(con->socket, (struct sockaddr*)&soc_address,
375: sizeof(soc_address));
376: if (status<0){
377: (void) HTInetStatus("connect");
378: if (TRACE) fprintf(stderr,
379: "FTP: Unable to connect to remote host for `%s'.\n",
380: arg);
381: NETCLOSE(con->socket);
382: free(con);
383: if (username) free(username);
384: return status; /* Bad return */
385: }
386:
387: if (TRACE) fprintf(stderr, "FTP connected, socket %d\n", con->socket);
388: control = con; /* Current control connection */
389: con->next = connections; /* Link onto list of good ones */
390: connections = con;
391: HTInitInput(con->socket);/* Initialise buffering for contron connection */
392:
393:
394: /* Now we log in Look up username, prompt for pw.
395: */
396: {
397: int status = response(NIL); /* Get greeting */
398:
399: if (status == 2) { /* Send username */
400: char * command;
401: if (username) {
402: command = (char*)malloc(10+strlen(username)+2+1);
403: if (command == NULL) outofmem(__FILE__, "get_connection");
404: sprintf(command, "USER %s\r\n", username);
405: } else {
406: command = (char*)malloc(25);
407: if (command == NULL) outofmem(__FILE__, "get_connection");
408: sprintf(command, "USER anonymous\r\n");
409: }
410: status = response(command);
411: free(command);
412: }
413: if (status == 3) { /* Send password */
414: char * command;
415: if (password) {
416: command = (char*)malloc(10+strlen(password)+2+1);
417: if (command == NULL) outofmem(__FILE__, "get_connection");
418: sprintf(command, "PASS %s\r\n", password);
419: } else {
420: #ifdef ANON_FTP_HOSTNAME
421: command = (char*)malloc(20+strlen(HTHostName())+2+1);
422: if (command == NULL) outofmem(__FILE__, "get_connection");
423: sprintf(command,
424: "PASS WWWuser@%s\r\n", HTHostName()); /*@@*/
425: #else
426: /* In fact ftp.uu.net for example prefers just "@"
427: the fulle domain name, which we can't get - DD */
428: command = (char*)malloc(20);
429: if (command == NULL) outofmem(__FILE__, "get_connection");
430: sprintf(command, "PASS WWWuser@\r\n"); /*@@*/
431: #endif
432: }
433: status = response(command);
434: free(command);
435: }
436: if (username) free(username);
437:
438: if (status == 3) status = response("ACCT noaccount\r\n");
439:
440: if (status !=2) {
441: if (TRACE) fprintf(stderr, "FTP: Login fail: %s", response_text);
442: if (control) close_connection(control);
443: return -1; /* Bad return */
444: }
445: if (TRACE) fprintf(stderr, "FTP: Logged in.\n");
446: }
447:
448: /* Now we inform the server of the port number we will listen on
449: */
450: #ifndef REPEAT_PORT
451: {
452: int status = response(port_command);
453: if (status !=2) {
454: if (control) close_connection(control);
455: return -status; /* Bad return */
456: }
457: if (TRACE) fprintf(stderr, "FTP: Port defined.\n");
458: }
459: #endif
460: return con->socket; /* Good return */
461: } /* Scope of con */
462: }
463:
464:
465: #ifdef LISTEN
466:
467: /* Close Master (listening) socket
468: ** -------------------------------
469: **
470: **
471: */
472: #ifdef __STDC__
473: PRIVATE int close_master_socket(void)
474: #else
475: PRIVATE int close_master_socket()
476: #endif
477: {
478: int status;
479: FD_CLR(master_socket, &open_sockets);
480: status = NETCLOSE(master_socket);
481: if (TRACE) fprintf(stderr, "FTP: Closed master socket %d\n", master_socket);
482: master_socket = -1;
483: if (status<0) return HTInetStatus("close master socket");
484: else return status;
485: }
486:
487:
488: /* Open a master socket for listening on
489: ** -------------------------------------
490: **
491: ** When data is transferred, we open a port, and wait for the server to
492: ** connect with the data.
493: **
494: ** On entry,
495: ** master_socket Must be negative if not set up already.
496: ** On exit,
497: ** Returns socket number if good
498: ** less than zero if error.
499: ** master_socket is socket number if good, else negative.
500: ** port_number is valid if good.
501: */
502: #ifdef __STDC__
503: PRIVATE int get_listen_socket(void)
504: #else
505: PRIVATE int get_listen_socket()
506: #endif
507: {
508: struct sockaddr_in soc_address; /* Binary network address */
509: struct sockaddr_in* sin = &soc_address;
510: int new_socket; /* Will be master_socket */
511:
512:
513: FD_ZERO(&open_sockets); /* Clear our record of open sockets */
514: num_sockets = 0;
515:
516: #ifndef REPEAT_LISTEN
517: if (master_socket>=0) return master_socket; /* Done already */
518: #endif
519:
520: /* Create internet socket
521: */
522: new_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
523:
524: if (new_socket<0)
525: return HTInetStatus("socket for master socket");
526:
527: if (TRACE) fprintf(stderr, "FTP: Opened master socket number %d\n", new_socket);
528:
529: /* Search for a free port.
530: */
531: sin->sin_family = AF_INET; /* Family = internet, host order */
532: sin->sin_addr.s_addr = INADDR_ANY; /* Any peer address */
533: #ifdef POLL_PORTS
534: {
535: unsigned short old_port_number = port_number;
536: for(port_number=old_port_number+1;;port_number++){
537: int status;
538: if (port_number > LAST_TCP_PORT)
539: port_number = FIRST_TCP_PORT;
540: if (port_number == old_port_number) {
541: return HTInetStatus("bind");
542: }
543: soc_address.sin_port = htons(port_number);
544: if ((status=bind(new_socket,
545: (struct sockaddr*)&soc_address,
546: /* Cast to generic sockaddr */
547: sizeof(soc_address))) == 0)
548: break;
549: if (TRACE) fprintf(stderr,
550: "TCP bind attempt to port %d yields %d, errno=%d\n",
551: port_number, status, errno);
552: } /* for */
553: }
554: #else
555: {
556: int status;
557: int address_length = sizeof(soc_address);
558: status = getsockname(control->socket,
559: (struct sockaddr *)&soc_address,
560: &address_length);
561: if (status<0) return HTInetStatus("getsockname");
562: CTRACE(tfp, "FTP: This host is %s\n",
563: HTInetString(sin));
564:
565: soc_address.sin_port = 0; /* Unspecified: please allocate */
566: status=bind(new_socket,
567: (struct sockaddr*)&soc_address,
568: /* Cast to generic sockaddr */
569: sizeof(soc_address));
570: if (status<0) return HTInetStatus("bind");
571:
572: address_length = sizeof(soc_address);
573: status = getsockname(new_socket,
574: (struct sockaddr*)&soc_address,
575: &address_length);
576: if (status<0) return HTInetStatus("getsockname");
577: }
578: #endif
579:
580: CTRACE(tfp, "FTP: bound to port %d on %s\n",
581: (int)ntohs(sin->sin_port),
582: HTInetString(sin));
583:
584: #ifdef REPEAT_LISTEN
585: if (master_socket>=0)
586: (void) close_master_socket();
587: #endif
588:
589: master_socket = new_socket;
590:
591: /* Now we must find out who we are to tell the other guy
592: */
593: (void)HTHostName(); /* Make address valid - doesn't work*/
594: sprintf(port_command, "PORT %d,%d,%d,%d,%d,%d\r\n",
595: (int)*((unsigned char *)(&sin->sin_addr)+0),
596: (int)*((unsigned char *)(&sin->sin_addr)+1),
597: (int)*((unsigned char *)(&sin->sin_addr)+2),
598: (int)*((unsigned char *)(&sin->sin_addr)+3),
599: (int)*((unsigned char *)(&sin->sin_port)+0),
600: (int)*((unsigned char *)(&sin->sin_port)+1));
601:
602:
603: /* Inform TCP that we will accept connections
604: */
605: if (listen(master_socket, 1)<0) {
606: master_socket = -1;
607: return HTInetStatus("listen");
608: }
609: CTRACE(tfp, "TCP: Master socket(), bind() and listen() all OK\n");
610: FD_SET(master_socket, &open_sockets);
611: if ((master_socket+1) > num_sockets) num_sockets=master_socket+1;
612:
613: return master_socket; /* Good */
614:
615: } /* get_listen_socket */
616: #endif
617:
618:
619: /* Get Styles from stylesheet
620: ** --------------------------
621: */
622: PRIVATE void get_styles NOARGS
623: {
624: if (!h1Style) h1Style = HTStyleNamed(styleSheet, "Heading1");
625: if (!h2Style) h2Style = HTStyleNamed(styleSheet, "Heading2");
626: if (!textStyle) textStyle = HTStyleNamed(styleSheet, "Example");
627: if (!dirStyle) dirStyle = HTStyleNamed(styleSheet, "Dir");
628: }
629:
630:
631: /* Read a directory into an hypertext object from the data socket
632: ** --------------------------------------------------------------
633: **
634: ** On entry,
635: ** anchor Parent anchor to link the HText to
636: ** address Address of the directory
637: ** On exit,
638: ** returns HT_LOADED if OK
639: ** <0 if error.
640: */
641: PRIVATE int read_directory
642: ARGS2 (
643: HTParentAnchor *, parent,
644: CONST char *, address
645: )
646: {
647: HText * HT = HText_new (parent);
648: char *filename = HTParse(address, "", PARSE_PATH + PARSE_PUNCTUATION);
649: HTChildAnchor * child; /* corresponds to an entry of the directory */
650: char c = 0;
651: #define LASTPATH_LENGTH 150 /* @@@@ Horrible limit on the entry size */
652: char lastpath[LASTPATH_LENGTH + 1];
653: char *p, *entry;
654:
655: HText_beginAppend (HT);
656: get_styles();
657:
658: HTAnchor_setTitle (parent, "FTP Directory of ");
659: HTAnchor_appendTitle (parent, address + 5); /* +5 gets rid of "file:" */
660: HText_setStyle (HT, h1Style);
661: HText_appendText (HT, filename);
662:
663: HText_setStyle (HT, dirStyle);
664: data_read_pointer = data_write_pointer = data_buffer;
665:
666: if (*filename == 0) /* Empty filename : use root */
667: strcpy (lastpath, "/");
668: else {
669: p = filename + strlen (filename) - 2;
670: while (p >= filename && *p != '/')
671: p--;
672: strcpy (lastpath, p + 1); /* relative path */
673: }
674: free (filename);
675: entry = lastpath + strlen (lastpath);
676: if (*(entry-1) != '/')
677: *entry++ = '/'; /* ready to append entries */
678:
679: if (strlen (lastpath) > 1) { /* Current file is not the FTP root */
680: strcpy (entry, "..");
681: child = HTAnchor_findChildAndLink (parent, 0, lastpath, 0);
682: HText_beginAnchor (HT, child);
683: HText_appendText (HT, "Parent Directory");
684: HText_endAnchor (HT);
685: HText_appendCharacter (HT, '\t');
686: }
687: for (;;) {
688: p = entry;
689: while (p - lastpath < LASTPATH_LENGTH) {
690: c = NEXT_DATA_CHAR;
691: if (c == '\r') {
692: c = NEXT_DATA_CHAR;
693: if (c != '\n') {
694: if (TRACE)
695: printf ("Warning: No newline but %d after carriage return.\n", c);
696: break;
697: }
698: }
699: if (c == '\n' || c == (char) EOF)
700: break;
701: *p++ = c;
702: }
703: if (c == (char) EOF && p == entry)
704: break;
705: *p = 0;
706: child = HTAnchor_findChildAndLink (parent, 0, lastpath, 0);
707: HText_beginAnchor (HT, child);
708: HText_appendText (HT, entry);
709: HText_endAnchor (HT);
710: HText_appendCharacter (HT, '\t');
711: }
712:
713: HText_appendParagraph (HT);
714: HText_endAppend (HT);
715: return response(NIL) == 2 ? HT_LOADED : -1;
716: }
717:
718:
719: /* Retrieve File from Server
720: ** -------------------------
721: **
722: ** On entry,
723: ** name WWW address of a file: document, including hostname
724: ** On exit,
725: ** returns Socket number for file if good.
726: ** <0 if bad.
727: */
728: PUBLIC int HTFTP_open_file_read
729: ARGS2 (
730: CONST char *, name,
731: HTParentAnchor *, anchor
732: )
733: {
734: BOOL isDirectory = NO;
735: int status;
736: int retry; /* How many times tried? */
737:
738: for (retry=0; retry<2; retry++) { /* For timed out/broken connections */
739:
740: status = get_connection(name);
741: if (status<0) return status;
742:
743: #ifdef LISTEN
744: status = get_listen_socket();
745: if (status<0) return status;
746:
747: #ifdef REPEAT_PORT
748: /* Inform the server of the port number we will listen on
749: */
750: {
751: status = response(port_command);
752: if (status !=2) { /* Could have timed out */
753: if (status<0) continue; /* try again - net error*/
754: return -status; /* bad reply */
755: }
756: if (TRACE) fprintf(stderr, "FTP: Port defined.\n");
757: }
758: #endif
759: #else /* Use PASV */
760: /* Tell the server to be passive
761: */
762: {
763: char *p;
764: int reply, h0, h1, h2, h3, p0, p1; /* Parts of reply */
765: status = response("PASV\r\n");
766: if (status !=2) {
767: if (status<0) continue; /* retry or Bad return */
768: return -status; /* bad reply */
769: }
770: for(p=response_text; *p; p++)
771: if ((*p<'0')||(*p>'9')) *p = ' '; /* Keep only digits */
772: status = sscanf(response_text, "%d%d%d%d%d%d%d",
773: &reply, &h0, &h1, &h2, &h3, &p0, &p1);
774: if (status<5) {
775: if (TRACE) fprintf(stderr, "FTP: PASV reply has no inet address!\n");
776: return -99;
777: }
778: passive_port = (p0<<8) + p1;
779: if (TRACE) fprintf(stderr, "FTP: Server is listening on port %d\n",
780: passive_port);
781: }
782:
783: /* Open connection for data:
784: */
785: {
786: struct sockaddr_in soc_address;
787: int status = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
788: if (status<0) {
789: (void) HTInetStatus("socket for data socket");
790: return status;
791: }
792: data_soc = status;
793:
794: soc_address.sin_addr.s_addr = control->addr;
795: soc_address.sin_port = htons(passive_port);
796: soc_address.sin_family = AF_INET; /* Family, host order */
797: if (TRACE) fprintf(stderr,
798: "FTP: Data remote address is port %d, inet %d.%d.%d.%d\n",
799: (unsigned int)ntohs(soc_address.sin_port),
800: (int)*((unsigned char *)(&soc_address.sin_addr)+0),
801: (int)*((unsigned char *)(&soc_address.sin_addr)+1),
802: (int)*((unsigned char *)(&soc_address.sin_addr)+2),
803: (int)*((unsigned char *)(&soc_address.sin_addr)+3));
804:
805: status = connect(data_soc, (struct sockaddr*)&soc_address,
806: sizeof(soc_address));
807: if (status<0){
808: (void) HTInetStatus("connect for data");
809: NETCLOSE(data_soc);
810: return status; /* Bad return */
811: }
812:
813: if (TRACE) fprintf(stderr, "FTP data connected, socket %d\n", data_soc);
814: }
815: #endif /* use PASV */
816: status = 0;
817: break; /* No more retries */
818:
819: } /* for retries */
820: if (status<0) return status; /* Failed with this code */
821:
822: /* Ask for the file:
823: */
824: {
825: char *filename = HTParse(name, "", PARSE_PATH + PARSE_PUNCTUATION);
826: char command[LINE_LENGTH+1];
827: if (!*filename) StrAllocCopy(filename, "/");
828: sprintf(command, "RETR %s\r\n", filename);
829: status = response(command);
830: if (status != 1) { /* Failed : try to CWD to it */
831: sprintf(command, "CWD %s\r\n", filename);
832: status = response(command);
833: if (status == 2) { /* Successed : let's NAME LIST it */
834: isDirectory = YES;
835: sprintf(command, "NLST\r\n");
836: status = response (command);
837: }
838: }
839: free(filename);
840: if (status != 1) return -status; /* Action not started */
841: }
842:
843: #ifdef LISTEN
844: /* Wait for the connection
845: */
846: {
847: struct sockaddr_in soc_address;
848: int soc_addrlen=sizeof(soc_address);
849: status = accept(master_socket,
850: (struct sockaddr *)&soc_address,
851: &soc_addrlen);
852: if (status<0)
853: return HTInetStatus("accept");
854: CTRACE(tfp, "TCP: Accepted new socket %d\n", status);
855: data_soc = status;
856: }
857: #else
858: /* @@ */
859: #endif
860: if (isDirectory)
861: return read_directory (anchor, name);
862: /* returns HT_LOADED or error */
863: else
864: return data_soc;
865:
866: } /* open_file_read */
867:
868:
869: /* Close socket opened for reading a file, and get final message
870: ** -------------------------------------------------------------
871: **
872: */
873: PUBLIC int HTFTP_close_file
874: ARGS1 (int,soc)
875: {
876: int status;
877:
878: if (soc!=data_soc) {
879: if (TRACE) fprintf(stderr,
880: "HTFTP: close socket %d: (not FTP data socket).\n",
881: soc);
882: return NETCLOSE(soc);
883: }
884:
885: HTInitInput(control->socket);
886: /* Reset buffering to control connection DD 921208 */
887:
888: status = NETCLOSE(data_soc);
889: if (TRACE) fprintf(stderr, "FTP: Closing data socket %d\n", data_soc);
890: if (status<0) (void) HTInetStatus("close"); /* Comment only */
891: data_soc = -1; /* invalidate it */
892:
893: status = response(NIL);
894: if (status!=2) return -status;
895:
896: return status; /* Good */
897: }
898:
899:
900: /*___________________________________________________________________________
901: */
902: /* Test program only
903: ** -----------------
904: **
905: ** Compiling this with -DTEST produces a test program. Unix only
906: **
907: ** Syntax:
908: ** test <file or option> ...
909: **
910: ** options: -v Verbose: Turn trace on at this point
911: */
912: #ifdef TEST
913:
914: PUBLIC int WWW_TraceFlag;
915:
916: #ifdef __STDC__
917: int main(int argc, char*argv[])
918: #else
919: int main(argc, argv)
920: int argc;
921: char *argv[];
922: #endif
923: {
924:
925: int arg; /* Argument number */
926: int status;
927: connection * con;
928: WWW_TraceFlag = (0==strcmp(argv[1], "-v")); /* diagnostics ? */
929:
930: #ifdef SUPRESS
931: status = get_listen_socket();
932: if (TRACE) fprintf(stderr, "get_listen_socket returns %d\n\n", status);
933: if (status<0) exit(status);
934:
935: status = get_connection(argv[1]); /* test double use */
936: if (TRACE) fprintf(stderr, "get_connection(`%s') returned %d\n\n", argv[1], status);
937: if (status<0) exit(status);
938: #endif
939:
940: for(arg=1; arg<argc; arg++) { /* For each argument */
941: if (0==strcmp(argv[arg], "-v")) {
942: WWW_TraceFlag = 1; /* -v => Trace on */
943:
944: } else { /* Filename: */
945:
946: status = HTTP_open_file_read(argv[arg]);
947: if (TRACE) fprintf(stderr, "open_file_read returned %d\n\n", status);
948: if (status<0) exit(status);
949:
950: /* Copy the file to std out:
951: */
952: {
953: char buffer[INPUT_BUFFER_SIZE];
954: for(;;) {
955: int status = NETREAD(data_soc, buffer, INPUT_BUFFER_SIZE);
956: if (status<=0) {
957: if (status<0) (void) HTInetStatus("read");
958: break;
959: }
960: status = write(1, buffer, status);
961: if (status<0) {
962: fprintf(stderr, "Write failure!\n");
963: break;
964: }
965: }
966: }
967:
968: status = HTTP_close_file(data_soc);
969: if (TRACE) fprintf(stderr, "Close_file returned %d\n\n", status);
970:
971: } /* if */
972: } /* for */
973: status = response("QUIT\r\n"); /* Be good */
974: if (TRACE) fprintf(stderr, "Quit returned %d\n", status);
975:
976: while(connections) close_connection(connections);
977:
978: close_master_socket();
979:
980: } /* main */
981: #endif /* TEST */
982:
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTFTP.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src