7 files changed, 620 insertions, 61 deletions

diff --git a/loader/Makefile b/loader/Makefile
index bf44d4a89..e932aef57 100644
--- a/loader/Makefile
+++ b/loader/Makefile
@@ -6,12 +6,12 @@ ARCH := $(patsubst i%86,i386,$(shell uname -m))
 ARCH := $(patsubst sparc%,sparc,$(ARCH))
 
 OBJS = log.o windows.o modules.o devices.o cdrom.o urls.o kickstart.o lang.o \
-       misc.o
+       misc.o ftp.o
 LOADEROBJS = loader.o loader-pcmcia.o popen.o
 SOURCES = $(subst .o,.c,$(OBJS) $(LOADEROBJS))
 BINS = init
 DIRS = 
-NETOBJS = net.o
+NETOBJS = net.o 
 ifeq (i386, $(ARCH))
 KON = 0
 endif
@@ -117,7 +117,7 @@ loader-local: loader-local.o $(OBJS)
         ../isys/modutils/insmod/libmodutils.a    \
         ../isys/modutils/util/libutil.a          \
         ../isys/modutils/obj/libobj.a            \
-        -L../pump -lpump -lrpm -lbz2 -lz -lresolv -lnewt -lslang -lpci
+        -L ../stubs -L../pump -lpump -lz -lresolv -lnewt -lslang -lpci
 
 loader-network: loader-net.o $(OBJS) $(NETOBJS)
 	$(CC) -g $(STATIC) -o $@ $^ -lpopt     \
diff --git a/loader/ftp.c b/loader/ftp.c
new file mode 100644
index 000000000..2c53631f3
--- /dev/null
+++ b/loader/ftp.c
@@ -0,0 +1,516 @@
+#define HAVE_ALLOCA_H 1
+#define HAVE_NETINET_IN_SYSTM_H 1
+#define HAVE_SYS_SOCKET_H 1
+#define USE_ALT_DNS 1
+
+#if HAVE_ALLOCA_H
+# include <alloca.h>
+#endif
+
+#if HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif
+
+#if HAVE_NETINET_IN_SYSTM_H
+# include <sys/types.h>
+# include <netinet/in_systm.h>
+#endif
+
+#if ! HAVE_HERRNO
+extern int h_errno;
+#endif
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <pwd.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <arpa/inet.h>
+
+#define TIMEOUT_SECS 60
+#define BUFFER_SIZE 4096
+
+#ifndef IPPORT_FTP
+# define IPPORT_FTP 21
+#endif
+
+#if defined(USE_ALT_DNS) && USE_ALT_DNS 
+#include "isys/dns.h"
+#endif
+
+#include "ftp.h"
+
+static int ftpCheckResponse(int sock, char ** str);
+static int ftpCommand(int sock, char * command, ...);
+static int getHostAddress(const char * host, struct in_addr * address);
+
+static int ftpCheckResponse(int sock, char ** str) {
+    static char buf[BUFFER_SIZE + 1];
+    int bufLength = 0; 
+    fd_set emptySet, readSet;
+    char * chptr, * start;
+    struct timeval timeout;
+    int bytesRead, rc = 0;
+    int doesContinue = 1;
+    char errorCode[4];
+ 
+    errorCode[0] = '\0';
+    
+    do {
+	FD_ZERO(&emptySet);
+	FD_ZERO(&readSet);
+	FD_SET(sock, &readSet);
+
+	timeout.tv_sec = TIMEOUT_SECS;
+	timeout.tv_usec = 0;
+    
+	rc = select(sock + 1, &readSet, &emptySet, &emptySet, &timeout);
+	if (rc < 1) {
+	    if (rc==0) 
+		return FTPERR_BAD_SERVER_RESPONSE;
+	    else
+		rc = FTPERR_UNKNOWN;
+	} else
+	    rc = 0;
+
+	bytesRead = read(sock, buf + bufLength, sizeof(buf) - bufLength - 1);
+
+	bufLength += bytesRead;
+
+	buf[bufLength] = '\0';
+
+	/* divide the response into lines, checking each one to see if 
+	   we are finished or need to continue */
+
+	start = chptr = buf;
+
+	do {
+	    while (*chptr != '\n' && *chptr) chptr++;
+
+	    if (*chptr == '\n') {
+		*chptr = '\0';
+		if (*(chptr - 1) == '\r') *(chptr - 1) = '\0';
+		if (str) *str = start;
+
+		if (errorCode[0]) {
+		    if (!strncmp(start, errorCode, 3) && start[3] == ' ')
+			doesContinue = 0;
+		} else {
+		    strncpy(errorCode, start, 3);
+		    errorCode[3] = '\0';
+		    if (start[3] != '-') {
+			doesContinue = 0;
+		    } 
+		}
+
+		start = chptr + 1;
+		chptr++;
+	    } else {
+		chptr++;
+	    }
+	} while (*chptr);
+
+	if (doesContinue && chptr > start) {
+	    memcpy(buf, start, chptr - start - 1);
+	    bufLength = chptr - start - 1;
+	} else {
+	    bufLength = 0;
+	}
+    } while (doesContinue && !rc);
+
+    if (*errorCode == '4' || *errorCode == '5') {
+	if (!strncmp(errorCode, "550", 3)) {
+	    return FTPERR_FILE_NOT_FOUND;
+	}
+
+	return FTPERR_BAD_SERVER_RESPONSE;
+    }
+
+    if (rc) return rc;
+
+    return 0;
+}
+
+int ftpCommand(int sock, char * command, ...) {
+    va_list ap;
+    int len;
+    char * s;
+    char * buf;
+    int rc;
+
+    va_start(ap, command);
+    len = strlen(command) + 2;
+    s = va_arg(ap, char *);
+    while (s) {
+	len += strlen(s) + 1;
+	s = va_arg(ap, char *);
+    }
+    va_end(ap);
+
+    buf = alloca(len + 1);
+
+    va_start(ap, command);
+    strcpy(buf, command);
+    strcat(buf, " ");
+    s = va_arg(ap, char *);
+    while (s) {
+	strcat(buf, s);
+	strcat(buf, " ");
+	s = va_arg(ap, char *);
+    }
+    va_end(ap);
+
+    buf[len - 2] = '\r';
+    buf[len - 1] = '\n';
+    buf[len] = '\0';
+     
+    if (write(sock, buf, len) != len) {
+        return FTPERR_SERVER_IO_ERROR;
+    }
+
+    if ((rc = ftpCheckResponse(sock, NULL)))
+	return rc;
+
+    return 0;
+}
+
+#if !defined(USE_ALT_DNS) || !USE_ALT_DNS 
+static int mygethostbyname(const char * host, struct in_addr * address) {
+    struct hostent * hostinfo;
+
+    hostinfo = gethostbyname(host);
+    if (!hostinfo) return 1;
+
+    memcpy(address, hostinfo->h_addr_list[0], hostinfo->h_length);
+    return 0;
+}
+#endif
+
+static int getHostAddress(const char * host, struct in_addr * address) {
+    if (isdigit(host[0])) {
+      if (!inet_aton(host, address)) {
+	  return FTPERR_BAD_HOST_ADDR;
+      }
+    } else {
+      if (mygethostbyname((char *) host, address)) {
+	  errno = h_errno;
+	  return FTPERR_BAD_HOSTNAME;
+      }
+    }
+    
+    return 0;
+}
+
+int ftpOpen(char * host, char * name, char * password, char * proxy,
+	    int port) {
+    static int sock;
+    /*static char * lastHost = NULL;*/
+    struct in_addr serverAddress;
+    struct sockaddr_in destPort;
+    struct passwd * pw;
+    char * buf;
+    int rc;
+
+    if (port < 0) port = IPPORT_FTP;
+
+    if (!name)
+	name = "anonymous";
+
+    if (!password) {
+	if (getuid()) {
+	    pw = getpwuid(getuid());
+	    password = alloca(strlen(pw->pw_name) + 2);
+	    strcpy(password, pw->pw_name);
+	    strcat(password, "@");
+	} else {
+	    password = "root@";
+	}
+    }
+
+    if (proxy) {
+	buf = alloca(strlen(name) + strlen(host) + 5);
+	sprintf(buf, "%s@%s", name, host);
+	name = buf;
+	host = proxy;
+    }
+
+    if ((rc = getHostAddress(host, &serverAddress))) return rc;
+
+    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
+    if (sock < 0) {
+        return FTPERR_FAILED_CONNECT;
+    }
+
+    destPort.sin_family = AF_INET;
+    destPort.sin_port = htons(port);
+    destPort.sin_addr = serverAddress;
+
+    if (connect(sock, (struct sockaddr *) &destPort, sizeof(destPort))) {
+	close(sock);
+        return FTPERR_FAILED_CONNECT;
+    }
+
+    /* ftpCheckResponse() assumes the socket is nonblocking */
+    if (fcntl(sock, F_SETFL, O_NONBLOCK)) {
+	close(sock);
+        return FTPERR_FAILED_CONNECT;
+    }
+
+    if ((rc = ftpCheckResponse(sock, NULL))) {
+        return rc;     
+    }
+
+    if ((rc = ftpCommand(sock, "USER", name, NULL))) {
+	close(sock);
+	return rc;
+    }
+
+    if ((rc = ftpCommand(sock, "PASS", password, NULL))) {
+	close(sock);
+	return rc;
+    }
+
+    if ((rc = ftpCommand(sock, "TYPE", "I", NULL))) {
+	close(sock);
+	return rc;
+    }
+
+    return sock;
+}
+
+int ftpGetFileDesc(int sock, char * remotename) {
+    int dataSocket;
+    struct sockaddr_in dataAddress;
+    int i, j;
+    char * passReply;
+    char * chptr;
+    char * retrCommand;
+    int rc;
+
+    if (write(sock, "PASV\r\n", 6) != 6) {
+        return FTPERR_SERVER_IO_ERROR;
+    }
+    if ((rc = ftpCheckResponse(sock, &passReply)))
+	return FTPERR_PASSIVE_ERROR;
+
+    chptr = passReply;
+    while (*chptr && *chptr != '(') chptr++;
+    if (*chptr != '(') return FTPERR_PASSIVE_ERROR; 
+    chptr++;
+    passReply = chptr;
+    while (*chptr && *chptr != ')') chptr++;
+    if (*chptr != ')') return FTPERR_PASSIVE_ERROR;
+    *chptr-- = '\0';
+
+    while (*chptr && *chptr != ',') chptr--;
+    if (*chptr != ',') return FTPERR_PASSIVE_ERROR;
+    chptr--;
+    while (*chptr && *chptr != ',') chptr--;
+    if (*chptr != ',') return FTPERR_PASSIVE_ERROR;
+    *chptr++ = '\0';
+    
+    /* now passReply points to the IP portion, and chptr points to the
+       port number portion */
+
+    dataAddress.sin_family = AF_INET;
+    if (sscanf(chptr, "%d,%d", &i, &j) != 2) {
+	return FTPERR_PASSIVE_ERROR;
+    }
+    dataAddress.sin_port = htons((i << 8) + j);
+
+    chptr = passReply;
+    while (*chptr++) {
+	if (*chptr == ',') *chptr = '.';
+    }
+
+    if (!inet_aton(passReply, &dataAddress.sin_addr)) 
+	return FTPERR_PASSIVE_ERROR;
+
+    dataSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
+    if (dataSocket < 0) {
+        return FTPERR_FAILED_CONNECT;
+    }
+
+    retrCommand = alloca(strlen(remotename) + 20);
+    sprintf(retrCommand, "RETR %s\r\n", remotename);
+    i = strlen(retrCommand);
+   
+    if (write(sock, retrCommand, i) != i) {
+        return FTPERR_SERVER_IO_ERROR;
+    }
+
+    if (connect(dataSocket, (struct sockaddr *) &dataAddress, 
+	        sizeof(dataAddress))) {
+	close(dataSocket);
+        return FTPERR_FAILED_DATA_CONNECT;
+    }
+
+    if ((rc = ftpCheckResponse(sock, NULL))) {
+	close(dataSocket);
+	return rc;
+    }
+
+    return dataSocket;
+}
+
+int ftpGetFileDone(int sock) {
+    if (ftpCheckResponse(sock, NULL)) {
+	return FTPERR_BAD_SERVER_RESPONSE;
+    }
+
+    return 0;
+}
+
+const char *ftpStrerror(int errorNumber) {
+  switch (errorNumber) {
+    case FTPERR_BAD_SERVER_RESPONSE:
+      return ("Bad FTP server response");
+
+    case FTPERR_SERVER_IO_ERROR:
+      return("FTP IO error");
+
+    case FTPERR_SERVER_TIMEOUT:
+      return("FTP server timeout");
+
+    case FTPERR_BAD_HOST_ADDR:
+      return("Unable to lookup FTP server host address");
+
+    case FTPERR_BAD_HOSTNAME:
+      return("Unable to lookup FTP server host name");
+
+    case FTPERR_FAILED_CONNECT:
+      return("Failed to connect to FTP server");
+
+    case FTPERR_FAILED_DATA_CONNECT:
+      return("Failed to establish data connection to FTP server");
+
+    case FTPERR_FILE_IO_ERROR:
+      return("IO error to local file");
+
+    case FTPERR_PASSIVE_ERROR:
+      return("Error setting remote server to passive mode");
+
+    case FTPERR_FILE_NOT_FOUND:
+      return("File not found on server");
+
+    case FTPERR_UNKNOWN:
+    default:
+      return("FTP Unknown or unexpected error");
+  }
+}
+  
+int httpGetFileDesc(char * hostname, int port, char * remotename) {
+    char * buf;
+    struct timeval timeout;
+    char headers[4096];
+    char * nextChar = headers;
+    int checkedCode;
+    struct in_addr serverAddress;
+    int sock;
+    int rc;
+    struct sockaddr_in destPort;
+    fd_set readSet;
+
+    if (port < 0) port = 80;
+
+    if ((rc = getHostAddress(hostname, &serverAddress))) return rc;
+
+    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
+    if (sock < 0) {
+        return FTPERR_FAILED_CONNECT;
+    }
+
+    destPort.sin_family = AF_INET;
+    destPort.sin_port = htons(port);
+    destPort.sin_addr = serverAddress;
+
+    if (connect(sock, (struct sockaddr *) &destPort, sizeof(destPort))) {
+	close(sock);
+        return FTPERR_FAILED_CONNECT;
+    }
+
+    buf = alloca(strlen(remotename) + 20);
+    sprintf(buf, "GET %s HTTP/0.9\r\n\r\n", remotename);
+    write(sock, buf, strlen(buf));
+
+    /* This is fun; read the response a character at a time until we:
+
+	1) Get our first \r\n; which lets us check the return code
+	2) Get a \r\n\r\n, which means we're done */
+
+    *nextChar = '\0';
+    checkedCode = 0;
+    while (!strstr(headers, "\r\n\r\n")) {
+	FD_ZERO(&readSet);
+	FD_SET(sock, &readSet);
+
+	timeout.tv_sec = TIMEOUT_SECS;
+	timeout.tv_usec = 0;
+    
+	rc = select(sock + 1, &readSet, NULL, NULL, &timeout);
+	if (rc == 0) {
+	    close(sock);
+	    return FTPERR_SERVER_TIMEOUT;
+	} else if (rc < 0) {
+	    close(sock);
+	    return FTPERR_SERVER_IO_ERROR;
+	}
+
+	if (read(sock, nextChar, 1) != 1) {
+	    close(sock);
+	    return FTPERR_SERVER_IO_ERROR;
+	}
+
+	nextChar++;
+	*nextChar = '\0';
+
+	if (nextChar - headers == sizeof(headers)) {
+	    close(sock);
+	    return FTPERR_SERVER_IO_ERROR;
+	}
+
+	if (!checkedCode && strstr(headers, "\r\n")) {
+	    char * start, * end;
+
+	    checkedCode = 1;
+	    start = headers;
+	    while (!isspace(*start) && *start) start++;
+	    if (!*start) {
+		close(sock);
+		return FTPERR_SERVER_IO_ERROR;
+	    }
+	    start++;
+
+	    end = start;
+	    while (!isspace(*end) && *end) end++;
+	    if (!*end) {
+		close(sock);
+		return FTPERR_SERVER_IO_ERROR;
+	    }
+
+	    *end = '\0';
+	    if (!strcmp(start, "404")) {
+		close(sock);
+		return FTPERR_FILE_NOT_FOUND;
+	    } else if (strcmp(start, "200")) {
+		close(sock);
+		return FTPERR_BAD_SERVER_RESPONSE;
+	    }
+
+	    *end = ' ';
+	}
+    }
+    
+    return sock;
+}
diff --git a/loader/ftp.h b/loader/ftp.h
new file mode 100644
index 000000000..2c7052312
--- /dev/null
+++ b/loader/ftp.h
@@ -0,0 +1,25 @@
+#ifndef H_FTP
+#define H_FTP
+
+const char * ftpStrerror(int ftpErrno);
+
+#define FTPERR_BAD_SERVER_RESPONSE   -1
+#define FTPERR_SERVER_IO_ERROR       -2
+#define FTPERR_SERVER_TIMEOUT        -3
+#define FTPERR_BAD_HOST_ADDR         -4
+#define FTPERR_BAD_HOSTNAME          -5
+#define FTPERR_FAILED_CONNECT        -6
+#define FTPERR_FILE_IO_ERROR         -7
+#define FTPERR_PASSIVE_ERROR         -8
+#define FTPERR_FAILED_DATA_CONNECT   -9
+#define FTPERR_FILE_NOT_FOUND        -10
+#define FTPERR_UNKNOWN               -100
+
+int ftpOpen(char * host, char * name, char * password, char * proxy, int port);
+int ftpGetFile(int sock, char * remotename, int dest);
+int ftpGetFileDesc(int sock, char * remotename);
+int ftpGetFileDone(int sock);
+
+int httpGetFileDesc(char * hostname, int port, char * remotename);
+
+#endif
diff --git a/loader/lang.c b/loader/lang.c
index d9484a3bc..46050d8bd 100644
--- a/loader/lang.c
+++ b/loader/lang.c
@@ -14,7 +14,6 @@
 #include <glob.h>   /* XXX rpmlib.h */
 #include <dirent.h> /* XXX rpmlib.h */
 
-#include <rpm/rpmio.h>
 #include <linux/keyboard.h>
 #include <linux/kd.h>
 
@@ -105,7 +104,7 @@ const int numLanguages = sizeof(languages) / sizeof(struct langInfo);
 
 void loadLanguage (char * file, int flags) {
     char filename[200];
-    FD_t stream;
+    gzFile stream;
     int fd, hash, rc;
     char * key = getenv("LANG");
 
@@ -125,18 +124,18 @@ void loadLanguage (char * file, int flags) {
 	    sprintf(filename, "/etc/loader.tr");
     }
 
-    stream = Fopen (file, "r.fdio");
+    stream = gzopen(file, "r");
 
-    if (!stream || Ferror (stream)) {
+    if (!stream) {
 	newtWinMessage("Error", "OK", "Cannot open %s: %s. Installation will "
-			"proceed in English.", file, Fstrerror(stream));
+			"proceed in English.", file, strerror(errno));
 	return ;
     }
     
     sprintf(filename, "%s.tr", key);
 
     rc = installCpioFile(stream, filename, "/tmp/translation", 1);
-    Fclose(stream);
+    gzclose(stream);
 
     if (rc || access("/tmp/translation", R_OK)) {
 	newtWinMessage("Error", "OK", "Cannot get translation file %s.\n", 
@@ -179,21 +178,21 @@ static int loadFont(char * fontFile, int flags) {
     struct unimapinit u;
     struct unipair desc[2048];
     int fd;
-    FD_t stream;
+    gzFile stream;
     int rc;
 
 #if 0
     if (!FL_TESTING(flags)) {
 #endif
-	stream = Fopen("/etc/fonts.cgz", "r.fdio");
-	if (!stream || Ferror (stream)) {
+	stream = gzopen("/etc/fonts.cgz", "r");
+	if (!stream) {
 	    newtWinMessage("Error", "OK", 
-			"Cannot open fonts: %s", Fstrerror(stream));
+			"Cannot open fonts: %s", strerror(errno));
 	    return LOADER_ERROR;
 	}
 
 	rc = installCpioFile(stream, fontFile, "/tmp/font", 1);
-        Fclose(stream);
+        gzclose(stream);
 	if (rc || access("/tmp/font", R_OK)) {
 	    return LOADER_ERROR;
 	}
diff --git a/loader/loader.c b/loader/loader.c
index 7219ac755..ff59d9d03 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -29,10 +29,6 @@
 #include <newt.h>
 #include <popt.h>
 
-#include <glob.h>   /* XXX rpmlib.h */
-#include <dirent.h> /* XXX rpmlib.h */
-
-#include <rpmio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ioctl.h>
@@ -918,7 +914,7 @@ static char * mountUrlImage(struct installMethod * method,
     struct iurlinfo ui;
     char needsSecondary = ' ';
     static struct networkDeviceConfig netDev;
-    FD_t fd;
+    int fd;
     char * url;
     char buf[1024];
     enum urlprotocol_t proto = 
@@ -951,10 +947,12 @@ static char * mountUrlImage(struct installMethod * method,
 			URL_STAGE_SECOND : URL_STAGE_FETCH;
 	    break;
 
+#if 0	    /* we don't support proxies, etc right now */
 	  case URL_STAGE_SECOND:
 	    rc = urlSecondarySetupPanel(&ui, proto);
 	    stage = rc ? URL_STAGE_MAIN : URL_STAGE_FETCH;
 	    break;
+#endif
 
 	  case URL_STAGE_FETCH:
 	    if (FL_TESTING(flags)) {
@@ -964,19 +962,16 @@ static char * mountUrlImage(struct installMethod * method,
 
 	    fd = urlinstStartTransfer(&ui, "base/stage2.img");
 	    
-	    if (fd == NULL || Ferror(fd)) {
+	    if (fd < 0) {
 		newtPopWindow();
-		snprintf(buf, sizeof(buf), "%s/RedHat/base/stage2.img",
-			 ui.urlprefix);
 		newtWinMessage(_("FTP"), _("OK"), 
 		       _("Unable to retrieve the second stage ramdisk"));
-		/*XXX ufdClose(fd);*/
 		stage = URL_STAGE_MAIN;
 		break;
 	    }
 	    
-	    rc = loadStage2Ramdisk(Fileno(fd), 0, flags);
-	    urlinstFinishTransfer(fd);
+	    rc = loadStage2Ramdisk(fd, 0, flags);
+	    urlinstFinishTransfer(&ui, fd);
 	    if (!rc)
 		stage = URL_STAGE_DONE;
 
@@ -984,8 +979,10 @@ static char * mountUrlImage(struct installMethod * method,
         }
     }
 
-    url = malloc(strlen(ui.urlprefix) + 2);
-    strcpy(url, ui.urlprefix);
+    url = malloc(strlen(ui.prefix) + 25 + strlen(ui.address));
+    sprintf(url, "%s//%s/%s", 
+	    ui.protocol == URL_METHOD_FTP ? "ftp" : "http",
+	    ui.address, ui.prefix);
 
     writeNetInfo("/tmp/netinfo", &netDev);
 
diff --git a/loader/urls.c b/loader/urls.c
index d8908970e..9aaf2fcf7 100644
--- a/loader/urls.c
+++ b/loader/urls.c
@@ -3,25 +3,21 @@
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <newt.h>
-
-#include <glob.h>   /* XXX rpmlib.h */
-#include <dirent.h> /* XXX rpmlib.h */
-
-#include <rpmio.h>
-#include <rpmlib.h>
-#include <rpmurl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 #include "isys/dns.h"
 
+#include "ftp.h"
 #include "lang.h"
 #include "loader.h"
 #include "urls.h"
 #include "log.h"
-#include "rpmmacro.h"
+#include "windows.h"
 
+#if 0
 static const char * urlfilter(const char * u)
 {
     int i = 0;
@@ -54,34 +50,55 @@ static const char * urlfilter(const char * u)
     }
     return buf;
 }
+#endif
 
-FD_t urlinstStartTransfer(struct iurlinfo * ui, char * filename) {
+int urlinstStartTransfer(struct iurlinfo * ui, char * filename) {
     char * buf;
-    newtComponent form;
-    FD_t fd;
-    
-    logMessage("transferring %s/RedHat/%s to a fd", urlfilter(ui->urlprefix),
-	       filename);
+    int fd;
     
-    newtCenteredWindow(70, 3, _("Retrieving"));
-
-    buf = alloca(strlen(ui->urlprefix) + strlen(filename) + 30);
-    sprintf(buf, "%s %s...", _("Retrieving"), filename);
-    form = newtForm(NULL, NULL, 0);
-    newtFormAddComponent(form, newtLabel(1, 1, buf));
+    logMessage("transferring %s://%s/%s/RedHat/%s to a fd",
+	       ui->protocol == URL_METHOD_FTP ? "ftp" : "http",
+	       ui->address, ui->prefix, filename);
+
+    buf = alloca(strlen(ui->prefix) + strlen(filename) + 20);
+    sprintf(buf, "%s/RedHat/%s", ui->prefix, filename);
+
+    if (ui->protocol == URL_METHOD_FTP) {
+	ui->ftpPort = ftpOpen(ui->address, "anonymous", "rhinstall@", NULL,
+			      -1);
+	if (ui->ftpPort < 0) {
+	    newtWinMessage(_("Error"), _("Ok"), 
+		_("Failed to log into %s: %s"), ui->address, 
+		ftpStrerror(ui->ftpPort));
+	    return -1;
+	}
 
-    newtDrawForm(form);
-    newtRefresh();
+	fd = ftpGetFileDesc(ui->ftpPort, buf);
+	if (fd < 0) {
+	    close(ui->ftpPort);
+	    newtWinMessage(_("Error"), _("Ok"), 
+		_("Failed to retrieve %s: %s"), buf, ftpStrerror(fd));
+	    return -1;
+	}
+    } else {
+	fd = httpGetFileDesc(ui->address, -1, buf);
+	if (fd < 0) {
+	    newtWinMessage(_("Error"), _("Ok"), 
+		_("Failed to retrieve %s: %s"), buf, ftpStrerror(fd));
+	    return -1;
+	}
+    }
 
-    strcpy(buf, ui->urlprefix);
-    strcat(buf, "/RedHat/");
-    strcat(buf, filename);
-    fd = Fopen(buf, "r.ufdio");
+    winStatus(70, 3, _("Retrieving"), "%s %s...", _("Retrieving"), filename);
 
     return fd;
 }
 
-int urlinstFinishTransfer(FD_t fd) {
+int urlinstFinishTransfer(struct iurlinfo * ui, int fd) {
+    if (ui->protocol == URL_METHOD_FTP)
+	close(ui->ftpPort);
+    close(fd);
+
     newtPopWindow();
 
     return 0;
@@ -109,7 +126,7 @@ int urlMainSetupPanel(struct iurlinfo * ui, urlprotocol protocol,
     newtComponent answer, text;
     char * site, * dir;
     char * reflowedText = NULL;
-    int width, height, len;
+    int width, height;
     newtGrid entryGrid, buttons, grid;
     char * chptr;
 
@@ -242,10 +259,12 @@ int urlMainSetupPanel(struct iurlinfo * ui, urlprotocol protocol,
     chptr++;
     *chptr = '\0';
 
+#if 0
     if (ui->urlprefix) free(ui->urlprefix);
     len = strlen(ui->address);
     if (len < 15) len = 15;
     ui->urlprefix = malloc(sizeof(char) * (len + strlen(ui->prefix) + 10));
+#endif
 
     if (*doSecondarySetup != '*') {
 	if (ui->login)
@@ -257,15 +276,15 @@ int urlMainSetupPanel(struct iurlinfo * ui, urlprotocol protocol,
 	if (ui->proxyPort)
 	    free(ui->proxyPort);
 	ui->login = ui->password = ui->proxy = ui->proxyPort = NULL;
+	/*
 	delMacro(NULL, "_httpproxy");
 	delMacro(NULL, "_ftpproxy");
 	delMacro(NULL, "_httpproxyport");
 	delMacro(NULL, "_ftpproxyport");
+	*/
     }
 
-    sprintf(ui->urlprefix, "%s://%s/%s",
-	    protocol == URL_METHOD_FTP ? "ftp" : "http",
-	    addrToIp(ui->address), ui->prefix);
+    ui->protocol = protocol;
 
     newtFormDestroy(form);
     newtPopWindow();
@@ -273,6 +292,7 @@ int urlMainSetupPanel(struct iurlinfo * ui, urlprotocol protocol,
     return 0;
 }
 
+#if 0
 int urlSecondarySetupPanel(struct iurlinfo * ui, urlprotocol protocol) {
     newtComponent form, okay, cancel, answer, text, accountEntry = NULL;
     newtComponent passwordEntry = NULL, proxyEntry = NULL;
@@ -423,3 +443,4 @@ int urlSecondarySetupPanel(struct iurlinfo * ui, urlprotocol protocol) {
 
     return 0;
 }
+#endif
diff --git a/loader/urls.h b/loader/urls.h
index e79f1ca51..321298b37 100644
--- a/loader/urls.h
+++ b/loader/urls.h
@@ -5,19 +5,20 @@ enum urlprotocol_t { URL_METHOD_FTP, URL_METHOD_HTTP };
 typedef enum urlprotocol_t urlprotocol;
 
 struct iurlinfo {
+    urlprotocol protocol;
     char * address;
     char * login;
     char * password;
     char * prefix;
     char * proxy;
     char * proxyPort;
-    char * urlprefix;
+    int ftpPort;
 };
 
 int urlMainSetupPanel(struct iurlinfo * ui, urlprotocol protocol,
 		      char * doSecondarySetup);
 int urlSecondarySetupPanel(struct iurlinfo * ui, urlprotocol protocol);
-FD_t urlinstStartTransfer(struct iurlinfo * ui, char * filename);
-int urlinstFinishTransfer(FD_t fd);
+int urlinstStartTransfer(struct iurlinfo * ui, char * filename);
+int urlinstFinishTransfer(struct iurlinfo * ui, int fd);
 
 #endif