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