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