Initial revision

1 files changed, 1046 insertions, 0 deletions

diff --git a/lib/ftp.c b/lib/ftp.c
new file mode 100644
index 000000000..d62891298
--- /dev/null
+++ b/lib/ftp.c
@@ -0,0 +1,1046 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ *  The contents of this file are subject to the Mozilla Public License
+ *  Version 1.0 (the "License"); you may not use this file except in
+ *  compliance with the License. You may obtain a copy of the License at
+ *  http://www.mozilla.org/MPL/
+ *
+ *  Software distributed under the License is distributed on an "AS IS"
+ *  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing rights and limitations
+ *  under the License.
+ *
+ *  The Original Code is Curl.
+ *
+ *  The Initial Developer of the Original Code is Daniel Stenberg.
+ *
+ *  Portions created by the Initial Developer are Copyright (C) 1998.
+ *  All Rights Reserved.
+ *
+ * ------------------------------------------------------------
+ * Main author:
+ * - Daniel Stenberg <Daniel.Stenberg@haxx.nu>
+ *
+ * 	http://curl.haxx.nu
+ *
+ * $Source$
+ * $Revision$
+ * $Date$
+ * $Author$
+ * $State$
+ * $Locker$
+ *
+ * ------------------------------------------------------------
+ ****************************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "setup.h"
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+
+#if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__)
+#include <winsock.h>
+#else /* some kind of unix */
+#include <sys/socket.h>
+#include <netinet/in.h>
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#include <sys/utsname.h>
+#include <netdb.h>
+#endif
+
+#if defined(WIN32) && defined(__GNUC__) || defined(__MINGW32__)
+#include <errno.h>
+#endif
+
+
+#include <curl/curl.h>
+#include "urldata.h"
+#include "sendf.h"
+
+#include "if2ip.h"
+#include "hostip.h"
+#include "progress.h"
+#include "upload.h"
+#include "download.h"
+
+
+/* returns last node in linked list */
+static struct curl_slist *slist_get_last(struct curl_slist *list)
+{
+	struct curl_slist	*item;
+
+	/* if caller passed us a NULL, return now */
+	if (!list)
+		return NULL;
+
+	/* loop through to find the last item */
+	item = list;
+	while (item->next) {
+		item = item->next;
+	}
+	return item;
+}
+
+/* append a struct to the linked list. It always retunrs the address of the
+ * first record, so that you can sure this function as an initialization
+ * function as well as an append function. If you find this bothersome,
+ * then simply create a separate _init function and call it appropriately from
+ * within the proram. */
+struct curl_slist *curl_slist_append(struct curl_slist *list, char *data)
+{
+	struct curl_slist	*last;
+	struct curl_slist	*new_item;
+
+	new_item = (struct curl_slist *) malloc(sizeof(struct curl_slist));
+	if (new_item) {
+		new_item->next = NULL;
+		new_item->data = strdup(data);
+	}
+	else {
+		fprintf(stderr, "Cannot allocate memory for QUOTE list.\n");
+		exit(-1);
+	}
+
+	if (list) {
+		last = slist_get_last(list);
+		last->next = new_item;
+		return list;
+	}
+
+	/* if this is the first item, then new_item *is* the list */
+	return new_item;
+}
+
+/* be nice and clean up resources */
+void curl_slist_free_all(struct curl_slist *list)
+{
+	struct curl_slist	*next;
+	struct curl_slist	*item;
+
+	if (!list)
+		return;
+
+	item = list;
+	do {
+		next = item->next;
+		
+		if (item->data) {
+			free(item->data);
+		}
+		free(item);
+		item = next;
+	} while (next);
+}
+
+
+static UrgError AllowServerConnect(struct UrlData *data,
+                                   int sock)
+{
+  fd_set rdset;
+  struct timeval dt;
+  
+  FD_ZERO(&rdset);
+
+  FD_SET(sock, &rdset);
+
+  /* we give the server 10 seconds to connect to us */
+  dt.tv_sec = 10;
+  dt.tv_usec = 0;
+
+  switch ( select(sock+1, &rdset, NULL, NULL, &dt)) {
+  case -1: /* error */
+    /* let's die here */
+    failf(data, "Error while waiting for server connect");
+    return URG_FTP_PORT_FAILED;
+  case 0:  /* timeout */
+    /* let's die here */
+    failf(data, "Timeout while waiting for server connect");
+    return URG_FTP_PORT_FAILED;
+  default:
+    /* we have received data here */
+    {
+      int s;
+      size_t size = sizeof(struct sockaddr_in);
+      struct sockaddr_in add;
+
+      getsockname(sock, (struct sockaddr *) &add, (int *)&size);
+      s=accept(sock, (struct sockaddr *) &add, (int *)&size);
+
+      if( -1 == s) {
+	/* DIE! */
+	failf(data, "Error accept()ing server connect");
+	return URG_FTP_PORT_FAILED;
+      }
+      infof(data, "Connection accepted from server\n");
+
+      data->secondarysocket = s;
+    }
+    break;
+  }
+  return URG_OK;
+}
+
+
+/* --- parse FTP server responses --- */
+
+#define lastline(line) (isdigit((int)line[0]) && isdigit((int)line[1]) && \
+			isdigit((int)line[2]) && (' ' == line[3]))
+
+static int GetLastResponse(int sockfd, char *buf,
+			   struct UrlData *data)
+{
+  int nread;
+  int read_rc=1;
+  char *ptr;
+  do {
+    ptr=buf;
+
+    /* get us a full line, terminated with a newline */
+    for(nread=0;
+        (nread<BUFSIZE) && read_rc;
+        nread++, ptr++) {
+#ifdef USE_SSLEAY
+      if (data->use_ssl) {
+        read_rc = SSL_read(data->ssl, ptr, 1);
+      }
+      else {
+#endif
+        read_rc = sread(sockfd, ptr, 1);
+#ifdef USE_SSLEAY
+      }
+#endif /* USE_SSLEAY */
+      if (*ptr == '\n')
+        break;
+    }
+    *ptr=0; /* zero terminate */
+
+    if(data->conf & CONF_VERBOSE) {
+      fputs("< ", data->err);
+      fwrite(buf, 1, nread, data->err);
+      fputs("\n", data->err);
+    }
+  } while(read_rc &&
+	  (nread<4 || !lastline(buf)) );
+  return nread;
+}
+
+/* -- who are we? -- */
+char *getmyhost(void)
+{
+  static char myhost[256];
+#if !defined(WIN32) && !defined(HAVE_UNAME) && !defined(HAVE_GETHOSTNAME)
+  /* We have no means of finding the local host name! */
+  strcpy(myhost, "localhost");
+#endif
+#if defined(WIN32) || !defined(HAVE_UNAME)
+  gethostname(myhost, 256);
+#else
+  struct utsname ugnm;
+
+  if (uname(&ugnm) < 0)
+    return "localhost";
+
+  (void) strncpy(myhost, ugnm.nodename, 255);
+  myhost[255] = '\0';
+#endif
+  return myhost;
+}
+
+#if 0
+/*
+ * URLfix()
+ *
+ * This function returns a string converted FROM the input URL format to a
+ * format that is more likely usable for the remote server. That is, all
+ * special characters (found as %XX-codes) will be eascaped with \<letter>.
+ */
+
+static char *URLfix(char *string)
+{
+  /* The length of the new string can't be longer than twice the original
+     string, if all letters are '+'... */
+  int alloc = strlen(string)*2;
+  char *ns = malloc(alloc);
+  unsigned char in;
+  int index=0;
+  int hex;
+   
+  while(*string) {
+    in = *string;
+    switch(in) {
+    case '+':
+      ns[index++] = '\\';
+      ns[index++] = ' ';
+      string++;
+      continue;
+
+    case '%':
+      /* encoded part */
+      if(sscanf(string+1, "%02X", &hex)) {
+        ns[index++] = '\\';
+        ns[index++] = hex;
+        string+=3;
+        continue;
+      }
+      /* FALLTHROUGH */
+    default:
+      ns[index++] = in;
+      string++;
+    }
+  }
+  ns[index]=0; /* terminate it */
+  return ns;
+}
+#endif
+
+static
+UrgError _ftp(struct UrlData *data,
+              long *bytecountp,
+              char *ftpuser,
+              char *ftppasswd,
+              char *ppath)
+{
+  /* this is FTP and no proxy */
+  size_t nread;
+  UrgError result;
+  char *buf = data->buffer; /* this is our buffer */
+  /* for the ftp PORT mode */
+  int portsock=-1;
+  struct sockaddr_in serv_addr;
+
+  struct curl_slist *qitem; /* QUOTE item */
+
+  /* The first thing we do is wait for the "220*" line: */
+  nread = GetLastResponse(data->firstsocket, buf, data);
+  if(strncmp(buf, "220", 3)) {
+    failf(data, "This doesn't seem like a nice ftp-server response");
+    return URG_FTP_WEIRD_SERVER_REPLY;
+  }
+
+  /* send USER */
+  sendf(data->firstsocket, data, "USER %s\r\n", ftpuser);
+
+  /* wait for feedback */
+  nread = GetLastResponse(data->firstsocket, buf, data);
+
+  if(!strncmp(buf, "530", 3)) {
+    /* 530 User ... access denied
+       (the server denies to log the specified user) */
+    failf(data, "Access denied: %s", &buf[4]);
+    return URG_FTP_ACCESS_DENIED;
+  }
+  else if(!strncmp(buf, "331", 3)) {
+    /* 331 Password required for ...
+       (the server requires to send the user's password too) */
+    sendf(data->firstsocket, data, "PASS %s\r\n", ftppasswd);
+    nread = GetLastResponse(data->firstsocket, buf, data);
+
+    if(!strncmp(buf, "530", 3)) {
+      /* 530 Login incorrect.
+         (the username and/or the password are incorrect) */
+      failf(data, "the username and/or the password are incorrect");
+      return URG_FTP_USER_PASSWORD_INCORRECT;
+    }
+    else if(!strncmp(buf, "230", 3)) {
+      /* 230 User ... logged in.
+         (user successfully logged in) */
+        
+      infof(data, "We have successfully logged in\n");
+    }
+    else {
+      failf(data, "Odd return code after PASS");
+      return URG_FTP_WEIRD_PASS_REPLY;
+    }
+  }
+  else if(! strncmp(buf, "230", 3)) {
+    /* 230 User ... logged in.
+       (the user logged in without password) */
+    infof(data, "We have successfully logged in\n");
+  }
+  else {
+    failf(data, "Odd return code after USER");
+    return URG_FTP_WEIRD_USER_REPLY;
+  }
+
+  /* Send any QUOTE strings? */
+  if(data->quote) {
+    qitem = data->quote;
+    /* Send all QUOTE strings in same order as on command-line */
+    while (qitem) {
+      /* Send string */
+      if (qitem->data) {
+        sendf(data->firstsocket, data, "%s\r\n", qitem->data);
+
+        nread = GetLastResponse(data->firstsocket, buf, data);
+
+        if (buf[0] != '2') {
+          failf(data, "QUOT string not accepted: %s",
+                qitem->data);
+          return URG_FTP_QUOTE_ERROR;
+        }
+      }
+      qitem = qitem->next;
+    }
+  }
+
+  /* If we have selected NOBODY, it means that we only want file information.
+     Which in FTP can't be much more than the file size! */
+  if(data->conf & CONF_NOBODY) {
+    /* The SIZE command is _not_ RFC 959 specified, and therefor many servers
+       may not support it! It is however the only way we have to get a file's
+       size! */
+    int filesize;
+    sendf(data->firstsocket, data, "SIZE %s\r\n", ppath);
+
+    nread = GetLastResponse(data->firstsocket, buf, data);
+
+    if(strncmp(buf, "213", 3)) {
+      failf(data, "Couldn't get file size: %s", buf+4);
+      return URG_FTP_COULDNT_GET_SIZE;
+    }
+    /* get the size from the ascii string: */
+    filesize = atoi(buf+4);
+
+    sprintf(buf, "Content-Length: %d\n", filesize);
+
+    if(strlen(buf) != data->fwrite(buf, 1, strlen(buf), data->out)) {
+      failf (data, "Failed writing output");
+      return URG_WRITE_ERROR;
+    }
+    if(data->writeheader) {
+      /* the header is requested to be written to this file */
+      if(strlen(buf) != fwrite (buf, 1, strlen(buf), data->writeheader)) {
+        failf (data, "Failed writing output");
+        return URG_WRITE_ERROR;
+      }
+    }
+    return URG_OK;
+  }
+
+  /* We have chosen to use the PORT command */
+  if(data->conf & CONF_FTPPORT) {
+    struct sockaddr_in sa;
+    struct hostent *h=NULL;
+    size_t size;
+    unsigned short porttouse;
+
+    char *myhost=NULL;
+      
+    if(data->ftpport) {
+      myhost = if2ip(data->ftpport);
+      if(myhost) {
+        h = GetHost(data, myhost);
+      }
+      else {
+        if(strlen(data->ftpport)>1)
+          h = GetHost(data, data->ftpport);
+        if(h)
+          myhost=data->ftpport;
+      }
+    }
+    if(!myhost) {
+      myhost = getmyhost();
+      h=GetHost(data, myhost);
+    }
+    infof(data, "We connect from %s\n", myhost);
+
+    if ( h ) {
+      if( (portsock = socket(AF_INET, SOCK_STREAM, 0)) >= 0 ) {
+        memset((char *)&sa, 0, sizeof(sa));
+        memcpy((char *)&sa.sin_addr,
+               h->h_addr,
+               h->h_length);
+        sa.sin_family = AF_INET;
+        sa.sin_addr.s_addr = INADDR_ANY;
+        sa.sin_port = 0;
+        size = sizeof(sa);
+
+        if(bind(portsock, (struct sockaddr *)&sa, size) >= 0) {
+          /* we succeeded to bind */
+          struct sockaddr_in add;
+          size = sizeof(add);
+
+          if(getsockname(portsock, (struct sockaddr *) &add,
+                         (int *)&size)<0) {
+            failf(data, "getsockname() failed");
+            return URG_FTP_PORT_FAILED;
+          }
+          porttouse = ntohs(add.sin_port);
+
+          if ( listen(portsock, 1) < 0 ) {
+            failf(data, "listen(2) failed on socket");
+            return URG_FTP_PORT_FAILED;
+          }
+        }
+        else {
+          failf(data, "bind(2) failed on socket");
+          return URG_FTP_PORT_FAILED;
+        }
+      }
+      else {
+        failf(data, "socket(2) failed (%s)");
+        return URG_FTP_PORT_FAILED;
+      }
+    }
+    else {
+      failf(data, "could't find my own IP address (%s)", myhost);
+      return URG_FTP_PORT_FAILED;
+    }
+    {
+      struct in_addr in;
+      unsigned short ip[5];
+      (void) memcpy(&in.s_addr, *h->h_addr_list, sizeof (in.s_addr));
+      sscanf( inet_ntoa(in), "%hu.%hu.%hu.%hu",
+              &ip[0], &ip[1], &ip[2], &ip[3]);
+      sendf(data->firstsocket, data, "PORT %d,%d,%d,%d,%d,%d\n",
+            ip[0], ip[1], ip[2], ip[3],
+            porttouse >> 8,
+            porttouse & 255);
+    }
+
+    nread = GetLastResponse(data->firstsocket, buf, data);
+
+    if(strncmp(buf, "200", 3)) {
+      failf(data, "Server does not grok PORT, try without it!");
+      return URG_FTP_PORT_FAILED;
+    }     
+  }
+  else { /* we use the PASV command */
+
+    sendf(data->firstsocket, data, "PASV\r\n");
+
+    nread = GetLastResponse(data->firstsocket, buf, data);
+
+    if(strncmp(buf, "227", 3)) {
+      failf(data, "Odd return code after PASV");
+      return URG_FTP_WEIRD_PASV_REPLY;
+    }
+    else {
+      int ip[4];
+      int port[2];
+      unsigned short newport;
+      char newhost[32];
+      struct hostent *he;
+      char *str=buf;
+
+      /*
+       * New 227-parser June 3rd 1999.
+       * It now scans for a sequence of six comma-separated numbers and
+       * will take them as IP+port indicators.
+       *
+       * Found reply-strings include:
+       * "227 Entering Passive Mode (127,0,0,1,4,51)"
+       * "227 Data transfer will passively listen to 127,0,0,1,4,51"
+       * "227 Entering passive mode. 127,0,0,1,4,51"
+       */
+      
+      while(*str) {
+	 if (6 == sscanf(str, "%d,%d,%d,%d,%d,%d",
+			 &ip[0], &ip[1], &ip[2], &ip[3],
+			 &port[0], &port[1]))
+	    break;
+	 str++;
+      }
+      if(!*str) {
+	 failf(data, "Couldn't interpret this 227-reply: %s", buf);
+	 return URG_FTP_WEIRD_227_FORMAT;
+      }
+      sprintf(newhost, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
+      he = GetHost(data, newhost);
+      if(!he) {
+        failf(data, "Can't resolve new host %s", newhost);
+        return URG_FTP_CANT_GET_HOST;
+      }
+
+	
+      newport = (port[0]<<8) + port[1];
+      data->secondarysocket = socket(AF_INET, SOCK_STREAM, 0);
+
+      memset((char *) &serv_addr, '\0', sizeof(serv_addr));
+      memcpy((char *)&(serv_addr.sin_addr), he->h_addr, he->h_length);
+      serv_addr.sin_family = he->h_addrtype;
+      serv_addr.sin_port = htons(newport);
+
+      if(data->conf & CONF_VERBOSE) {
+        struct in_addr in;
+#if 1
+        struct hostent * answer;
+
+        unsigned long address;
+#if defined(HAVE_INET_ADDR) || defined(WIN32)
+        address = inet_addr(newhost);
+        answer = gethostbyaddr((char *) &address, sizeof(address), 
+                               AF_INET);
+#else
+        answer = NULL;
+#endif
+        (void) memcpy(&in.s_addr, *he->h_addr_list, sizeof (in.s_addr));
+        infof(data, "Connecting to %s (%s) port %u\n",
+              answer?answer->h_name:newhost, inet_ntoa(in), newport);
+#else
+        (void) memcpy(&in.s_addr, *he->h_addr_list, sizeof (in.s_addr));
+        infof(data, "Connecting to %s (%s) port %u\n",
+              he->h_name, inet_ntoa(in), newport);
+#endif
+      }
+	
+      if (connect(data->secondarysocket, (struct sockaddr *) &serv_addr,
+                  sizeof(serv_addr)) < 0) {
+        switch(errno) {
+#ifdef ECONNREFUSED
+          /* this should be made nicer */
+        case ECONNREFUSED:
+          failf(data, "Connection refused by ftp server");
+          break;
+#endif
+#ifdef EINTR
+        case EINTR:
+          failf(data, "Connection timeouted to ftp server");
+          break;
+#endif
+        default:
+          failf(data, "Can't connect to ftp server");
+          break;
+        }
+        return URG_FTP_CANT_RECONNECT;
+      }
+    }
+
+  }
+  /* we have the (new) data connection ready */
+
+  if(data->conf & CONF_UPLOAD) {
+
+    /* Set type to binary (unless specified ASCII) */
+    sendf(data->firstsocket, data, "TYPE %s\r\n",
+          (data->conf&CONF_FTPASCII)?"A":"I");
+
+    nread = GetLastResponse(data->firstsocket, buf, data);
+
+    if(strncmp(buf, "200", 3)) {
+      failf(data, "Couldn't set %s mode",
+            (data->conf&CONF_FTPASCII)?"ASCII":"binary");
+      return (data->conf&CONF_FTPASCII)? URG_FTP_COULDNT_SET_ASCII:
+        URG_FTP_COULDNT_SET_BINARY;
+    }
+
+    if(data->resume_from) {
+      /* we're about to continue the uploading of a file */
+      /* 1. get already existing file's size. We use the SIZE
+         command for this which may not exist in the server!
+         The SIZE command is not in RFC959. */
+
+      /* 2. This used to set REST. But since we can do append, we
+         don't another ftp command. We just skip the source file
+         offset and then we APPEND the rest on the file instead */
+
+      /* 3. pass file-size number of bytes in the source file */
+      /* 4. lower the infilesize counter */
+      /* => transfer as usual */
+
+      if(data->resume_from < 0 ) {
+        /* we could've got a specified offset from the command line,
+           but now we know we didn't */
+
+        sendf(data->firstsocket, data, "SIZE %s\r\n", ppath);
+
+        nread = GetLastResponse(data->firstsocket, buf, data);
+
+        if(strncmp(buf, "213", 3)) {
+          failf(data, "Couldn't get file size: %s", buf+4);
+          return URG_FTP_COULDNT_GET_SIZE;
+        }
+
+        /* get the size from the ascii string: */
+        data->resume_from = atoi(buf+4);
+      }
+
+      if(data->resume_from) {
+        /* do we still game? */
+        int passed=0;
+#if 0
+        /* Set resume file transfer offset */
+        infof(data, "Instructs server to resume from offset %d\n",
+              data->resume_from);
+
+        sendf(data->firstsocket, data, "REST %d\r\n", data->resume_from);
+
+        nread = GetLastResponse(data->firstsocket, buf, data);
+
+        if(strncmp(buf, "350", 3)) {
+          failf(data, "Couldn't use REST: %s", buf+4);
+          return URG_FTP_COULDNT_USE_REST;
+        }
+#else
+        /* enable append instead */
+        data->conf |= CONF_FTPAPPEND;
+#endif
+        /* Now, let's read off the proper amount of bytes from the
+           input. If we knew it was a proper file we could've just
+           fseek()ed but we only have a stream here */
+        do {
+          int readthisamountnow = (data->resume_from - passed);
+          int actuallyread;
+
+          if(readthisamountnow > BUFSIZE)
+            readthisamountnow = BUFSIZE;
+
+          actuallyread =
+            data->fread(data->buffer, 1, readthisamountnow, data->in);
+
+          passed += actuallyread;
+          if(actuallyread != readthisamountnow) {
+            failf(data, "Could only read %d bytes from the input\n",
+                  passed);
+            return URG_FTP_COULDNT_USE_REST;
+          }
+        }
+        while(passed != data->resume_from);
+
+        /* now, decrease the size of the read */
+        if(data->infilesize>0) {
+          data->infilesize -= data->resume_from;
+
+          if(data->infilesize <= 0) {
+            infof(data, "File already completely uploaded\n");
+            return URG_OK;
+          }
+        }
+        /* we've passed, proceed as normal */
+      }
+    }
+
+    /* Send everything on data->in to the socket */
+    if(data->conf & CONF_FTPAPPEND)
+      /* we append onto the file instead of rewriting it */
+      sendf(data->firstsocket, data, "APPE %s\r\n", ppath);
+    else
+      sendf(data->firstsocket, data, "STOR %s\r\n", ppath);
+
+    nread = GetLastResponse(data->firstsocket, buf, data);
+
+    if(atoi(buf)>=400) {
+      failf(data, "Failed FTP upload:%s", buf+3);
+      /* oops, we never close the sockets! */
+      return URG_FTP_COULDNT_STOR_FILE;
+    }
+
+    if(data->conf & CONF_FTPPORT) {
+      result = AllowServerConnect(data, portsock);
+      if( result )
+        return result;
+    }
+
+    *bytecountp=0;
+
+    /* When we know we're uploading a specified file, we can get the file
+       size prior to the actual upload. */
+
+    ProgressInit(data, data->infilesize);
+    result = Upload(data, data->secondarysocket, bytecountp);
+    if(result)
+      return result;
+      
+    if((-1 != data->infilesize) && (data->infilesize != *bytecountp)) {
+      failf(data, "Wrote only partial file (%d out of %d bytes)",
+            *bytecountp, data->infilesize);
+      return URG_PARTIAL_FILE;
+    }
+  }
+  else {
+    /* Retrieve file or directory */
+    bool dirlist=FALSE;
+    long downloadsize=-1;
+
+    if(data->conf&CONF_RANGE && data->range) {
+      int from, to;
+      int totalsize=-1;
+      char *ptr;
+      char *ptr2;
+
+      from=strtol(data->range, &ptr, 0);
+      while(ptr && *ptr && (isspace((int)*ptr) || (*ptr=='-')))
+        ptr++;
+      to=strtol(ptr, &ptr2, 0);
+      if(ptr == ptr2) {
+        /* we didn't get any digit */
+        to=-1;
+      }
+      if(-1 == to) {
+        /* X - */
+        data->resume_from = from;
+      }
+      else if(from < 0) {
+        /* -Y */
+        from = 0;
+        to = -from;
+        totalsize = to-from;
+        data->maxdownload = totalsize;
+      }
+      else {
+        /* X- */
+        totalsize = to-from;
+        data->maxdownload = totalsize;
+      }
+      infof(data, "range-download from %d to %d, totally %d bytes\n",
+            from, to, totalsize);
+    }
+
+    if(!ppath[0])
+      /* make sure this becomes a valid name */
+      ppath="./";
+
+    if((data->conf & CONF_FTPLISTONLY) ||
+       ('/' == ppath[strlen(ppath)-1] )) {
+      /* The specified path ends with a slash, and therefore we think this
+         is a directory that is requested, use LIST. But before that we
+         need to set ASCII transfer mode. */
+      dirlist = TRUE;
+
+      /* Set type to ASCII */
+      sendf(data->firstsocket, data, "TYPE A\r\n");
+	
+      nread = GetLastResponse(data->firstsocket, buf, data);
+	
+      if(strncmp(buf, "200", 3)) {
+        failf(data, "Couldn't set ascii mode");
+        return URG_FTP_COULDNT_SET_ASCII;
+      }
+
+      /* if this output is to be machine-parsed, the NLST command will be
+         better used since the LIST command output is not specified or
+         standard in any way */
+
+      sendf(data->firstsocket, data, "%s %s\r\n",
+            data->customrequest?data->customrequest:
+            (data->conf&CONF_FTPLISTONLY?"NLST":"LIST"),
+            ppath);
+    }
+    else {
+      /* Set type to binary (unless specified ASCII) */
+      sendf(data->firstsocket, data, "TYPE %s\r\n",
+            (data->conf&CONF_FTPASCII)?"A":"I");
+
+      nread = GetLastResponse(data->firstsocket, buf, data);
+
+      if(strncmp(buf, "200", 3)) {
+        failf(data, "Couldn't set %s mode",
+              (data->conf&CONF_FTPASCII)?"ASCII":"binary");
+        return (data->conf&CONF_FTPASCII)? URG_FTP_COULDNT_SET_ASCII:
+          URG_FTP_COULDNT_SET_BINARY;
+      }
+
+      if(data->resume_from) {
+
+        /* Daniel: (August 4, 1999)
+         *
+         * We start with trying to use the SIZE command to figure out the size
+         * of the file we're gonna get. If we can get the size, this is by far
+         * the best way to know if we're trying to resume beyond the EOF.  */
+
+        sendf(data->firstsocket, data, "SIZE %s\r\n", ppath);
+
+        nread = GetLastResponse(data->firstsocket, buf, data);
+
+        if(strncmp(buf, "213", 3)) {
+          infof(data, "server doesn't support SIZE: %s", buf+4);
+          /* We couldn't get the size and therefore we can't know if there
+             really is a part of the file left to get, although the server
+             will just close the connection when we start the connection so it
+             won't cause us any harm, just not make us exit as nicely. */
+        }
+        else {
+          int foundsize=atoi(buf+4);
+          /* We got a file size report, so we check that there actually is a
+             part of the file left to get, or else we go home.  */
+          if(foundsize <= data->resume_from) {
+            failf(data, "Offset (%d) was beyond file size (%d)",
+                  data->resume_from, foundsize);
+            return URG_FTP_BAD_DOWNLOAD_RESUME;
+          }
+          /* Now store the number of bytes we are expected to download */
+          downloadsize = foundsize-data->resume_from;
+        }
+
+        /* Set resume file transfer offset */
+        infof(data, "Instructs server to resume from offset %d\n",
+              data->resume_from);
+
+        sendf(data->firstsocket, data, "REST %d\r\n", data->resume_from);
+
+        nread = GetLastResponse(data->firstsocket, buf, data);
+
+        if(strncmp(buf, "350", 3)) {
+          failf(data, "Couldn't use REST: %s", buf+4);
+          return URG_FTP_COULDNT_USE_REST;
+        }
+      }
+
+      sendf(data->firstsocket, data, "RETR %s\r\n", ppath);
+    }
+
+    nread = GetLastResponse(data->firstsocket, buf, data);
+
+    if(!strncmp(buf, "150", 3) || !strncmp(buf, "125", 3)) {
+
+      /*
+        A;
+        150 Opening BINARY mode data connection for /etc/passwd (2241
+        bytes).  (ok, the file is being transfered)
+	
+        B:
+        150 Opening ASCII mode data connection for /bin/ls 
+
+        C:
+        150 ASCII data connection for /bin/ls (137.167.104.91,37445) (0 bytes).
+
+        D:
+        150 Opening ASCII mode data connection for /linux/fisk/kpanelrc (0.0.0.0,0) (545 bytes).
+          
+        E:
+        125 Data connection already open; Transfer starting. */
+
+      int size=-1; /* default unknown size */
+
+      if(!dirlist && (-1 == downloadsize)) {
+        /*
+         * It seems directory listings either don't show the size or very
+         * often uses size 0 anyway.
+         * Example D above makes this parsing a little tricky
+         */
+        char *bytes;
+        bytes=strstr(buf, " bytes");
+        if(bytes--) {
+          int index=bytes-buf;
+          /* this is a hint there is size information in there! ;-) */
+          while(--index) {
+            /* scan for the parenthesis and break there */
+            if('(' == *bytes)
+              break;
+            /* if only skip digits, or else we're in deep trouble */
+            if(!isdigit((int)*bytes)) {
+              bytes=NULL;
+              break;
+            }
+            /* one more estep backwards */
+            bytes--;
+          }
+          /* only if we have nothing but digits: */
+          if(bytes++) {
+            /* get the number! */
+            size = atoi(bytes);
+          }
+            
+        }
+#if 0
+        if(2 != sscanf(buf, "%*[^(](%d bytes%c", &size, &paren))
+          size=-1;
+#endif
+      }
+      else if(downloadsize > -1)
+        size = downloadsize;
+
+#if 0
+      if((size > -1) && (data->resume_from>0)) {
+        size -= data->resume_from;
+        if(size <= 0) {
+          failf(data, "Offset (%d) was beyond file size (%d)",
+                data->resume_from, data->resume_from+size);
+          return URG_PARTIAL_FILE;
+        }
+      }
+#endif
+
+      if(data->conf & CONF_FTPPORT) {
+        result = AllowServerConnect(data, portsock);
+        if( result )
+          return result;
+      }
+
+      infof(data, "Getting file with size: %d\n", size);
+
+      /* FTP download: */
+      result=Download(data, data->secondarysocket, size, FALSE,
+                      bytecountp);
+      if(result)
+        return result;
+
+      if((-1 != size) && (size != *bytecountp)) {
+        failf(data, "Received only partial file");
+        return URG_PARTIAL_FILE;
+      }
+      else if(0 == *bytecountp) {
+        failf(data, "No data was received!");
+        return URG_FTP_COULDNT_RETR_FILE;
+      }
+    }
+    else {
+      failf(data, "%s", buf+4);
+      return URG_FTP_COULDNT_RETR_FILE;
+    }
+	
+  }
+  /* end of transfer */
+  ProgressEnd(data);
+
+  /* shut down the socket to inform the server we're done */
+  sclose(data->secondarysocket);
+  data->secondarysocket = -1;
+    
+  /* now let's see what the server says about the transfer we
+     just performed: */
+  nread = GetLastResponse(data->firstsocket, buf, data);
+
+  /* 226 Transfer complete */
+  if(strncmp(buf, "226", 3)) {
+    failf(data, "%s", buf+4);
+    return URG_FTP_WRITE_ERROR;
+  }
+
+  return URG_OK;
+}
+
+/* -- deal with the ftp server!  -- */
+
+UrgError ftp(struct UrlData *data,
+             long *bytecountp,
+             char *ftpuser,
+             char *ftppasswd,
+             char *urlpath)
+{
+  char *realpath;
+  UrgError retcode;
+
+#if 0
+  realpath = URLfix(urlpath);
+#else
+  realpath = curl_unescape(urlpath);
+#endif
+  if(realpath) {
+    retcode = _ftp(data, bytecountp, ftpuser, ftppasswd, realpath);
+    free(realpath);
+  }
+  else
+    /* then we try the original path */
+    retcode = _ftp(data, bytecountp, ftpuser, ftppasswd, urlpath);
+
+  return retcode;
+}
+