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