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