Annotation of libwww/Library/src/HTFTP.c, revision 1.75
1.46 frystyk 1: /* HTFTP.c
2: ** FILE TRANSFER PROTOCOL (FTP) CLIENT
3: **
1.52 frystyk 4: ** (c) COPYRIGHT MIT 1995.
1.46 frystyk 5: ** Please first read the full copyright statement in the file COPYRIGH.
1.1 timbl 6: **
7: ** A cache of control connections is kept.
8: **
9: ** Note: Port allocation
10: **
11: ** It is essential that the port is allocated by the system, rather
12: ** than chosen in rotation by us (POLL_PORTS), or the following
13: ** problem occurs.
14: **
15: ** It seems that an attempt by the server to connect to a port which has
16: ** been used recently by a listen on the same socket, or by another
17: ** socket this or another process causes a hangup of (almost exactly)
18: ** one minute. Therefore, we have to use a rotating port number.
19: ** The problem remains that if the application is run twice in quick
20: ** succession, it will hang for what remains of a minute.
21: **
22: ** Authors
1.54 frystyk 23: ** TBL Tim Berners-lee <timbl@w3.org>
1.1 timbl 24: ** DD Denis DeLaRoca 310 825-4580 <CSP1DWD@mvs.oac.ucla.edu>
1.22 frystyk 25: ** LM Lou Montulli <montulli@ukanaix.cc.ukans.edu>
26: ** FM Foteos Macrides <macrides@sci.wfeb.edu>
1.54 frystyk 27: ** HF Henrik Frystyk <frystyk@w3.org>
1.30 luotonen 28: ** AL Ari Luotonen <luotonen@www.cern.ch>
1.23 frystyk 29: **
1.1 timbl 30: ** History:
31: ** 2 May 91 Written TBL, as a part of the WorldWideWeb project.
32: ** 15 Jan 92 Bug fix: close() was used for NETCLOSE for control soc
33: ** 10 Feb 92 Retry if cached connection times out or breaks
34: ** 8 Dec 92 Bug fix 921208 TBL after DD
35: ** 17 Dec 92 Anon FTP password now just WWWuser@ suggested by DD
1.2 timbl 36: ** fails on princeton.edu!
1.22 frystyk 37: ** 27 Dec 93 (FM) Fixed up so FTP now works with VMS hosts. Path
38: ** must be Unix-style and cannot include the device
39: ** or top directory.
40: ** ?? ??? ?? (LM) Added code to prompt and send passwords for non
41: ** anonymous FTP
42: ** 25 Mar 94 (LM) Added code to recognize different ftp server types
43: ** and code to parse dates and sizes on most hosts.
44: ** 27 Mar 93 (FM) Added code for getting dates and sizes on VMS hosts.
1.23 frystyk 45: ** 27 Apr 94 (HF) The module is basically rewritten to conform with
46: ** rfc 959, 1123 and 1579 and turned into a state
47: ** machine. New semantics of ftp URLs are supported.
1.30 luotonen 48: ** 2 May 94 (AL) Fixed possible security hole when the URL contains
49: ** a newline, that could cause multiple commands to be
50: ** sent to an FTP server.
1.60 frystyk 51: ** Sep 95 HFN Rewritten to support streams and persistent conenctions
52: ** and multiplexed IO
1.22 frystyk 53: ** Notes:
54: ** Portions Copyright 1994 Trustees of Dartmouth College
55: ** Code for recognizing different FTP servers and
56: ** parsing "ls -l" output taken from Macintosh Fetch
57: ** program with permission from Jim Matthews,
58: ** Dartmouth Software Development Team.
1.23 frystyk 59: */
1.1 timbl 60:
1.22 frystyk 61: /* Library include files */
1.48 frystyk 62: #include "tcp.h"
63: #include "HTUtils.h"
64: #include "HTString.h"
1.1 timbl 65: #include "HTParse.h"
66: #include "HTTCP.h"
67: #include "HTAnchor.h"
1.51 frystyk 68: #include "HTBind.h"
1.53 frystyk 69: #include "HTSocket.h"
1.60 frystyk 70: #include "HTWriter.h"
1.6 secret 71: #include "HTChunk.h"
1.22 frystyk 72: #include "HTAlert.h"
1.60 frystyk 73: #include "HTFormat.h"
74: #include "HTStream.h"
1.33 frystyk 75: #include "HTError.h"
1.58 frystyk 76: #include "HTReqMan.h"
1.60 frystyk 77: #include "HTNetMan.h"
1.63 frystyk 78: #include "HTFTPDir.h"
1.22 frystyk 79: #include "HTFTP.h" /* Implemented here */
80:
81: /* Macros and other defines */
1.60 frystyk 82: #if 0
83: /* Only use this if ABSOLUTELY necessary! */
84: #define POLL_PORTS /* If allocation does not work, poll ourselves.*/
1.1 timbl 85: #endif
86:
87: #ifdef POLL_PORTS
1.23 frystyk 88: #define FIRST_TCP_PORT 1024 /* Region to try for a listening port */
89: #define LAST_TCP_PORT 5999
1.60 frystyk 90: PRIVATE int DataPort = FIRST_TCP_PORT;
1.1 timbl 91: #endif
92:
1.60 frystyk 93: #ifndef FTP_PORT
94: #define FTP_PORT 21
95: #define FTP_DATA 20
1.1 timbl 96: #endif
1.60 frystyk 97:
98: #define WWW_FTP_CLIENT "libwww@" /* If can't get user-info, use this */
99: #define FTP_DIR(me) ((me)->type=='L' || (me)->type=='N')
1.1 timbl 100:
1.58 frystyk 101: /*
102: ** Local context structure used in the HTNet object.
103: */
1.45 frystyk 104: typedef enum _HTFTPState {
1.60 frystyk 105: FTP_SUCCESS = -2,
106: FTP_ERROR = -1,
1.58 frystyk 107: FTP_BEGIN = 0,
108: FTP_NEED_CCON, /* Control connection */
1.60 frystyk 109: FTP_NEED_LOGIN,
1.58 frystyk 110: FTP_NEED_DCON, /* Data connection */
1.60 frystyk 111: FTP_NEED_DATA,
112: FTP_NEED_SERVER /* For directory listings */
1.39 frystyk 113: } HTFTPState;
114:
1.58 frystyk 115: typedef struct _ftp_ctrl {
1.60 frystyk 116: HTChunk * cmd;
117: int repcode;
118: char * reply;
119: char * uid;
1.58 frystyk 120: char * passwd;
1.60 frystyk 121: char * account;
1.58 frystyk 122: HTFTPState state; /* State of the connection */
1.60 frystyk 123: int substate; /* For hierarchical states */
124: BOOL sent; /* Read or write command */
125: BOOL cwd; /* Done cwd */
126: BOOL reset; /* Expect greeting */
1.63 frystyk 127: FTPServerType server; /* Type of server */
1.60 frystyk 128: HTNet * dnet; /* Data connection */
1.58 frystyk 129: } ftp_ctrl;
1.39 frystyk 130:
1.58 frystyk 131: typedef struct _ftp_data {
1.60 frystyk 132: char host[30]; /* Host to contact for data */
133: char * file; /* File or dir name */
134: char * offset; /* offset into file */
135: BOOL pasv; /* Active or passive */
136: char type; /* 'A', 'I', 'L'(IST), 'N'(LST) */
1.63 frystyk 137: BOOL ready; /* True if either ctrl or data is HT_LOADED */
1.58 frystyk 138: } ftp_data;
1.39 frystyk 139:
1.60 frystyk 140: struct _HTStream {
141: CONST HTStreamClass * isa;
142: HTStream * target;
143: HTRequest * request;
144: ftp_ctrl * ctrl;
145: HTSocketEOL state;
146: HTChunk * welcome;
1.62 frystyk 147: BOOL junk; /* For too long lines */
1.60 frystyk 148: BOOL first_line;
1.63 frystyk 149: char buffer[MAX_FTP_LINE+1];
1.60 frystyk 150: int buflen;
151: };
152:
153: typedef enum _FTPDataCon {
154: FTP_DATA_PASV = 0x1,
155: FTP_DATA_PORT = 0x2
156: } FTPDataCon;
157:
158: PRIVATE FTPDataCon FTPMode = FTP_DATA_PASV;
1.39 frystyk 159:
1.23 frystyk 160: /* ------------------------------------------------------------------------- */
1.60 frystyk 161: /* FTP Status Line Stream */
1.22 frystyk 162: /* ------------------------------------------------------------------------- */
1.60 frystyk 163:
164: /* FTPCleanup
165: ** ----------
166: ** This function closes the connection and frees memory.
167: ** Returns YES on OK, else NO
168: */
1.65 frystyk 169: PRIVATE int FTPCleanup (HTRequest * request, int status)
1.60 frystyk 170: {
1.75 ! frystyk 171: if (request) {
! 172: HTNet * cnet = request->net;
! 173: ftp_ctrl * ctrl;
! 174:
! 175: /* Free stream with data TO network */
! 176: if (!HTRequest_isDestination(request) && request->input_stream) {
! 177: if (status == HT_INTERRUPTED)
! 178: (*request->input_stream->isa->abort)(request->input_stream,NULL);
! 179: else
! 180: (*request->input_stream->isa->_free)(request->input_stream);
! 181: }
! 182:
! 183: /* Remove the request object and our own context structure for http */
! 184: if (cnet && (ctrl = (ftp_ctrl *) cnet->context) != NULL) {
! 185: HTNet * dnet = ctrl->dnet;
! 186: ftp_data * data;
! 187: HTChunk_delete(ctrl->cmd);
! 188: FREE(ctrl->reply);
! 189: FREE(ctrl->uid);
! 190: FREE(ctrl->passwd);
! 191: FREE(ctrl->account);
! 192: FREE(ctrl);
! 193: if (dnet && (data = (ftp_data *) dnet->context) != NULL) {
! 194: FREE(data->file);
! 195: FREE(data);
! 196: }
! 197: HTNet_delete(dnet, HT_IGNORE);
! 198: }
! 199: HTNet_delete(cnet, status);
! 200: return YES;
1.60 frystyk 201: }
1.75 ! frystyk 202: return NO;
1.60 frystyk 203: }
204:
205: /* ScanResponse
206: ** ------------
207: ** Analyzes the response from the FTP server.
208: ** Returns HT_LOADED if OK, HT_OK if more, HT_ERROR if error
209: ** the control connection.
1.33 frystyk 210: */
1.65 frystyk 211: PRIVATE int ScanResponse (HTStream * me)
1.33 frystyk 212: {
1.60 frystyk 213: int reply = 0;
214: char cont = '\0';
215: char *ptr = me->buffer+4;
216: *(me->buffer+me->buflen) = '\0';
217: if (isdigit(*(me->buffer))) sscanf(me->buffer, "%d%c", &reply, &cont);
218: if (me->first_line) {
1.67 frystyk 219: if (PROT_TRACE) TTYPrint(TDEST, "FTP Rx...... `%s\'\n", me->buffer);
1.60 frystyk 220: if (!reply) return HT_ERROR;
221: me->first_line = NO;
222: me->ctrl->repcode = reply;
223: StrAllocCopy(me->ctrl->reply, ptr);
224: } else {
1.73 frystyk 225: HTChunk_puts(me->welcome, ptr);
226: HTChunk_putc(me->welcome, '\n');
1.33 frystyk 227: }
1.60 frystyk 228: me->buflen = 0;
1.68 frystyk 229: me->state = EOL_BEGIN;
1.60 frystyk 230: if (cont != '-') {
231: me->first_line = YES;
232: return HT_LOADED;
1.33 frystyk 233: }
1.60 frystyk 234: return HT_OK;
1.33 frystyk 235: }
236:
1.60 frystyk 237: /*
238: ** Searches for FTP header line until buffer fills up or a CRLF or LF
239: ** is found
1.23 frystyk 240: */
1.60 frystyk 241: PRIVATE int FTPStatus_put_block (HTStream * me, CONST char * b, int l)
242: {
243: int status;
244: while (l-- > 0) {
245: if (me->state == EOL_FCR) {
246: if (*b == LF) {
1.62 frystyk 247: if (!me->junk) {
248: if ((status = ScanResponse(me)) != HT_OK)
249: return status;
250: } else {
251: me->buflen = 0;
252: me->junk = NO;
253: }
1.60 frystyk 254: }
255: } else if (*b == CR) {
256: me->state = EOL_FCR;
257: } else if (*b == LF) {
1.62 frystyk 258: if (!me->junk) {
259: if ((status = ScanResponse(me)) != HT_OK)
260: return status;
261: } else {
262: me->buflen = 0;
263: me->junk = NO;
264: }
1.60 frystyk 265: } else {
266: *(me->buffer+me->buflen++) = *b;
1.63 frystyk 267: if (me->buflen >= MAX_FTP_LINE) {
1.60 frystyk 268: if (PROT_TRACE)
1.67 frystyk 269: TTYPrint(TDEST, "FTP Status.. Line too long - chopped\n");
1.62 frystyk 270: me->junk = YES;
271: if ((status = ScanResponse(me)) != HT_OK) {
272: me->junk = NO;
273: return status;
274: }
1.23 frystyk 275: }
276: }
1.60 frystyk 277: b++;
1.25 frystyk 278: }
1.60 frystyk 279: return HT_OK;
1.25 frystyk 280: }
281:
1.65 frystyk 282: PRIVATE int FTPStatus_put_string (HTStream * me, CONST char * s)
1.60 frystyk 283: {
284: return FTPStatus_put_block(me, s, (int) strlen(s));
285: }
1.25 frystyk 286:
1.65 frystyk 287: PRIVATE int FTPStatus_put_character (HTStream * me, char c)
1.25 frystyk 288: {
1.60 frystyk 289: return FTPStatus_put_block(me, &c, 1);
290: }
1.25 frystyk 291:
1.65 frystyk 292: PRIVATE int FTPStatus_flush (HTStream * me)
1.60 frystyk 293: {
294: return (*me->target->isa->flush)(me->target);
1.23 frystyk 295: }
1.22 frystyk 296:
1.65 frystyk 297: PRIVATE int FTPStatus_free (HTStream * me)
1.22 frystyk 298: {
1.60 frystyk 299: int status = HT_OK;
300: if (me->target) {
301: if ((status = (*me->target->isa->_free)(me->target)) == HT_WOULD_BLOCK)
302: return HT_WOULD_BLOCK;
1.22 frystyk 303: }
1.73 frystyk 304: HTChunk_delete(me->welcome);
1.60 frystyk 305: free(me);
306: return HT_OK;
1.22 frystyk 307: }
308:
1.68 frystyk 309: PRIVATE int FTPStatus_abort (HTStream * me, HTList * e)
1.22 frystyk 310: {
1.60 frystyk 311: if (me->target)
312: (*me->target->isa->abort)(me->target, e);
1.73 frystyk 313: HTChunk_delete(me->welcome);
1.60 frystyk 314: free(me);
315: if (PROT_TRACE)
1.67 frystyk 316: TTYPrint(TDEST, "FTPStatus... ABORTING...\n");
1.60 frystyk 317: return HT_ERROR;
1.22 frystyk 318: }
319:
1.60 frystyk 320: /* FTPStatus Stream
321: ** -----------------
1.22 frystyk 322: */
1.60 frystyk 323: PRIVATE CONST HTStreamClass FTPStatusClass =
324: {
325: "FTPStatus",
326: FTPStatus_flush,
327: FTPStatus_free,
328: FTPStatus_abort,
329: FTPStatus_put_character,
330: FTPStatus_put_string,
331: FTPStatus_put_block
332: };
333:
1.65 frystyk 334: PRIVATE HTStream * FTPStatus_new (HTRequest * request, ftp_ctrl * ctrl)
1.60 frystyk 335: {
336: HTStream * me = (HTStream *) calloc(1, sizeof(HTStream));
337: if (!me) outofmem(__FILE__, "FTPStatus_new");
338: me->isa = &FTPStatusClass;
339: me->request = request;
340: me->first_line = YES;
1.73 frystyk 341: me->welcome = HTChunk_new(256);
1.60 frystyk 342: me->ctrl = ctrl;
343: me->state = EOL_BEGIN;
344: return me;
1.22 frystyk 345: }
346:
1.60 frystyk 347: /* ------------------------------------------------------------------------- */
348: /* FTP Client Functions for managing control and data connections */
349: /* ------------------------------------------------------------------------- */
1.22 frystyk 350:
1.60 frystyk 351: PRIVATE int SendCommand (HTRequest *request, ftp_ctrl *ctrl,
352: char *token, char *pars)
353: {
354: int len = strlen(token) + (pars ? strlen(pars)+1:0) + 2;
1.73 frystyk 355: HTChunk_clear(ctrl->cmd);
356: HTChunk_ensure(ctrl->cmd, len);
1.60 frystyk 357: if (pars && *pars)
1.73 frystyk 358: sprintf(HTChunk_data(ctrl->cmd), "%s %s%c%c", token, pars, CR, LF);
1.60 frystyk 359: else
1.73 frystyk 360: sprintf(HTChunk_data(ctrl->cmd), "%s%c%c", token, CR, LF);
361: if (PROT_TRACE) TTYPrint(TDEST, "FTP Tx...... %s", HTChunk_data(ctrl->cmd));
1.60 frystyk 362: return (*request->input_stream->isa->put_block)
1.73 frystyk 363: (request->input_stream, HTChunk_data(ctrl->cmd), len);
1.60 frystyk 364: }
365:
366: /* HTFTPParseURL
367: ** -------------
368: ** Scan URL for uid and passwd, and any data type indication. The
369: ** expected format is [user[:password]@]host[:port].
370: ** If no values are found then use defaults.
371: ** Returns YES if OK, else NO
1.22 frystyk 372: */
1.60 frystyk 373: PRIVATE BOOL HTFTPParseURL (char *url, ftp_ctrl *ctrl, ftp_data *data)
1.22 frystyk 374: {
1.60 frystyk 375: char *login = HTParse(url, "", PARSE_HOST);
376: char *path = HTParse(url, "", PARSE_PATH+PARSE_PUNCTUATION);
377: char *ptr = strchr(login, '@');
378: if (ptr) { /* Uid and/or passwd specified */
379: char *passwd;
380: *ptr = '\0';
381: if ((passwd = strchr(login, ':'))) { /* Passwd specified */
382: *passwd++ = '\0';
383: HTUnEscape(passwd);
384: StrAllocCopy(ctrl->passwd, passwd);
1.22 frystyk 385: }
1.60 frystyk 386: HTUnEscape(login);
387: StrAllocCopy(ctrl->uid, login);
388: } else { /* Use anonymous */
389: CONST char *mailaddress = HTGetMailAddress();
390: StrAllocCopy(ctrl->uid, "anonymous");
391: if (mailaddress)
392: StrAllocCopy(ctrl->passwd, mailaddress);
393: else
394: StrAllocCopy(ctrl->passwd, WWW_FTP_CLIENT);
1.22 frystyk 395: }
1.66 frystyk 396: if (PROT_TRACE)
1.67 frystyk 397: TTYPrint(TDEST, "FTPParse.... uid `%s\' pw `%s\'\n",
1.66 frystyk 398: ctrl->uid ? ctrl->uid : "<null>",
399: ctrl->passwd ? ctrl->passwd : "<null>");
1.60 frystyk 400:
401: ptr = strchr(path, ';');
402: if (ptr) {
403: *ptr = '\0';
404: if (strncasecomp(ptr, ";type=", 6)) /* Look for type */
405: data->type = TOUPPER(*(ptr+6));
406: else if (*(ptr-1) == '/')
407: data->type = 'N';
408: } else if (*(path+strlen(path)-1) == '/') {
409: *(path+strlen(path)-1) = '\0';
410: data->type = 'N';
411: }
412: if (data->type && PROT_TRACE)
1.67 frystyk 413: TTYPrint(TDEST, "FTPParse.... Datatype %c\n", data->type);
1.60 frystyk 414: StrAllocCopy(data->file, path);
415: data->offset = data->file;
416: free(login);
417: free(path);
418: return YES;
1.22 frystyk 419: }
420:
1.60 frystyk 421: /* Use LIST or NLST
422: ** ----------------
423: ** This function sets the type field for what type of list we can use
424: ** Returns YES if OK, else NO
425: */
1.63 frystyk 426: PRIVATE BOOL FTPListType (ftp_data * data, FTPServerType type)
1.60 frystyk 427: {
428: if (!data) return NO;
429: switch (type) {
430: case FTP_GENERIC: data->type='N'; break;
431: case FTP_MACHTEN: data->type='L'; break;
432: case FTP_UNIX: data->type='L'; break;
433: case FTP_VMS: data->type='L'; break;
434: case FTP_CMS: data->type='N'; break;
435: case FTP_DCTS: data->type='N'; break;
436: case FTP_TCPC: data->type='N'; break;
437: case FTP_PETER_LEWIS: data->type='L'; break;
438: case FTP_NCSA: data->type='N'; break;
439: case FTP_WINNT: data->type='L'; break;
440: default: data->type='N'; break;
441: }
442: return YES;
443: }
444:
445: /* Open a Data socket for listening on
446: ** -----------------------------------
447: ** Set up a port to listen for data
448: ** Returns YES if OK, else NO
1.22 frystyk 449: */
1.60 frystyk 450: PRIVATE BOOL ListenSocket (HTNet *cnet, HTNet *dnet, ftp_data *data)
1.22 frystyk 451: {
1.60 frystyk 452: #ifdef POLL_PORTS
453: unsigned short old_DataPort = DataPort;
454: for (DataPort=old_DataPort+1;; DataPort++) {
455: if (DataPort > LAST_TCP_PORT)
456: DataPort = FIRST_TCP_PORT;
457: if (DataPort == old_DataPort) {
1.71 frystyk 458: if(PROT_TRACE) TTYPrint(TDEST,"FTP......... No data port found\n");
1.60 frystyk 459: return NO;
460: }
1.71 frystyk 461: if (HTDoListen(dnet, DataPort, 1) == HT_OK)
1.60 frystyk 462: break;
463: if (dnet->sockfd != INVSOC) {
464: NETCLOSE(dnet->sockfd);
465: dnet->sockfd = INVSOC:
466: }
1.22 frystyk 467: }
1.60 frystyk 468: #else
1.71 frystyk 469: if (HTDoListen(dnet, 0, cnet->sockfd, 1) != HT_OK) return NO;
1.60 frystyk 470: #endif /* POLL_PORTS */
1.22 frystyk 471:
1.60 frystyk 472: /* Now we must find out who we are to tell the other guy */
473: {
474: SockA local_addr;
475: int addr_size = sizeof(local_addr);
476: memset((void *) &local_addr, '\0', sizeof(local_addr));
477: if (getsockname(dnet->sockfd, (struct sockaddr *) &local_addr,
478: &addr_size) < 0) {
1.68 frystyk 479: HTRequest_addSystemError(dnet->request, ERR_FATAL, socerrno,
480: NO, "getsockname");
1.60 frystyk 481: return NO;
1.22 frystyk 482: }
1.67 frystyk 483: if (PROT_TRACE) TTYPrint(TDEST, "FTP......... This host is `%s\'\n",
1.60 frystyk 484: HTInetString(&local_addr));
485: {
486: u_long addr = local_addr.sin_addr.s_addr;
487: u_short port = local_addr.sin_port;
488: sprintf(data->host, "%d,%d,%d,%d,%d,%d",
489: (int)*((unsigned char *)(&addr)+0),
490: (int)*((unsigned char *)(&addr)+1),
491: (int)*((unsigned char *)(&addr)+2),
492: (int)*((unsigned char *)(&addr)+3),
493: (int)*((unsigned char *)(&port)+0),
494: (int)*((unsigned char *)(&port)+1));
1.22 frystyk 495: }
496: }
1.60 frystyk 497: return YES;
1.22 frystyk 498: }
499:
1.60 frystyk 500: /* HTFTPLogin
501: ** -----------
502: ** This function makes a login to a ftp-server. It takes the user name
503: ** and passwd specified in ctrl->user and if that fails or an additional
504: ** account is needed, the user is prompted.
505: ** Returns HT_OK, HT_ERROR, or HT_WOULD_BLOCK
1.22 frystyk 506: */
1.60 frystyk 507: PRIVATE int HTFTPLogin (HTRequest *request, HTNet *cnet, ftp_ctrl *ctrl)
1.22 frystyk 508: {
1.60 frystyk 509: int status;
510: typedef enum _state {
511: SUB_ERROR = -2,
512: SUB_SUCCESS = -1,
513: NEED_SELECT = 0,
514: NEED_GREETING,
515: NEED_REIN,
516: NEED_UID,
517: NEED_PASSWD,
518: NEED_ACCOUNT,
519: PROMPT_USER
520: } state;
521:
522: /* Jump into a second level state machine */
523: while (1) {
524: switch ((state) ctrl->substate) {
525: case NEED_SELECT:
526: ctrl->substate = ctrl->reset ? NEED_REIN : NEED_GREETING;
527: break;
528:
529: case NEED_GREETING:
530: status = HTSocketRead(request, cnet);
531: if (status == HT_WOULD_BLOCK)
532: return HT_WOULD_BLOCK;
533: else if (status == HT_LOADED) {
1.66 frystyk 534: if (ctrl->repcode/100 == 2) {
535: ctrl->substate = (ctrl->uid && *ctrl->uid) ?
536: NEED_UID : PROMPT_USER;
537: } else
1.60 frystyk 538: ctrl->substate = SUB_ERROR;
539: } else
540: ctrl->substate = SUB_ERROR;
541: break;
542:
543: case NEED_REIN:
544: if (!ctrl->sent) {
545: status = SendCommand(request, ctrl, "REIN", NULL);
546: if (status == HT_WOULD_BLOCK)
547: return HT_WOULD_BLOCK;
548: else if (status == HT_ERROR)
549: ctrl->substate = SUB_ERROR;
550: ctrl->sent = YES;
551: } else {
552: status = HTSocketRead(request, cnet);
553: if (status == HT_WOULD_BLOCK)
554: return HT_WOULD_BLOCK;
555: else if (status == HT_LOADED) {
1.66 frystyk 556: if (ctrl->repcode/100 == 2) {
557: ctrl->substate = (ctrl->uid && *ctrl->uid) ?
558: NEED_UID : PROMPT_USER;
559: } else
1.60 frystyk 560: ctrl->substate = SUB_SUCCESS; /* hope the best */
561: } else
562: ctrl->substate = SUB_ERROR;
563: ctrl->sent = NO;
1.22 frystyk 564: }
1.60 frystyk 565: break;
566:
567: case NEED_UID:
568: if (!ctrl->sent) {
569: status = SendCommand(request, ctrl, "USER", ctrl->uid);
570: if (status == HT_WOULD_BLOCK)
571: return HT_WOULD_BLOCK;
572: else if (status == HT_ERROR)
573: ctrl->substate = SUB_ERROR;
574: ctrl->sent = YES;
1.22 frystyk 575: } else {
1.60 frystyk 576: status = HTSocketRead(request, cnet);
577: if (status == HT_WOULD_BLOCK)
578: return HT_WOULD_BLOCK;
579: else if (status == HT_LOADED) {
580: int code = ctrl->repcode/100;
581: if (code == 2) /* Logged in w/o passwd! */
582: ctrl->substate = SUB_SUCCESS;
1.66 frystyk 583: else if (code == 3) { /* Password demanded */
584: ctrl->substate = (ctrl->passwd && *ctrl->passwd) ?
585: NEED_PASSWD : PROMPT_USER;
586: } else if (ctrl->repcode == 530)
1.60 frystyk 587: ctrl->substate = PROMPT_USER; /* User unknown */
588: else
589: ctrl->substate = SUB_ERROR;
590: } else
591: ctrl->substate = SUB_ERROR;
592: ctrl->sent = NO;
1.22 frystyk 593: }
1.60 frystyk 594: break;
1.1 timbl 595:
1.60 frystyk 596: case NEED_PASSWD:
597: if (!ctrl->sent) {
598: status = SendCommand(request, ctrl, "PASS", ctrl->passwd);
599: if (status == HT_WOULD_BLOCK)
600: return HT_WOULD_BLOCK;
601: else if (status == HT_ERROR)
602: ctrl->substate = SUB_ERROR;
603: ctrl->sent = YES;
604: } else {
605: status = HTSocketRead(request, cnet);
606: if (status == HT_WOULD_BLOCK)
607: return HT_WOULD_BLOCK;
608: else if (status == HT_LOADED) {
609: int code = ctrl->repcode/100;
610: if (code == 2) /* Logged in with passwd */
611: ctrl->substate = SUB_SUCCESS;
1.70 frystyk 612: else if (code == 3) { /* Account required */
613: HTAlertCallback *cbf = HTAlert_find(HT_A_PROMPT);
614: HTAlertPar * reply = HTAlert_newReply();
615: if (cbf && (*cbf)(request, HT_A_PROMPT,
616: HT_MSG_ACCOUNT, NULL, NULL, reply)) {
617: ctrl->account = HTAlert_replyMessage(reply);
1.60 frystyk 618: ctrl->substate = NEED_ACCOUNT;
1.70 frystyk 619: } else
1.60 frystyk 620: ctrl->substate = SUB_ERROR;
1.70 frystyk 621: HTAlert_deleteReply(reply);
1.60 frystyk 622: } else if (ctrl->repcode == 530)
623: ctrl->substate = PROMPT_USER;
624: else
625: ctrl->substate = SUB_ERROR;
626: } else
627: ctrl->substate = SUB_ERROR;
628: ctrl->sent = NO;
629: }
630: break;
1.1 timbl 631:
1.60 frystyk 632: case NEED_ACCOUNT:
633: if (!ctrl->sent) {
634: status = SendCommand(request, ctrl, "ACCT", ctrl->account);
635: if (status == HT_WOULD_BLOCK)
636: return HT_WOULD_BLOCK;
637: else if (status == HT_ERROR)
638: ctrl->substate = SUB_ERROR;
639: ctrl->sent = YES;
1.23 frystyk 640: } else {
1.60 frystyk 641: status = HTSocketRead(request, cnet);
642: if (status == HT_WOULD_BLOCK)
643: return HT_WOULD_BLOCK;
644: else if (status == HT_LOADED) {
645: int code = ctrl->repcode/100;
646: if (code == 2) /* Logged in with account */
647: ctrl->substate = SUB_SUCCESS;
648: else
649: ctrl->substate = SUB_ERROR; /* hopeless */
650: } else
651: ctrl->substate = SUB_ERROR;
652: ctrl->sent = NO;
1.1 timbl 653: }
1.60 frystyk 654: break;
1.1 timbl 655:
1.60 frystyk 656: case PROMPT_USER:
657: {
1.70 frystyk 658: HTAlertCallback *cbf = HTAlert_find(HT_A_USER_PW);
659: HTAlertPar * reply = HTAlert_newReply();
1.60 frystyk 660: FREE(ctrl->uid);
661: FREE(ctrl->passwd);
1.70 frystyk 662: if (cbf &&
663: (*cbf)(request, HT_A_USER_PW,HT_MSG_NULL,NULL,NULL,reply)){
664: ctrl->uid = HTAlert_replyMessage(reply);
665: ctrl->passwd = HTAlert_replySecret(reply);
666: }
667: HTAlert_deleteReply(reply);
1.66 frystyk 668: if (ctrl->uid && *ctrl->uid && ctrl->passwd && *ctrl->passwd)
1.60 frystyk 669: ctrl->substate = NEED_UID;
670: else
671: ctrl->substate = SUB_ERROR;
672: }
673: break;
1.1 timbl 674:
1.60 frystyk 675: case SUB_ERROR:
676: if (PROT_TRACE)
1.67 frystyk 677: TTYPrint(TDEST, "FTP......... Login failed\n");
1.60 frystyk 678: ctrl->substate = 0;
679: return HT_ERROR;
680: break;
1.23 frystyk 681:
1.60 frystyk 682: case SUB_SUCCESS:
1.43 frystyk 683: if (PROT_TRACE)
1.67 frystyk 684: TTYPrint(TDEST, "FTP......... Logged in as `%s\'\n", ctrl->uid);
1.60 frystyk 685: ctrl->substate = 0;
686: return HT_OK;
687: break;
1.23 frystyk 688: }
1.22 frystyk 689: }
690: }
691:
1.60 frystyk 692: /* HTFTPDataConnection
693: ** -------------------
694: ** Prepares a data connection to the server and initializes the
695: ** transfer mode.
696: ** Returns HT_OK, HT_ERROR, or HT_WOULD_BLOCK
1.1 timbl 697: */
1.60 frystyk 698: PRIVATE int HTFTPDataConnection (HTRequest * request, HTNet *cnet,
699: ftp_ctrl *ctrl, ftp_data *data)
1.1 timbl 700: {
1.60 frystyk 701: int status;
702: HTNet *dnet = ctrl->dnet;
703: typedef enum _state {
704: SUB_ERROR = -2,
705: SUB_SUCCESS = -1,
706: NEED_TYPE = 0,
707: NEED_SELECT,
708: NEED_PASV,
709: NEED_PORT
710: } state;
711:
712: /* Jump into a second level state machine */
713: while (1) {
714: switch ((state) ctrl->substate) {
715: case NEED_TYPE:
716: if(!data->type|| data->pasv || data->type=='N' || data->type=='L'){
717: ctrl->substate = NEED_SELECT;
718: break;
719: }
720: if (!ctrl->sent) {
721: char type[2];
722: *type = data->type;
723: *(type+1) = '\0';
724: status = SendCommand(request, ctrl, "TYPE", type);
725: if (status == HT_WOULD_BLOCK)
726: return HT_WOULD_BLOCK;
727: else if (status == HT_ERROR)
728: ctrl->substate = SUB_ERROR;
729: ctrl->sent = YES;
730: } else {
731: status = HTSocketRead(request, cnet);
732: if (status == HT_WOULD_BLOCK)
733: return HT_WOULD_BLOCK;
734: else if (status == HT_LOADED) {
735: if (ctrl->repcode/100 == 2)
736: ctrl->substate = NEED_SELECT;
737: else
738: ctrl->substate = SUB_ERROR;
739: } else
740: ctrl->substate = SUB_ERROR;
741: ctrl->sent = NO;
742: }
743: break;
744:
745: case NEED_SELECT:
746: if (FTPMode & FTP_DATA_PASV && !data->pasv)
747: ctrl->substate = NEED_PASV;
748: else if (ListenSocket(cnet, dnet, data))
749: ctrl->substate = NEED_PORT;
750: else
751: ctrl->substate = SUB_ERROR;
752: break;
753:
754: case NEED_PASV:
755: if (!ctrl->sent) {
756: status = SendCommand(request, ctrl, "PASV", NULL);
757: if (status == HT_WOULD_BLOCK)
758: return HT_WOULD_BLOCK;
759: else if (status == HT_ERROR)
760: ctrl->substate = SUB_ERROR;
761: ctrl->sent = YES;
762: } else {
763: status = HTSocketRead(request, cnet);
764: if (status == HT_WOULD_BLOCK)
765: return HT_WOULD_BLOCK;
766: else if (status == HT_LOADED) {
767: if (ctrl->repcode == 227) {
768: /*
769: ** If succes, we have to scan for the returned number.
770: ** As the format for the response isn't standard,
771: ** the best thing to do is to scan for the first digit
772: ** after the status code, see RFC1123
773: */
774: char *host = ctrl->reply;
775: int h0, h1, h2, h3, p0=0, p1=0;
776: while (*host && !isdigit(*host++));
777: if (!*host || sscanf(--host, "%d,%d,%d,%d,%d,%d",
778: &h0,&h1,&h2,&h3,&p0,&p1) < 6) {
779: if (PROT_TRACE)
1.67 frystyk 780: TTYPrint(TDEST, "FTP......... PASV No addr\n");
1.60 frystyk 781: ctrl->substate = SUB_ERROR;
782: break;
783: } else {
784: int port = (p0<<8)+p1;
785: sprintf(data->host, "ftp://%d.%d.%d.%d:%d/",
786: h0, h1, h2, h3, port);
787: data->pasv = YES;
788: ctrl->substate = SUB_SUCCESS;
789: }
790: } else {
791: ctrl->substate = ListenSocket(cnet, dnet, data) ?
792: NEED_PORT : SUB_ERROR;
793: }
794: } else
795: ctrl->substate = SUB_ERROR;
796: ctrl->sent = NO;
797: }
798: break;
1.22 frystyk 799:
1.60 frystyk 800: case NEED_PORT:
801: if (!ctrl->sent) {
802: status = SendCommand(request, ctrl, "PORT", data->host);
803: if (status == HT_WOULD_BLOCK)
804: return HT_WOULD_BLOCK;
805: else if (status == HT_ERROR)
806: ctrl->substate = SUB_ERROR;
807: ctrl->sent = YES;
808: } else {
809: status = HTSocketRead(request, cnet);
810: if (status == HT_WOULD_BLOCK)
811: return HT_WOULD_BLOCK;
812: else if (status == HT_LOADED) {
813: data->pasv = NO;
814: ctrl->substate = (ctrl->repcode/100 == 2) ?
815: SUB_SUCCESS : SUB_ERROR;
816: } else
817: ctrl->substate = SUB_ERROR;
818: ctrl->sent = NO;
819: }
820: break;
1.1 timbl 821:
1.60 frystyk 822: case SUB_ERROR:
823: if (PROT_TRACE)
1.67 frystyk 824: TTYPrint(TDEST, "FTP......... Can't setup data connection\n");
1.60 frystyk 825: ctrl->substate = 0;
826: return HT_ERROR;
827: break;
1.1 timbl 828:
1.60 frystyk 829: case SUB_SUCCESS:
830: if (PROT_TRACE)
1.67 frystyk 831: TTYPrint(TDEST, "FTP......... Data connection negotiated\n");
1.60 frystyk 832: ctrl->substate = 0;
833: return HT_OK;
834: break;
1.23 frystyk 835: }
1.58 frystyk 836: }
1.23 frystyk 837: }
1.1 timbl 838:
839:
1.60 frystyk 840: /* HTFTPServerInfo
841: ** ---------------
842: ** This function finds out what server we are talking to.
843: ** Maybe we can upgrade from NLST to LIST.
844: ** Returns HT_OK, HT_ERROR, or HT_WOULD_BLOCK
845: ** Thanks to James.W.Matthews@Dartmouth.EDU (James W. Matthews) for making
846: ** his code available.
1.1 timbl 847: */
1.60 frystyk 848: PRIVATE int HTFTPServerInfo (HTRequest *request, HTNet *cnet,
849: ftp_ctrl *ctrl, ftp_data *data)
1.23 frystyk 850: {
1.60 frystyk 851: int status;
852: typedef enum _state {
853: SUB_ERROR = -2,
854: SUB_SUCCESS = -1,
855: NEED_SYST = 0,
856: CHECK_SYST,
857: NEED_PWD,
858: CHECK_PWD
859: } state;
860:
861: /* Jump into a second level state machine */
862: while (1) {
863: switch ((state) ctrl->substate) {
864: case NEED_SYST:
865: if (!ctrl->sent) {
1.63 frystyk 866: if (ctrl->server != FTP_UNSURE) {
1.60 frystyk 867: FTPListType(data, ctrl->server);
868: return HT_OK;
869: }
870: status = SendCommand(request, ctrl, "SYST", NULL);
871: if (status == HT_WOULD_BLOCK)
872: return HT_WOULD_BLOCK;
873: else if (status == HT_ERROR)
874: ctrl->substate = SUB_ERROR;
875: ctrl->sent = YES;
876: } else {
877: status = HTSocketRead(request, cnet);
878: if (status == HT_WOULD_BLOCK)
879: return HT_WOULD_BLOCK;
880: else if (status == HT_LOADED) {
881: ctrl->substate=ctrl->repcode==215 ? CHECK_SYST : NEED_PWD;
882: } else
883: ctrl->substate = SUB_ERROR;
884: ctrl->sent = NO;
1.23 frystyk 885: }
886: break;
887:
1.60 frystyk 888: case CHECK_SYST:
1.23 frystyk 889: {
1.60 frystyk 890: char *reply = ctrl->reply;
891: if (!*reply) {
1.43 frystyk 892: if (PROT_TRACE)
1.67 frystyk 893: TTYPrint(TDEST, "FTP......... No server info?\n");
1.60 frystyk 894: ctrl->substate = NEED_PWD;
1.23 frystyk 895: break;
896: }
1.60 frystyk 897: if (strncmp(reply, "UNIX Type: L8MAC-OSMachTen", 28) == 0) {
898: ctrl->server = FTP_MACHTEN;
899: } else if (strstr(reply, "UNIX") != NULL) {
900: ctrl->server = FTP_UNIX;
901: } else if (strncmp(reply, "VMS", 3) == 0) {
902: ctrl->server = FTP_VMS;
903: } else if ((strncmp(reply, "VM/CMS", 6) == 0) ||
904: (strncmp(reply, "VM", 2) == 0)) {
905: ctrl->server = FTP_CMS;
906: } else if (strncmp(reply, "DCTS", 4) == 0) {
907: ctrl->server = FTP_DCTS;
908: } else if (strstr(reply, "MAC-OS TCP/ConnectII") != NULL) {
1.23 frystyk 909: /* Check old versions of TCP/C using / in pathnames */
1.63 frystyk 910: ctrl->server = FTP_TCPC + FTP_UNSURE;
1.60 frystyk 911: } else if (strncmp(reply, "MACOS Peter's Server", 20) == 0) {
912: ctrl->server = FTP_PETER_LEWIS;
913: } else if (strncmp(reply, "Windows_NT", 10) == 0) {
914: ctrl->server = FTP_WINNT;
1.23 frystyk 915: }
916:
917: /* If we are unsure, try PWD to get more information */
1.60 frystyk 918: if (ctrl->server & FTP_UNSURE)
919: ctrl->substate = NEED_PWD;
1.23 frystyk 920: else
1.60 frystyk 921: ctrl->substate = SUB_SUCCESS;
1.1 timbl 922: }
1.23 frystyk 923: break;
924:
925: case NEED_PWD:
1.60 frystyk 926: if (!ctrl->sent) {
927: status = SendCommand(request, ctrl, "PWD", NULL);
928: if (status == HT_WOULD_BLOCK)
929: return HT_WOULD_BLOCK;
930: else if (status == HT_ERROR)
931: ctrl->substate = SUB_ERROR;
932: ctrl->sent = YES;
1.23 frystyk 933: } else {
1.60 frystyk 934: status = HTSocketRead(request, cnet);
935: if (status == HT_WOULD_BLOCK)
936: return HT_WOULD_BLOCK;
937: else if (status == HT_LOADED) {
938: ctrl->substate = (ctrl->repcode/100 == 2) ?
939: CHECK_PWD : SUB_ERROR;
940: } else
941: ctrl->substate = SUB_ERROR;
942: ctrl->sent = NO;
1.23 frystyk 943: }
944: break;
945:
1.60 frystyk 946: case CHECK_PWD:
947: {
948: char *start = strchr(ctrl->reply, '"');
949: char *end;
950: if (!start || (end = strchr(++start, '"')) == NULL) {
1.43 frystyk 951: if (PROT_TRACE)
1.67 frystyk 952: TTYPrint(TDEST, "FTP......... No current directory?\n");
1.60 frystyk 953: ctrl->server = FTP_GENERIC;
1.23 frystyk 954: } else {
1.60 frystyk 955: *end = '\0';
1.63 frystyk 956: if (ctrl->server & FTP_TCPC) {
1.60 frystyk 957: ctrl->server = *start == '/' ? FTP_NCSA : FTP_TCPC;
958: } else if (*start == '/') {
959: /* path names starting with / imply Unix, right? */
960: ctrl->server = FTP_UNIX;
961: } else if (*(end-1) == ']') {
962: /* path names ending with ] imply VMS, right? */
963: ctrl->server = FTP_VMS;
964: } else
965: ctrl->server = FTP_GENERIC;
1.23 frystyk 966: }
1.60 frystyk 967: ctrl->substate = SUB_SUCCESS;
1.1 timbl 968: }
1.23 frystyk 969: break;
1.1 timbl 970:
1.60 frystyk 971: case SUB_ERROR:
972: if (PROT_TRACE)
1.67 frystyk 973: TTYPrint(TDEST, "FTP......... Can't get server information\n");
1.60 frystyk 974: ctrl->substate = 0;
1.63 frystyk 975: ctrl->server = FTP_GENERIC;
1.60 frystyk 976: return HT_ERROR;
1.23 frystyk 977: break;
1.22 frystyk 978:
1.60 frystyk 979: case SUB_SUCCESS:
1.63 frystyk 980: if (PROT_TRACE)
1.67 frystyk 981: TTYPrint(TDEST, "FTP Server.. Guessed type %d\n", ctrl->server);
1.60 frystyk 982: HTDNS_setServerVersion(cnet->dns, ctrl->server);
983: FTPListType(data, ctrl->server);
984: ctrl->substate = 0;
985: return HT_OK;
1.23 frystyk 986: break;
1.22 frystyk 987: }
1.23 frystyk 988: }
989: }
990:
1.60 frystyk 991: /* HTFTPGetData
992: ** ------------
993: ** This function asks for the file or a directory. First we try in one go,
1.23 frystyk 994: ** but if that doesn't work, then we use CWD for each segment and then
995: ** try to retrieve it. If that also fails, then we try if it is a
1.60 frystyk 996: ** directory.
997: ** Returns HT_OK, HT_LOADED, HT_ERROR, or HT_WOULD_BLOCK
1.23 frystyk 998: */
1.71 frystyk 999: PRIVATE int HTFTPGetData (HTRequest *request, HTNet *cnet, SOCKET sockfd,
1.60 frystyk 1000: ftp_ctrl *ctrl, ftp_data *data)
1.23 frystyk 1001: {
1002: int status;
1.60 frystyk 1003: char *segment = NULL;
1004: HTNet *dnet = ctrl->dnet;
1005: typedef enum _state {
1006: SUB_ERROR = -2,
1007: SUB_SUCCESS = -1,
1008: NEED_SELECT = 0,
1009: NEED_CONNECT,
1010: NEED_ACCEPT,
1011: NEED_ACTION,
1012: NEED_CWD,
1013: NEED_SEGMENT,
1014: NEED_STREAM,
1.63 frystyk 1015: NEED_BODY
1.60 frystyk 1016: } state;
1017:
1018: /* Jump into a second level state machine */
1019: while (1) {
1020: switch ((state) ctrl->substate) {
1021: case NEED_SELECT:
1022: ctrl->substate = data->pasv ? NEED_CONNECT : NEED_ACTION;
1023: break;
1024:
1025: case NEED_CONNECT:
1026: status = HTDoConnect(dnet, data->host, FTP_DATA);
1027: if (status == HT_WOULD_BLOCK)
1028: return HT_WOULD_BLOCK;
1029: else if (status == HT_OK) {
1030: if (PROT_TRACE)
1.67 frystyk 1031: TTYPrint(TDEST, "FTP Data.... Active data socket %d\n",
1.60 frystyk 1032: dnet->sockfd);
1033: ctrl->substate = NEED_ACTION;
1034: } else { /* Swap to PORT on the fly */
1035: NETCLOSE(dnet->sockfd);
1036: dnet->sockfd = INVSOC;
1037: if (PROT_TRACE)
1.67 frystyk 1038: TTYPrint(TDEST, "FTP......... Swap to PORT on the fly\n");
1.60 frystyk 1039: ctrl->substate = 0;
1040: FREE(segment);
1041: return HT_OK;
1042: }
1.23 frystyk 1043: break;
1044:
1.60 frystyk 1045: case NEED_ACCEPT:
1046: {
1.72 frystyk 1047: SOCKET oldsocket = dnet->sockfd;
1048: status = HTDoAccept(dnet);
1.60 frystyk 1049: if (status == HT_WOULD_BLOCK)
1050: return HT_WOULD_BLOCK;
1051: else if (status == HT_OK) {
1052: if (PROT_TRACE)
1.72 frystyk 1053: TTYPrint(TDEST,"FTP Data.... Passive data socket %d\n",
1054: dnet->sockfd);
1055: NETCLOSE(oldsocket); /* We only accept one socket */
1.43 frystyk 1056: if (PROT_TRACE)
1.67 frystyk 1057: TTYPrint(TDEST, "FTP Data.... New data socket %d\n",
1.60 frystyk 1058: dnet->sockfd);
1059: ctrl->substate = NEED_STREAM;
1060: } else
1061: ctrl->substate = SUB_ERROR;
1.23 frystyk 1062: }
1.60 frystyk 1063: break;
1.33 frystyk 1064:
1.60 frystyk 1065: case NEED_ACTION:
1066: if (!ctrl->sent) {
1067: char *cmd = (data->type=='L') ? "LIST" :
1068: (data->type=='N') ? "NLST" : "RETR";
1069: StrAllocCopy(segment, data->offset);
1070: HTUnEscape(segment);
1071: HTCleanTelnetString(segment);
1072: status = SendCommand(request, ctrl, cmd, segment);
1.63 frystyk 1073: FREE(segment);
1.60 frystyk 1074: if (status == HT_WOULD_BLOCK)
1075: return HT_WOULD_BLOCK;
1076: else if (status == HT_ERROR)
1077: ctrl->substate = SUB_ERROR;
1078: ctrl->sent = YES;
1079: } else {
1080: status = HTSocketRead(request, cnet);
1081: if (status == HT_WOULD_BLOCK)
1082: return HT_WOULD_BLOCK;
1083: else if (status == HT_LOADED) {
1084: int code = ctrl->repcode;
1085: if (code==125 || code==150 || code==225)
1086: ctrl->substate=data->pasv ? NEED_STREAM : NEED_ACCEPT;
1087: else if (code/100==5 && !ctrl->cwd)
1088: ctrl->substate = NEED_SEGMENT;
1089: else
1090: ctrl->substate = SUB_ERROR;
1091: } else
1092: ctrl->substate = SUB_ERROR;
1093: ctrl->sent = NO;
1.23 frystyk 1094: }
1095: break;
1.60 frystyk 1096:
1097: case NEED_SEGMENT:
1.23 frystyk 1098: {
1.60 frystyk 1099: char *ptr;
1100: if (data->offset == data->file) {
1.63 frystyk 1101: if (ctrl->server == FTP_VMS) { /* Change to root */
1102: segment = (char *) malloc(strlen(ctrl->uid)+3);
1103: sprintf(segment, "[%s]", ctrl->uid);
1104: } else
1105: StrAllocCopy(segment, "/");
1.60 frystyk 1106: data->offset++;
1107: ctrl->substate = NEED_CWD;
1108: } else {
1109: if ((ptr = strchr(data->offset, '/'))) {
1110: *ptr='\0';
1111: StrAllocCopy(segment, data->offset);
1112: *ptr='/';
1113: data->offset = ++ptr;
1114: HTUnEscape(segment);
1115: HTCleanTelnetString(segment);
1116: ctrl->substate = NEED_CWD;
1.33 frystyk 1117: } else
1.60 frystyk 1118: ctrl->substate = NEED_ACTION;
1.23 frystyk 1119: }
1120: }
1121: break;
1122:
1.60 frystyk 1123: case NEED_CWD:
1124: if (!ctrl->sent) {
1125: status = SendCommand(request, ctrl, "CWD", segment);
1.63 frystyk 1126: FREE(segment);
1.60 frystyk 1127: if (status == HT_WOULD_BLOCK)
1128: return HT_WOULD_BLOCK;
1129: else if (status == HT_ERROR)
1130: ctrl->substate = SUB_ERROR;
1131: ctrl->cwd = YES;
1132: ctrl->sent = YES;
1133: } else {
1134: status = HTSocketRead(request, cnet);
1135: if (status == HT_WOULD_BLOCK)
1136: return HT_WOULD_BLOCK;
1137: else if (status == HT_LOADED) {
1138: if (ctrl->repcode/100 == 2)
1139: ctrl->substate = NEED_SEGMENT;
1140: else
1141: ctrl->substate = SUB_ERROR;
1142: } else
1143: ctrl->substate = SUB_ERROR;
1144: ctrl->sent = NO;
1.33 frystyk 1145: }
1.60 frystyk 1146: break;
1.33 frystyk 1147:
1.60 frystyk 1148: case NEED_STREAM:
1149: {
1150: dnet->isoc = HTInputSocket_new(dnet->sockfd);
1.63 frystyk 1151: if (FTP_DIR(data)) {
1.69 frystyk 1152: dnet->target=HTFTPDir_new(request,ctrl->server,data->type);
1.63 frystyk 1153: } else {
1154: dnet->target =
1155: HTStreamStack(HTAnchor_format(request->anchor),
1156: request->output_format,
1157: request->output_stream,
1158: request,YES);
1159: }
1160: sockfd = dnet->sockfd; /* Ensure that we try data first */
1.60 frystyk 1161: ctrl->substate = NEED_BODY;
1162: }
1.23 frystyk 1163: break;
1164:
1.60 frystyk 1165: case NEED_BODY:
1.63 frystyk 1166: if (sockfd == dnet->sockfd) {
1167: status = HTSocketRead(request, dnet);
1168: if (status == HT_WOULD_BLOCK)
1169: return HT_WOULD_BLOCK;
1.75 ! frystyk 1170: else if (status == HT_LOADED || status == HT_CLOSED) {
1.63 frystyk 1171: if (data->ready)
1172: ctrl->substate = SUB_SUCCESS;
1173: else
1174: sockfd = cnet->sockfd;
1175: data->ready = YES;
1176: } else
1177: ctrl->substate = SUB_ERROR;
1178: } else {
1179: status = HTSocketRead(request, cnet);
1180: if (status == HT_WOULD_BLOCK)
1181: return HT_WOULD_BLOCK;
1182: else if (status == HT_LOADED) {
1183: if (ctrl->repcode/100 == 2) {
1184: if (data->ready)
1185: ctrl->substate = SUB_SUCCESS;
1186: else
1187: sockfd = dnet->sockfd;
1188: data->ready = YES;
1189: } else
1190: ctrl->substate = SUB_ERROR;
1191: } else
1.60 frystyk 1192: ctrl->substate = SUB_ERROR;
1.63 frystyk 1193: }
1.23 frystyk 1194: break;
1.22 frystyk 1195:
1.60 frystyk 1196: case SUB_ERROR:
1197: if (PROT_TRACE)
1.67 frystyk 1198: TTYPrint(TDEST, "FTP......... Can't retrieve object\n");
1.60 frystyk 1199: ctrl->substate = 0;
1200: FREE(segment);
1201: return HT_ERROR;
1.23 frystyk 1202: break;
1203:
1.60 frystyk 1204: case SUB_SUCCESS:
1205: if (PROT_TRACE)
1.67 frystyk 1206: TTYPrint(TDEST, "FTP......... Object is loaded\n");
1.60 frystyk 1207: ctrl->substate = 0;
1208: FREE(segment);
1209: return HT_LOADED;
1.23 frystyk 1210: break;
1.1 timbl 1211: }
1212: }
1.23 frystyk 1213: }
1.1 timbl 1214:
1.23 frystyk 1215: /* ------------------------------------------------------------------------- */
1216:
1217: /* Retrieve File from Server as an atomic action.
1218: ** -----------------------------------------------
1.58 frystyk 1219: ** Given a hypertext address, this routine loads a document.
1.23 frystyk 1220: **
1221: ** On entry,
1.58 frystyk 1222: ** request This is the request structure
1223: ** returns HT_ERROR Error has occured in call back
1224: ** HT_OK Call back was OK
1225: */
1.65 frystyk 1226: PUBLIC int HTLoadFTP (SOCKET soc, HTRequest * request, SockOps ops)
1.58 frystyk 1227: {
1228: int status = HT_ERROR;
1.60 frystyk 1229: HTNet *cnet = request->net;
1.58 frystyk 1230: ftp_ctrl *ctrl;
1.60 frystyk 1231: ftp_data *data;
1.58 frystyk 1232: char *url = HTAnchor_physical(request->anchor);
1.23 frystyk 1233:
1.58 frystyk 1234: /*
1.60 frystyk 1235: ** Initiate a new FTP ctrl and data structure and bind to request structure
1.58 frystyk 1236: ** This is actually state FTP_BEGIN, but it can't be in the state
1237: ** machine as we need the structure first.
1238: */
1239: if (ops == FD_NONE) {
1.67 frystyk 1240: if (PROT_TRACE) TTYPrint(TDEST, "FTP......... Looking for `%s\'\n",url);
1.60 frystyk 1241: if ((ctrl = (ftp_ctrl *) calloc(1, sizeof(ftp_ctrl))) == NULL ||
1242: (data = (ftp_data *) calloc(1, sizeof(ftp_data))) == NULL)
1.58 frystyk 1243: outofmem(__FILE__, "HTLoadFTP");
1.73 frystyk 1244: ctrl->cmd = HTChunk_new(128);
1.58 frystyk 1245: ctrl->state = FTP_BEGIN;
1.60 frystyk 1246: ctrl->server = FTP_UNSURE;
1.74 frystyk 1247: ctrl->dnet = HTNet_dup(cnet);
1.60 frystyk 1248: cnet->context = ctrl; /* Context for control connection */
1249: ctrl->dnet->context = data; /* Context for data connection */
1250: } else if (ops == FD_CLOSE) { /* Interrupted */
1251: if(HTRequest_isPostWeb(request)&&!HTRequest_isMainDestination(request))
1252: FTPCleanup(request, HT_IGNORE);
1253: else
1254: FTPCleanup(request, HT_INTERRUPTED);
1255: return HT_OK;
1256: } else {
1257: ctrl = (ftp_ctrl *) cnet->context; /* Get existing copy */
1258: data = (ftp_data *) ctrl->dnet->context;
1259: }
1.58 frystyk 1260:
1261: /* Now jump into the machine. We know the state from the previous run */
1262: while (1) {
1263: switch (ctrl->state) {
1.60 frystyk 1264: case FTP_BEGIN:
1265: HTFTPParseURL(url, ctrl, data);
1266: if (data->type != 'N') {
1267: HTBind_getBindings(request->anchor);
1268: if (HTAnchor_encoding(request->anchor) != HTAtom_for("7bit"))
1269: data->type = 'I';
1270: }
1271: ctrl->state = FTP_NEED_CCON;
1272: break;
1273:
1274: case FTP_NEED_CCON:
1275: status = HTDoConnect(cnet, url, FTP_PORT);
1276: if (status == HT_OK) {
1277: char *s_class = HTDNS_serverClass(cnet->dns);
1278: if (s_class && strcasecomp(s_class, "ftp")) {
1.68 frystyk 1279: HTRequest_addError(request, ERR_FATAL, NO, HTERR_CLASS,
1280: NULL, 0, "HTLoadFTP");
1.60 frystyk 1281: ctrl->state = FTP_ERROR;
1282: break;
1283: }
1284: HTDNS_setServerClass(cnet->dns, "ftp");
1.63 frystyk 1285: if (HTDNS_socket(cnet->dns) != INVSOC) {
1286: ctrl->server = HTDNS_serverVersion(cnet->dns);
1287: if (PROT_TRACE)
1.67 frystyk 1288: TTYPrint(TDEST, "FTP Server.. We know from cache that this is a type %d server\n",
1.63 frystyk 1289: ctrl->server);
1.60 frystyk 1290: ctrl->reset = 1;
1.63 frystyk 1291: } else
1.60 frystyk 1292: HTDNS_setSocket(cnet->dns, cnet->sockfd);
1293: if (PROT_TRACE)
1.67 frystyk 1294: TTYPrint(TDEST, "FTP Ctrl.... Connected, socket %d\n",
1.60 frystyk 1295: cnet->sockfd);
1.23 frystyk 1296:
1.60 frystyk 1297: /* Set up stream TO network */
1298: request->input_stream = HTWriter_new(cnet, YES);
1.23 frystyk 1299:
1.60 frystyk 1300: /*
1301: ** Set up concurrent read/write if this request isn't the
1302: ** source for a PUT or POST. As source we don't start reading
1303: ** before all destinations are ready. If destination then
1304: ** register the input stream and get ready for read
1305: */
1306: if (HTRequest_isPostWeb(request)) {
1307: HTEvent_Register(cnet->sockfd, request, (SockOps) FD_READ,
1308: HTLoadFTP, cnet->priority);
1309: HTRequest_linkDestination(request);
1310: }
1311:
1312: /* Set up stream FROM network and corresponding read buffer */
1313: cnet->isoc = HTInputSocket_new(cnet->sockfd);
1314: cnet->target = FTPStatus_new(request, ctrl);
1315: ctrl->state = FTP_NEED_LOGIN;
1316: } else if (status == HT_WOULD_BLOCK || status == HT_PERSISTENT)
1317: return HT_OK;
1318: else
1319: ctrl->state = FTP_ERROR; /* Error or interrupt */
1320: break;
1321:
1322: case FTP_NEED_LOGIN:
1323: status = HTFTPLogin(request, cnet, ctrl);
1324: if (status == HT_WOULD_BLOCK) return HT_OK;
1325: ctrl->state = (status == HT_OK) ? FTP_NEED_DCON : FTP_ERROR;
1326: break;
1327:
1328: case FTP_NEED_DCON:
1329: status = HTFTPDataConnection(request, cnet, ctrl, data);
1330: if (status == HT_WOULD_BLOCK) return HT_OK;
1331: if (status == HT_OK)
1332: ctrl->state = (data->type=='N') ?
1333: FTP_NEED_SERVER : FTP_NEED_DATA;
1334: else
1335: ctrl->state = FTP_ERROR;
1336: break;
1337:
1338: case FTP_NEED_DATA:
1.63 frystyk 1339: status = HTFTPGetData(request, cnet, soc, ctrl, data);
1.60 frystyk 1340: if (status == HT_WOULD_BLOCK) return HT_OK;
1341: if (status == HT_LOADED)
1342: ctrl->state = FTP_SUCCESS;
1343: else if (status == HT_OK)
1344: ctrl->state = FTP_NEED_DCON;
1345: else if (!FTP_DIR(data)) {
1346: FTPListType(data, ctrl->server);
1347: ctrl->state = FTP_NEED_SERVER; /* Try a dir instead? */
1348: } else
1349: ctrl->state = FTP_ERROR;
1350: break;
1.23 frystyk 1351:
1.60 frystyk 1352: case FTP_NEED_SERVER:
1353: status = HTFTPServerInfo(request, cnet, ctrl, data);
1354: if (status == HT_WOULD_BLOCK) return HT_OK;
1355: ctrl->state = FTP_NEED_DATA;
1356: break;
1357:
1358: case FTP_SUCCESS:
1359: if (HTRequest_isPostWeb(request)) {
1360: BOOL main = HTRequest_isMainDestination(request);
1361: if (HTRequest_isDestination(request)) {
1362: HTLink *link =
1363: HTAnchor_findLink((HTAnchor *) request->source->anchor,
1364: (HTAnchor *) request->anchor);
1.72 frystyk 1365: HTLink_setResult(link, HT_LINK_OK);
1.23 frystyk 1366: }
1.60 frystyk 1367: HTRequest_removeDestination(request);
1368: FTPCleanup(request, main ? HT_LOADED : HT_IGNORE);
1369: } else
1370: FTPCleanup(request, HT_LOADED);
1371: return HT_OK;
1372: break;
1373:
1374: case FTP_ERROR:
1375: /* Clean up the other connections or just this one */
1376: if (HTRequest_isPostWeb(request)) {
1377: BOOL main = HTRequest_isMainDestination(request);
1378: HTRequest_killPostWeb(request);
1379: if (HTRequest_isDestination(request)) {
1380: HTLink *link =
1381: HTAnchor_findLink((HTAnchor *) request->source->anchor,
1382: (HTAnchor *) request->anchor);
1.72 frystyk 1383: HTLink_setResult(link, HT_LINK_ERROR);
1.30 luotonen 1384: }
1.60 frystyk 1385: HTRequest_removeDestination(request);
1386: FTPCleanup(request, main ? HT_ERROR : HT_IGNORE);
1387: } else
1388: FTPCleanup(request, HT_ERROR);
1389: return HT_OK;
1390: break;
1.23 frystyk 1391: }
1.60 frystyk 1392: } /* End of while(1) */
1.23 frystyk 1393: }
1.22 frystyk 1394:
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