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