move ftp stuff from opieftp to shared lib

8 files changed, 631 insertions, 558 deletions

diff --git a/noncore/net/opieftp/ftplib.c b/noncore/net/ftplib/ftplib.c
index 5116170..421f855 100644
--- a/noncore/net/opieftp/ftplib.c
+++ b/noncore/net/ftplib/ftplib.c
@@ -1,1294 +1,1346 @@
 /***************************************************************************/
 /* ftplib.c - callable ftp access routines           */
 /* Copyright (C) 1996-2000 Thomas Pfau, pfau@cnj.digex.net       */
 /*  73 Catherine Street, South Bound Brook, NJ, 08880      */
 /*                     */
 /* This library is free software; you can redistribute it and/or     */
 /* modify it under the terms of the GNU Library General Public       */
 /* License as published by the Free Software Foundation; either      */
 /* version 2 of the License, or (at your option) any later version.    */
 /*                     */
 /* This library is distributed in the hope that it will be useful,     */
 /* but WITHOUT ANY WARRANTY; without even the implied warranty of    */
 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     */
 /* Library General Public License for more details.        */
 /*                     */
 /* You should have received a copy of the GNU Library General Public     */
 /* License along with this progam; if not, write to the        */
 /* Free Software Foundation, Inc., 59 Temple Place - Suite 330,      */
 /* Boston, MA 02111-1307, USA.               */
 /*                     */
 /***************************************************************************/
-
+// changes made by Lorn Potter <llornkcor@handhelds.org>
+// 
 #if defined(__unix__) || defined(__VMS)
 #include <unistd.h>
 #endif
 #if defined(_WIN32)
 #include <windows.h>
 #endif
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <ctype.h>
+
 #if defined(__unix__)
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #include <arpa/inet.h>
+
 #elif defined(VMS)
+
 #include <types.h>
 #include <socket.h>
 #include <in.h>
 #include <netdb.h>
 #include <inet.h>
+
 #elif defined(_WIN32)
+
 #include <winsock.h>
+
 #endif
 
 #define BUILDING_LIBRARY
 #include "ftplib.h"
 
 #if defined(_WIN32)
 #define SETSOCKOPT_OPTVAL_TYPE (const char *)
 #else
 #define SETSOCKOPT_OPTVAL_TYPE (void *)
 #endif
 
 #define FTPLIB_BUFSIZ 8192
-#define ACCEPT_TIMEOUT 15
+#define ACCEPT_TIMEOUT 10
 
 #define FTPLIB_CONTROL 0
 #define FTPLIB_READ 1
 #define FTPLIB_WRITE 2
 
 #if !defined FTPLIB_DEFMODE
 #define FTPLIB_DEFMODE FTPLIB_PASSIVE
 #endif
 
 struct NetBuf {
     char *cput,*cget;
     int handle;
     int cavail,cleft;
     char *buf;
     int dir;
     netbuf *ctrl;
     netbuf *data;    
     int cmode;
     struct timeval idletime;
     FtpCallback idlecb;
     void *idlearg;
     int xfered;
     int cbbytes;
     int xfered1;
     char response[256];
 };
 
 static char *version =
-    "ftplib Release 3.1-1 9/16/00, copyright 1996-2000 Thomas Pfau";
+"ftplib Release 3.1-1 9/16/00, copyright 1996-2000 Thomas Pfau";
 
 GLOBALDEF int ftplib_debug = 0;
 
 #if defined(__unix__) || defined(VMS)
 #define net_read read
 #define net_write write
 #define net_close close
 #elif defined(_WIN32)
 #define net_read(x,y,z) recv(x,y,z,0)
 #define net_write(x,y,z) send(x,y,z,0)
 #define net_close closesocket
 #endif
 
 #if defined(NEED_MEMCCPY)
 /*
  * VAX C does not supply a memccpy routine so I provide my own
  */
 void *memccpy(void *dest, const void *src, int c, size_t n)
 {
     int i=0;
     const unsigned char *ip=src;
     unsigned char *op=dest;
 
     while (i < n)
-    {
-  if ((*op++ = *ip++) == c)
-      break;
-  i++;
-    }
+      {
+          if ((*op++ = *ip++) == c)
+              break;
+          i++;
+      }
     if (i == n)
-  return NULL;
+        return NULL;
     return op;
 }
 #endif
 #if defined(NEED_STRDUP)
 /*
  * strdup - return a malloc'ed copy of a string
  */
 char *strdup(const char *src)
 {
     int l = strlen(src) + 1;
     char *dst = malloc(l);
     if (dst)
         strcpy(dst,src);
     return dst;
 }
 #endif
 
 /*
  * socket_wait - wait for socket to receive or flush data
  *
  * return 1 if no user callback, otherwise, return value returned by
  * user callback
  */
 static int socket_wait(netbuf *ctl)
 {
     fd_set fd,*rfd = NULL,*wfd = NULL;
     struct timeval tv;
     int rv = 0;
     if ((ctl->dir == FTPLIB_CONTROL) || (ctl->idlecb == NULL))
-  return 1;
+        return 1;
     if (ctl->dir == FTPLIB_WRITE)
-  wfd = &fd;
+        wfd = &fd;
     else
-  rfd = &fd;
+        rfd = &fd;
     FD_ZERO(&fd);
     do
-    {
-  FD_SET(ctl->handle,&fd);
-  tv = ctl->idletime;
-  rv = select(ctl->handle+1, rfd, wfd, NULL, &tv);
-  if (rv == -1)
-  {
-      rv = 0;
-      strncpy(ctl->ctrl->response, strerror(errno),
-                    sizeof(ctl->ctrl->response));
-      break;
-  }
-  else if (rv > 0)
-  {
-      rv = 1;
-      break;
-  }
-    }
+      {
+          FD_SET(ctl->handle,&fd);
+          tv = ctl->idletime;
+          rv = select(ctl->handle+1, rfd, wfd, NULL, &tv);
+          if (rv == -1)
+            {
+                rv = 0;
+                strncpy(ctl->ctrl->response, strerror(errno),
+                        sizeof(ctl->ctrl->response));
+                break;
+            }
+          else if (rv > 0)
+            {
+                rv = 1;
+                break;
+            }
+      }
     while ((rv = ctl->idlecb(ctl, ctl->xfered, ctl->idlearg)));
     return rv;
 }
 
 /*
  * read a line of text
  *
  * return -1 on error or bytecount
  */
 static int readline(char *buf,int max,netbuf *ctl)
 {
     int x,retval = 0;
     char *end,*bp=buf;
     int eof = 0;
 
     if ((ctl->dir != FTPLIB_CONTROL) && (ctl->dir != FTPLIB_READ))
-  return -1;
+        return -1;
     if (max == 0)
-  return 0;
+        return 0;
     do
-    {
-      if (ctl->cavail > 0)
-      {
-      x = (max >= ctl->cavail) ? ctl->cavail : max-1;
-      end = memccpy(bp,ctl->cget,'\n',x);
-      if (end != NULL)
-    x = end - bp;
-      retval += x;
-      bp += x;
-      *bp = '\0';
-      max -= x;
-      ctl->cget += x;
-      ctl->cavail -= x;
-      if (end != NULL)
-      {
-    bp -= 2;
-    if (strcmp(bp,"\r\n") == 0)
-    {
-        *bp++ = '\n';
-        *bp++ = '\0';
-        --retval;
-    }
-        break;
-      }
-      }
-      if (max == 1)
       {
-      *buf = '\0';
-      break;
+          if (ctl->cavail > 0)
+            {
+                x = (max >= ctl->cavail) ? ctl->cavail : max-1;
+                end = memccpy(bp,ctl->cget,'\n',x);
+                if (end != NULL)
+                    x = end - bp;
+                retval += x;
+                bp += x;
+                *bp = '\0';
+                max -= x;
+                ctl->cget += x;
+                ctl->cavail -= x;
+                if (end != NULL)
+                  {
+                      bp -= 2;
+                      if (strcmp(bp,"\r\n") == 0)
+                        {
+                            *bp++ = '\n';
+                            *bp++ = '\0';
+                            --retval;
+                        }
+                      break;
+                  }
+            }
+          if (max == 1)
+            {
+                *buf = '\0';
+                break;
+            }
+          if (ctl->cput == ctl->cget)
+            {
+                ctl->cput = ctl->cget = ctl->buf;
+                ctl->cavail = 0;
+                ctl->cleft = FTPLIB_BUFSIZ;
+            }
+          if (eof)
+            {
+                if (retval == 0)
+                    retval = -1;
+                break;
+            }
+          if (!socket_wait(ctl))
+              return retval;
+          if ((x = net_read(ctl->handle,ctl->cput,ctl->cleft)) == -1)
+            {
+                perror("read");
+                retval = -1;
+                break;
+            }
+          if (x == 0)
+              eof = 1;
+          ctl->cleft -= x;
+          ctl->cavail += x;
+          ctl->cput += x;
       }
-      if (ctl->cput == ctl->cget)
-      {
-      ctl->cput = ctl->cget = ctl->buf;
-      ctl->cavail = 0;
-      ctl->cleft = FTPLIB_BUFSIZ;
-      }
-  if (eof)
-  {
-      if (retval == 0)
-    retval = -1;
-      break;
-  }
-  if (!socket_wait(ctl))
-      return retval;
-      if ((x = net_read(ctl->handle,ctl->cput,ctl->cleft)) == -1)
-      {
-      perror("read");
-      retval = -1;
-      break;
-      }
-  if (x == 0)
-      eof = 1;
-      ctl->cleft -= x;
-      ctl->cavail += x;
-      ctl->cput += x;
-    }
     while (1);
     return retval;
 }
 
 /*
  * write lines of text
  *
  * return -1 on error or bytecount
  */
 static int writeline(char *buf, int len, netbuf *nData)
 {
     int x, nb=0, w;
     char *ubp = buf, *nbp;
     char lc=0;
 
     if (nData->dir != FTPLIB_WRITE)
-  return -1;
+        return -1;
     nbp = nData->buf;
     for (x=0; x < len; x++)
-    {
-  if ((*ubp == '\n') && (lc != '\r'))
-  {
-      if (nb == FTPLIB_BUFSIZ)
       {
-    if (!socket_wait(nData))
-        return x;
-    w = net_write(nData->handle, nbp, FTPLIB_BUFSIZ);
-    if (w != FTPLIB_BUFSIZ)
-    {
-        printf("net_write(1) returned %d, errno = %d\n", w, errno);
-        return(-1);
-    }
-    nb = 0;
+          if ((*ubp == '\n') && (lc != '\r'))
+            {
+                if (nb == FTPLIB_BUFSIZ)
+                  {
+                      if (!socket_wait(nData))
+                          return x;
+                      w = net_write(nData->handle, nbp, FTPLIB_BUFSIZ);
+                      if (w != FTPLIB_BUFSIZ)
+                        {
+                            printf("net_write(1) returned %d, errno = %d\n", w, errno);
+                            return(-1);
+                        }
+                      nb = 0;
+                  }
+                nbp[nb++] = '\r';
+            }
+          if (nb == FTPLIB_BUFSIZ)
+            {
+                if (!socket_wait(nData))
+                    return x;
+                w = net_write(nData->handle, nbp, FTPLIB_BUFSIZ);
+                if (w != FTPLIB_BUFSIZ)
+                  {
+                      printf("net_write(2) returned %d, errno = %d\n", w, errno);
+                      return(-1);
+                  }
+                nb = 0;
+            }
+          nbp[nb++] = lc = *ubp++;
       }
-      nbp[nb++] = '\r';
-  }
-  if (nb == FTPLIB_BUFSIZ)
-  {
-      if (!socket_wait(nData))
-    return x;
-      w = net_write(nData->handle, nbp, FTPLIB_BUFSIZ);
-      if (w != FTPLIB_BUFSIZ)
+    if (nb)
       {
-    printf("net_write(2) returned %d, errno = %d\n", w, errno);
-    return(-1);
+          if (!socket_wait(nData))
+              return x;
+          w = net_write(nData->handle, nbp, nb);
+          if (w != nb)
+            {
+                printf("net_write(3) returned %d, errno = %d\n", w, errno);
+                return(-1);
+            }
       }
-      nb = 0;
-  }
-  nbp[nb++] = lc = *ubp++;
-    }
-    if (nb)
-    {
-  if (!socket_wait(nData))
-      return x;
-  w = net_write(nData->handle, nbp, nb);
-  if (w != nb)
-  {
-      printf("net_write(3) returned %d, errno = %d\n", w, errno);
-      return(-1);
-  }
-    }
     return len;
 }
 
 /*
  * read a response from the server
  *
  * return 0 if first char doesn't match
  * return 1 if first char matches
  */
 static int readresp(char c, netbuf *nControl)
 {
     char match[5];
     if (readline(nControl->response,256,nControl) == -1)
-    {
-  perror("Control socket read failed");
-  return 0;
-    }
+      {
+          perror("Control socket read failed");
+          return 0;
+      }
     if (ftplib_debug > 1)
-  fprintf(stderr,"%s",nControl->response);
+        fprintf(stderr,"%s",nControl->response);
     if (nControl->response[3] == '-')
-    {
-  strncpy(match,nControl->response,3);
-  match[3] = ' ';
-  match[4] = '\0';
-  do
-  {
-      if (readline(nControl->response,256,nControl) == -1)
       {
-    perror("Control socket read failed");
-    return 0;
+          strncpy(match,nControl->response,3);
+          match[3] = ' ';
+          match[4] = '\0';
+          do
+            {
+                if (readline(nControl->response,256,nControl) == -1)
+                  {
+                      perror("Control socket read failed");
+                      return 0;
+                  }
+                if (ftplib_debug > 1)
+                    fprintf(stderr,"%s",nControl->response);
+            }
+          while (strncmp(nControl->response,match,4));
       }
-      if (ftplib_debug > 1)
-    fprintf(stderr,"%s",nControl->response);
-  }
-  while (strncmp(nControl->response,match,4));
-    }
     if (nControl->response[0] == c)
-  return 1;
+        return 1;
     return 0;
 }
 
 /*
  * FtpInit for stupid operating systems that require it (Windows NT)
  */
 GLOBALDEF void FtpInit(void)
 {
 #if defined(_WIN32)
     WORD wVersionRequested;
     WSADATA wsadata;
     int err;
     wVersionRequested = MAKEWORD(1,1);
     if ((err = WSAStartup(wVersionRequested,&wsadata)) != 0)
-  fprintf(stderr,"Network failed to start: %d\n",err);
+        fprintf(stderr,"Network failed to start: %d\n",err);
 #endif
 }
 
 /*
  * FtpLastResponse - return a pointer to the last response received
  */
 GLOBALDEF char *FtpLastResponse(netbuf *nControl)
 {
     if ((nControl) && (nControl->dir == FTPLIB_CONTROL))
-      return nControl->response;
+        return nControl->response;
     return NULL;
 }
 
 /*
  * FtpConnect - connect to remote server
  *
  * return 1 if connected, 0 if not
  */
 GLOBALDEF int FtpConnect(const char *host, netbuf **nControl)
 {
-    int sControl;
+    int sControl, stat, flags, oldflags;
     struct sockaddr_in sin;
     struct hostent *phe;
     struct servent *pse;
     int on=1;
     netbuf *ctrl;
     char *lhost;
     char *pnum;
+    struct timeval tv;
+    fd_set wr;
 
     memset(&sin,0,sizeof(sin));
     sin.sin_family = AF_INET;
     lhost = strdup(host);
     pnum = strchr(lhost,':');
     if (pnum == NULL)
-    {
+      {
 #if defined(VMS)
-      sin.sin_port = htons(21);
+          sin.sin_port = htons(21);
 #else
-      if ((pse = getservbyname("ftp","tcp")) == NULL)
-      {
-      perror("getservbyname");
-      return 0;
-      }
-      sin.sin_port = pse->s_port;
+          if ((pse = getservbyname("ftp","tcp")) == NULL)
+            {
+                perror("getservbyname");
+                return 0;
+            }
+          sin.sin_port = pse->s_port;
 #endif
-    }
+      }
     else
-    {
-  *pnum++ = '\0';
-  if (isdigit(*pnum))
-      sin.sin_port = htons(atoi(pnum));
-  else
-  {
-      pse = getservbyname(pnum,"tcp");
-      sin.sin_port = pse->s_port;
-  }
-    }
+      {
+          *pnum++ = '\0';
+          if (isdigit(*pnum))
+              sin.sin_port = htons(atoi(pnum));
+          else
+            {
+                pse = getservbyname(pnum,"tcp");
+                sin.sin_port = pse->s_port;
+            }
+      }
     if ((sin.sin_addr.s_addr = inet_addr(lhost)) == -1)
-    {
-      if ((phe = gethostbyname(lhost)) == NULL)
       {
-      perror("gethostbyname");
-      return 0;
+          if ((phe = gethostbyname(lhost)) == NULL)
+            {
+                perror("gethostbyname");
+                return 0;
+            }
+
+          memcpy((char *)&sin.sin_addr, phe->h_addr, phe->h_length);
+
       }
-      memcpy((char *)&sin.sin_addr, phe->h_addr, phe->h_length);
-    }
     free(lhost);
+
     sControl = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
     if (sControl == -1)
-    {
-  perror("socket");
-  return 0;
-    }
-    if (setsockopt(sControl,SOL_SOCKET,SO_REUSEADDR,
-       SETSOCKOPT_OPTVAL_TYPE &on, sizeof(on)) == -1)
-    {
-  perror("setsockopt");
-  net_close(sControl);
-  return 0;
-    }
-    if (connect(sControl, (struct sockaddr *)&sin, sizeof(sin)) == -1)
-    {
-  perror("connect");
-  net_close(sControl);
-  return 0;
-    }
+      {
+          perror("socket");
+          return 0;
+      }
+
+    if ( setsockopt(sControl,SOL_SOCKET,SO_REUSEADDR,
+                   SETSOCKOPT_OPTVAL_TYPE &on, sizeof(on)) == -1)
+      {
+          perror("setsockopt");
+          net_close(sControl);
+          return 0;
+      }
+
+     //set nonblocking for connection timeout
+    flags = fcntl( sControl, F_GETFL,0);
+    oldflags=flags;
+    fcntl( sControl, F_SETFL, O_NONBLOCK|flags);
+
+    stat=connect( sControl, (struct sockaddr *)&sin, sizeof(sin));
+    if (stat < 0) 
+      { 
+          if (errno != EWOULDBLOCK && errno != EINPROGRESS) 
+            { 
+                perror("connect");
+                net_close(sControl);
+                return 0;
+            } 
+      } 
+
+    FD_ZERO(&wr); 
+    FD_SET( sControl, &wr); 
+
+    tv.tv_sec = ACCEPT_TIMEOUT;
+    tv.tv_usec = 0; 
+
+    stat = select(sControl+1, 0, &wr, 0, &tv);
+
+    if (stat < 1)
+      { 
+            // time out has expired, 
+            // or an error has ocurred
+          perror("timeout");
+          net_close(sControl);
+          return 0;
+      } 
+
+    printf("connected\n");
+
+      //set original flags
+    fcntl( sControl, F_SETFL, oldflags);
+
     ctrl = calloc(1,sizeof(netbuf));
     if (ctrl == NULL)
-    {
-  perror("calloc");
-  net_close(sControl);
-  return 0;
-    }
+      {
+          perror("calloc");
+          net_close(sControl);
+          return 0;
+      }
     ctrl->buf = malloc(FTPLIB_BUFSIZ);
     if (ctrl->buf == NULL)
-    {
-  perror("calloc");
-  net_close(sControl);
-  free(ctrl);
-  return 0;
-    }
+      {
+          perror("calloc");
+          net_close(sControl);
+          free(ctrl);
+          return 0;
+      }
     ctrl->handle = sControl;
     ctrl->dir = FTPLIB_CONTROL;
     ctrl->ctrl = NULL;
     ctrl->cmode = FTPLIB_DEFMODE;
     ctrl->idlecb = NULL;
     ctrl->idletime.tv_sec = ctrl->idletime.tv_usec = 0;
     ctrl->idlearg = NULL;
     ctrl->xfered = 0;
     ctrl->xfered1 = 0;
     ctrl->cbbytes = 0;
     if (readresp('2', ctrl) == 0)
-    {
-  net_close(sControl);
-  free(ctrl->buf);
-  free(ctrl);
-  return 0;
-    }
+      {
+          net_close(sControl);
+          free(ctrl->buf);
+          free(ctrl);
+          return 0;
+      }
     *nControl = ctrl;
     return 1;
 }
 
 /*
  * FtpOptions - change connection options
  *
  * returns 1 if successful, 0 on error
  */
 GLOBALDEF int FtpOptions(int opt, long val, netbuf *nControl)
 {
     int v,rv=0;
     switch (opt)
-    {
-      case FTPLIB_CONNMODE:
-  v = (int) val;
-  if ((v == FTPLIB_PASSIVE) || (v == FTPLIB_PORT))
-  {
-      nControl->cmode = v;
-      rv = 1;
-  }
-  break;
-      case FTPLIB_CALLBACK:
-  nControl->idlecb = (FtpCallback) val;
-  rv = 1;
-  break;
-      case FTPLIB_IDLETIME:
-  v = (int) val;
-  rv = 1;
-  nControl->idletime.tv_sec = v / 1000;
-  nControl->idletime.tv_usec = (v % 1000) * 1000;
-  break;
-      case FTPLIB_CALLBACKARG:
-  rv = 1;
-  nControl->idlearg = (void *) val;
-  break;
-      case FTPLIB_CALLBACKBYTES:
-        rv = 1;
-        nControl->cbbytes = (int) val;
-        break;
-    }
+      {
+        case FTPLIB_CONNMODE:
+            v = (int) val;
+            if ((v == FTPLIB_PASSIVE) || (v == FTPLIB_PORT))
+              {
+                  nControl->cmode = v;
+                  rv = 1;
+              }
+            break;
+        case FTPLIB_CALLBACK:
+            nControl->idlecb = (FtpCallback) val;
+            rv = 1;
+            break;
+        case FTPLIB_IDLETIME:
+            v = (int) val;
+            rv = 1;
+            nControl->idletime.tv_sec = v / 1000;
+            nControl->idletime.tv_usec = (v % 1000) * 1000;
+            break;
+        case FTPLIB_CALLBACKARG:
+            rv = 1;
+            nControl->idlearg = (void *) val;
+            break;
+        case FTPLIB_CALLBACKBYTES:
+            rv = 1;
+            nControl->cbbytes = (int) val;
+            break;
+      }
     return rv;
 }
 
 /*
  * FtpSendCmd - send a command and wait for expected response
  *
  * return 1 if proper response received, 0 otherwise
  */
 static int FtpSendCmd(const char *cmd, char expresp, netbuf *nControl)
 {
     char buf[256];
     if (nControl->dir != FTPLIB_CONTROL)
-  return 0;
+        return 0;
     if (ftplib_debug > 2)
-  fprintf(stderr,"%s\n",cmd);
+        fprintf(stderr,"%s\n",cmd);
     if ((strlen(cmd) + 3) > sizeof(buf))
         return 0;
     sprintf(buf,"%s\r\n",cmd);
     if (net_write(nControl->handle,buf,strlen(buf)) <= 0)
-    {
-  perror("write");
-  return 0;
-    }
+      {
+          perror("write");
+          return 0;
+      }
     return readresp(expresp, nControl);
 }
 
 /*
  * FtpLogin - log in to remote server
  *
  * return 1 if logged in, 0 otherwise
  */
 GLOBALDEF int FtpLogin(const char *user, const char *pass, netbuf *nControl)
 {
     char tempbuf[64];
 
     if (((strlen(user) + 7) > sizeof(tempbuf)) ||
         ((strlen(pass) + 7) > sizeof(tempbuf)))
         return 0;
     sprintf(tempbuf,"USER %s",user);
     if (!FtpSendCmd(tempbuf,'3',nControl))
-    {
-  if (nControl->response[0] == '2')
-      return 1;
-  return 0;
-    }
+      {
+          if (nControl->response[0] == '2')
+              return 1;
+          return 0;
+      }
     sprintf(tempbuf,"PASS %s",pass);
     return FtpSendCmd(tempbuf,'2',nControl);
 }
 
 /*
  * FtpOpenPort - set up data connection
  *
  * return 1 if successful, 0 otherwise
  */
 static int FtpOpenPort(netbuf *nControl, netbuf **nData, int mode, int dir)
 {
     int sData;
     union {
-  struct sockaddr sa;
-  struct sockaddr_in in;
+        struct sockaddr sa;
+        struct sockaddr_in in;
     } sin;
     struct linger lng = { 0, 0 };
     unsigned int l;
     int on=1;
     netbuf *ctrl;
     char *cp;
     unsigned int v[6];
     char buf[256];
 
     if (nControl->dir != FTPLIB_CONTROL)
-  return -1;
+        return -1;
     if ((dir != FTPLIB_READ) && (dir != FTPLIB_WRITE))
-    {
-  sprintf(nControl->response, "Invalid direction %d\n", dir);
-  return -1;
-    }
+      {
+          sprintf(nControl->response, "Invalid direction %d\n", dir);
+          return -1;
+      }
     if ((mode != FTPLIB_ASCII) && (mode != FTPLIB_IMAGE))
-    {
-  sprintf(nControl->response, "Invalid mode %c\n", mode);
-  return -1;
-    }
+      {
+          sprintf(nControl->response, "Invalid mode %c\n", mode);
+          return -1;
+      }
     l = sizeof(sin);
     if (nControl->cmode == FTPLIB_PASSIVE)
-    {
-  memset(&sin, 0, l);
-  sin.in.sin_family = AF_INET;
-  if (!FtpSendCmd("PASV",'2',nControl))
-      return -1;
-  cp = strchr(nControl->response,'(');
-  if (cp == NULL)
-      return -1;
-  cp++;
-  sscanf(cp,"%u,%u,%u,%u,%u,%u",&v[2],&v[3],&v[4],&v[5],&v[0],&v[1]);
-  sin.sa.sa_data[2] = v[2];
-  sin.sa.sa_data[3] = v[3];
-  sin.sa.sa_data[4] = v[4];
-  sin.sa.sa_data[5] = v[5];
-  sin.sa.sa_data[0] = v[0];
-  sin.sa.sa_data[1] = v[1];
-    }
+      {
+          memset(&sin, 0, l);
+          sin.in.sin_family = AF_INET;
+          if (!FtpSendCmd("PASV",'2',nControl))
+              return -1;
+          cp = strchr(nControl->response,'(');
+          if (cp == NULL)
+              return -1;
+          cp++;
+          sscanf(cp,"%u,%u,%u,%u,%u,%u",&v[2],&v[3],&v[4],&v[5],&v[0],&v[1]);
+          sin.sa.sa_data[2] = v[2];
+          sin.sa.sa_data[3] = v[3];
+          sin.sa.sa_data[4] = v[4];
+          sin.sa.sa_data[5] = v[5];
+          sin.sa.sa_data[0] = v[0];
+          sin.sa.sa_data[1] = v[1];
+      }
     else
-    {
-  if (getsockname(nControl->handle, &sin.sa, &l) < 0)
-  {
-      perror("getsockname");
-      return 0;
-  }
-    }
+      {
+          if (getsockname(nControl->handle, &sin.sa, &l) < 0)
+            {
+                perror("getsockname");
+                return 0;
+            }
+      }
     sData = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
     if (sData == -1)
-    {
-  perror("socket");
-  return -1;
-    }
+      {
+          perror("socket");
+          return -1;
+      }
     if (setsockopt(sData,SOL_SOCKET,SO_REUSEADDR,
-       SETSOCKOPT_OPTVAL_TYPE &on,sizeof(on)) == -1)
-    {
-  perror("setsockopt");
-  net_close(sData);
-  return -1;
-    }
+                   SETSOCKOPT_OPTVAL_TYPE &on,sizeof(on)) == -1)
+      {
+          perror("setsockopt");
+          net_close(sData);
+          return -1;
+      }
     if (setsockopt(sData,SOL_SOCKET,SO_LINGER,
-       SETSOCKOPT_OPTVAL_TYPE &lng,sizeof(lng)) == -1)
-    {
-  perror("setsockopt");
-  net_close(sData);
-  return -1;
-    }
+                   SETSOCKOPT_OPTVAL_TYPE &lng,sizeof(lng)) == -1)
+      {
+          perror("setsockopt");
+          net_close(sData);
+          return -1;
+      }
     if (nControl->cmode == FTPLIB_PASSIVE)
-    {
-  if (connect(sData, &sin.sa, sizeof(sin.sa)) == -1)
-  {
-      perror("connect");
-      net_close(sData);
-      return -1;
-  }
-    }
+      {
+          if (connect(sData, &sin.sa, sizeof(sin.sa)) == -1)
+            {
+                perror("connect");
+                net_close(sData);
+                return -1;
+            }
+      }
     else
-    {
-  sin.in.sin_port = 0;
-  if (bind(sData, &sin.sa, sizeof(sin)) == -1)
-  {
-      perror("bind");
-      net_close(sData);
-      return 0;
-  }
-  if (listen(sData, 1) < 0)
-  {
-      perror("listen");
-      net_close(sData);
-      return 0;
-  }
-  if (getsockname(sData, &sin.sa, &l) < 0)
-      return 0;
-  sprintf(buf, "PORT %d,%d,%d,%d,%d,%d",
-    (unsigned char) sin.sa.sa_data[2],
-    (unsigned char) sin.sa.sa_data[3],
-    (unsigned char) sin.sa.sa_data[4],
-    (unsigned char) sin.sa.sa_data[5],
-    (unsigned char) sin.sa.sa_data[0],
-    (unsigned char) sin.sa.sa_data[1]);
-  if (!FtpSendCmd(buf,'2',nControl))
-  {
-      net_close(sData);
-      return 0;
-  }
-    }
+      {
+          sin.in.sin_port = 0;
+          if (bind(sData, &sin.sa, sizeof(sin)) == -1)
+            {
+                perror("bind");
+                net_close(sData);
+                return 0;
+            }
+          if (listen(sData, 1) < 0)
+            {
+                perror("listen");
+                net_close(sData);
+                return 0;
+            }
+          if (getsockname(sData, &sin.sa, &l) < 0)
+              return 0;
+          sprintf(buf, "PORT %d,%d,%d,%d,%d,%d",
+                  (unsigned char) sin.sa.sa_data[2],
+                  (unsigned char) sin.sa.sa_data[3],
+                  (unsigned char) sin.sa.sa_data[4],
+                  (unsigned char) sin.sa.sa_data[5],
+                  (unsigned char) sin.sa.sa_data[0],
+                  (unsigned char) sin.sa.sa_data[1]);
+          if (!FtpSendCmd(buf,'2',nControl))
+            {
+                net_close(sData);
+                return 0;
+            }
+      }
     ctrl = calloc(1,sizeof(netbuf));
     if (ctrl == NULL)
-    {
-  perror("calloc");
-  net_close(sData);
-  return -1;
-    }
+      {
+          perror("calloc");
+          net_close(sData);
+          return -1;
+      }
     if ((mode == 'A') && ((ctrl->buf = malloc(FTPLIB_BUFSIZ)) == NULL))
-    {
-  perror("calloc");
-  net_close(sData);
-  free(ctrl);
-  return -1;
-    }
+      {
+          perror("calloc");
+          net_close(sData);
+          free(ctrl);
+          return -1;
+      }
     ctrl->handle = sData;
     ctrl->dir = dir;
     ctrl->idletime = nControl->idletime;
     ctrl->idlearg = nControl->idlearg;
     ctrl->xfered = 0;
     ctrl->xfered1 = 0;
     ctrl->cbbytes = nControl->cbbytes;
     if (ctrl->idletime.tv_sec || ctrl->idletime.tv_usec || ctrl->cbbytes)
-  ctrl->idlecb = nControl->idlecb;
+        ctrl->idlecb = nControl->idlecb;
     else
-  ctrl->idlecb = NULL;
+        ctrl->idlecb = NULL;
     *nData = ctrl;
     return 1;
 }
 
 /*
  * FtpAcceptConnection - accept connection from server
  *
  * return 1 if successful, 0 otherwise
  */
 static int FtpAcceptConnection(netbuf *nData, netbuf *nControl)
 {
     int sData;
     struct sockaddr addr;
     unsigned int l;
     int i;
     struct timeval tv;
     fd_set mask;
     int rv;
 
     FD_ZERO(&mask);
     FD_SET(nControl->handle, &mask);
     FD_SET(nData->handle, &mask);
     tv.tv_usec = 0;
     tv.tv_sec = ACCEPT_TIMEOUT;
+    printf("<<<<<<<<<<<<<<<<%d\n",ACCEPT_TIMEOUT);
     i = nControl->handle;
     if (i < nData->handle)
-  i = nData->handle;
+        i = nData->handle;
     i = select(i+1, &mask, NULL, NULL, &tv);
     if (i == -1)
-    {
-        strncpy(nControl->response, strerror(errno),
-                sizeof(nControl->response));
-        net_close(nData->handle);
-        nData->handle = 0;
-        rv = 0;
-    }
+      {
+          strncpy(nControl->response, strerror(errno),
+                  sizeof(nControl->response));
+          net_close(nData->handle);
+          nData->handle = 0;
+          rv = 0;
+      }
     else if (i == 0)
-    {
-  strcpy(nControl->response, "timed out waiting for connection");
-  net_close(nData->handle);
-  nData->handle = 0;
-  rv = 0;
-    }
-    else
-    {
-  if (FD_ISSET(nData->handle, &mask))
-  {
-      l = sizeof(addr);
-      sData = accept(nData->handle, &addr, &l);
-      i = errno;
-      net_close(nData->handle);
-      if (sData > 0)
       {
-    rv = 1;
-    nData->handle = sData;
+          strcpy(nControl->response, "timed out waiting for connection");
+          net_close(nData->handle);
+          nData->handle = 0;
+          rv = 0;
       }
-      else
+    else
       {
-    strncpy(nControl->response, strerror(i),
-                        sizeof(nControl->response));
-    nData->handle = 0;
-    rv = 0;
+          if (FD_ISSET(nData->handle, &mask))
+            {
+                l = sizeof(addr);
+                sData = accept(nData->handle, &addr, &l);
+                i = errno;
+                net_close(nData->handle);
+                if (sData > 0)
+                  {
+                      rv = 1;
+                      nData->handle = sData;
+                  }
+                else
+                  {
+                      strncpy(nControl->response, strerror(i),
+                              sizeof(nControl->response));
+                      nData->handle = 0;
+                      rv = 0;
+                  }
+            }
+          else if (FD_ISSET(nControl->handle, &mask))
+            {
+                net_close(nData->handle);
+                nData->handle = 0;
+                readresp('2', nControl);
+                rv = 0;
+            }
       }
-  }
-  else if (FD_ISSET(nControl->handle, &mask))
-  {
-      net_close(nData->handle);
-      nData->handle = 0;
-      readresp('2', nControl);
-      rv = 0;
-  }
-    }
     return rv;  
 }
 
 /*
  * FtpAccess - return a handle for a data stream
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpAccess(const char *path, int typ, int mode, netbuf *nControl,
-    netbuf **nData)
+                        netbuf **nData)
 {
     char buf[256];
     int dir;
     if ((path == NULL) &&
         ((typ == FTPLIB_FILE_WRITE) || (typ == FTPLIB_FILE_READ)))
-    {
-  sprintf(nControl->response,
-                "Missing path argument for file transfer\n");
-  return 0;
-    }
+      {
+          sprintf(nControl->response,
+                  "Missing path argument for file transfer\n");
+          return 0;
+      }
     sprintf(buf, "TYPE %c", mode);
     if (!FtpSendCmd(buf, '2', nControl))
-  return 0;
+        return 0;
     switch (typ)
-    {
-      case FTPLIB_DIR:
-  strcpy(buf,"NLST");
-  dir = FTPLIB_READ;
-  break;
-      case FTPLIB_DIR_VERBOSE:
-  strcpy(buf,"LIST");
-  dir = FTPLIB_READ;
-  break;
-      case FTPLIB_FILE_READ:
-  strcpy(buf,"RETR");
-  dir = FTPLIB_READ;
-  break;
-      case FTPLIB_FILE_WRITE:
-  strcpy(buf,"STOR");
-  dir = FTPLIB_WRITE;
-  break;
-      default:
-  sprintf(nControl->response, "Invalid open type %d\n", typ);
-  return 0;
-    }
-    if (path != NULL)
-    {
-        int i = strlen(buf);
-        buf[i++] = ' ';
-        if ((strlen(path) + i) >= sizeof(buf))
+      {
+        case FTPLIB_DIR:
+            strcpy(buf,"NLST");
+            dir = FTPLIB_READ;
+            break;
+        case FTPLIB_DIR_VERBOSE:
+            strcpy(buf,"LIST");
+            dir = FTPLIB_READ;
+            break;
+        case FTPLIB_FILE_READ:
+            strcpy(buf,"RETR");
+            dir = FTPLIB_READ;
+            break;
+        case FTPLIB_FILE_WRITE:
+            strcpy(buf,"STOR");
+            dir = FTPLIB_WRITE;
+            break;
+        default:
+            sprintf(nControl->response, "Invalid open type %d\n", typ);
             return 0;
-        strcpy(&buf[i],path);
-    }
+      }
+    if (path != NULL)
+      {
+          int i = strlen(buf);
+          buf[i++] = ' ';
+          if ((strlen(path) + i) >= sizeof(buf))
+              return 0;
+          strcpy(&buf[i],path);
+      }
     if (FtpOpenPort(nControl, nData, mode, dir) == -1)
-  return 0;
+        return 0;
     if (!FtpSendCmd(buf, '1', nControl))
-    {
-  FtpClose(*nData);
-  *nData = NULL;
-  return 0;
-    }
+      {
+          FtpClose(*nData);
+          *nData = NULL;
+          return 0;
+      }
     (*nData)->ctrl = nControl;
     nControl->data = *nData;
     if (nControl->cmode == FTPLIB_PORT)
-    {
-  if (!FtpAcceptConnection(*nData,nControl))
-  {
-      FtpClose(*nData);
-      *nData = NULL;
-      nControl->data = NULL;
-      return 0;
-  }
-    }
+      {
+          if (!FtpAcceptConnection(*nData,nControl))
+            {
+                FtpClose(*nData);
+                *nData = NULL;
+                nControl->data = NULL;
+                return 0;
+            }
+      }
     return 1;
 }
 
 /*
  * FtpRead - read from a data connection
  */
 GLOBALDEF int FtpRead(void *buf, int max, netbuf *nData)
 {
     int i;
     if (nData->dir != FTPLIB_READ)
-  return 0;
+        return 0;
     if (nData->buf)
         i = readline(buf, max, nData);
     else
-    {
-        i = socket_wait(nData);
-  if (i != 1)
-      return 0;
-        i = net_read(nData->handle, buf, max);
-    }
+      {
+          i = socket_wait(nData);
+          if (i != 1)
+              return 0;
+          i = net_read(nData->handle, buf, max);
+      }
     if (i == -1)
-  return 0;
+        return 0;
     nData->xfered += i;
     if (nData->idlecb && nData->cbbytes)
-    {
-        nData->xfered1 += i;
-        if (nData->xfered1 > nData->cbbytes)
-        {
-      if (nData->idlecb(nData, nData->xfered, nData->idlearg) == 0)
-    return 0;
-            nData->xfered1 = 0;
-        }
-    }
+      {
+          nData->xfered1 += i;
+          if (nData->xfered1 > nData->cbbytes)
+            {
+                if (nData->idlecb(nData, nData->xfered, nData->idlearg) == 0)
+                    return 0;
+                nData->xfered1 = 0;
+            }
+      }
     return i;
 }
 
 /*
  * FtpWrite - write to a data connection
  */
 GLOBALDEF int FtpWrite(void *buf, int len, netbuf *nData)
 {
     int i;
     if (nData->dir != FTPLIB_WRITE)
-  return 0;
+        return 0;
     if (nData->buf)
-      i = writeline(buf, len, nData);
+        i = writeline(buf, len, nData);
     else
-    {
-        socket_wait(nData);
-        i = net_write(nData->handle, buf, len);
-    }
+      {
+          socket_wait(nData);
+          i = net_write(nData->handle, buf, len);
+      }
     if (i == -1)
-  return 0;
+        return 0;
     nData->xfered += i;
     if (nData->idlecb && nData->cbbytes)
-    {
-        nData->xfered1 += i;
-        if (nData->xfered1 > nData->cbbytes)
-        {
-            nData->idlecb(nData, nData->xfered, nData->idlearg);
-            nData->xfered1 = 0;
-        }
-    }
+      {
+          nData->xfered1 += i;
+          if (nData->xfered1 > nData->cbbytes)
+            {
+                nData->idlecb(nData, nData->xfered, nData->idlearg);
+                nData->xfered1 = 0;
+            }
+      }
     return i;
 }
 
 /*
  * FtpClose - close a data connection
  */
 GLOBALDEF int FtpClose(netbuf *nData)
 {
     netbuf *ctrl;
     switch (nData->dir)
-    {
-      case FTPLIB_WRITE:
-  /* potential problem - if buffer flush fails, how to notify user? */
-  if (nData->buf != NULL)
-      writeline(NULL, 0, nData);
-      case FTPLIB_READ:
-  if (nData->buf)
-      free(nData->buf);
-  shutdown(nData->handle,2);
-  net_close(nData->handle);
-  ctrl = nData->ctrl;
-  free(nData);
-  if (ctrl)
-  {
-      ctrl->data = NULL;
-      return(readresp('2', ctrl));
-  }
-  return 1;
-      case FTPLIB_CONTROL:
-  if (nData->data)
-  {
-      nData->ctrl = NULL;
-      FtpClose(nData);
-  }
-  net_close(nData->handle);
-  free(nData);
-  return 0;
-    }
+      {
+        case FTPLIB_WRITE:
+              /* potential problem - if buffer flush fails, how to notify user? */
+            if (nData->buf != NULL)
+                writeline(NULL, 0, nData);
+        case FTPLIB_READ:
+            if (nData->buf)
+                free(nData->buf);
+            shutdown(nData->handle,2);
+            net_close(nData->handle);
+            ctrl = nData->ctrl;
+            free(nData);
+            if (ctrl)
+              {
+                  ctrl->data = NULL;
+                  return(readresp('2', ctrl));
+              }
+            return 1;
+        case FTPLIB_CONTROL:
+            if (nData->data)
+              {
+                  nData->ctrl = NULL;
+                  FtpClose(nData);
+              }
+            net_close(nData->handle);
+            free(nData);
+            return 0;
+      }
     return 1;
 }
 
 /*
  * FtpSite - send a SITE command
  *
  * return 1 if command successful, 0 otherwise
  */
 GLOBALDEF int FtpSite(const char *cmd, netbuf *nControl)
 {
     char buf[256];
     
     if ((strlen(cmd) + 7) > sizeof(buf))
         return 0;
     sprintf(buf,"SITE %s",cmd);
     if (!FtpSendCmd(buf,'2',nControl))
-  return 0;
+        return 0;
     return 1;
 }
 
 /*
  * FtpSysType - send a SYST command
  *
  * Fills in the user buffer with the remote system type.  If more
  * information from the response is required, the user can parse
  * it out of the response buffer returned by FtpLastResponse().
  *
  * return 1 if command successful, 0 otherwise
  */
 GLOBALDEF int FtpSysType(char *buf, int max, netbuf *nControl)
 {
     int l = max;
     char *b = buf;
     char *s;
     if (!FtpSendCmd("SYST",'2',nControl))
-  return 0;
+        return 0;
     s = &nControl->response[4];
     while ((--l) && (*s != ' '))
-  *b++ = *s++;
+        *b++ = *s++;
     *b++ = '\0';
     return 1;
 }
 
 /*
  * FtpMkdir - create a directory at server
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpMkdir(const char *path, netbuf *nControl)
 {
     char buf[256];
 
     if ((strlen(path) + 6) > sizeof(buf))
         return 0;
     sprintf(buf,"MKD %s",path);
     if (!FtpSendCmd(buf,'2', nControl))
-  return 0;
+        return 0;
     return 1;
 }
 
 /*
  * FtpChdir - change path at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpChdir(const char *path, netbuf *nControl)
 {
     char buf[256];
 
     if ((strlen(path) + 6) > sizeof(buf))
         return 0;
     sprintf(buf,"CWD %s",path);
     if (!FtpSendCmd(buf,'2',nControl))
-  return 0;
+        return 0;
     return 1;
 }
 
 /*
  * FtpCDUp - move to parent directory at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpCDUp(netbuf *nControl)
 {
     if (!FtpSendCmd("CDUP",'2',nControl))
-  return 0;
+        return 0;
     return 1;
 }
 
 /*
  * FtpRmdir - remove directory at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpRmdir(const char *path, netbuf *nControl)
 {
     char buf[256];
 
     if ((strlen(path) + 6) > sizeof(buf))
         return 0;
     sprintf(buf,"RMD %s",path);
     if (!FtpSendCmd(buf,'2',nControl))
-  return 0;
+        return 0;
     return 1;
 }
 
 /*
  * FtpPwd - get working directory at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpPwd(char *path, int max, netbuf *nControl)
 {
     int l = max;
     char *b = path;
     char *s;
     if (!FtpSendCmd("PWD",'2',nControl))
-  return 0;
+        return 0;
     s = strchr(nControl->response, '"');
     if (s == NULL)
-  return 0;
+        return 0;
     s++;
     while ((--l) && (*s) && (*s != '"'))
-  *b++ = *s++;
+        *b++ = *s++;
     *b++ = '\0';
     return 1;
 }
 
 /*
  * FtpXfer - issue a command and transfer data
  *
  * return 1 if successful, 0 otherwise
  */
 static int FtpXfer(const char *localfile, const char *path,
-  netbuf *nControl, int typ, int mode)
+                   netbuf *nControl, int typ, int mode)
 {
     int l,c;
     char *dbuf;
     FILE *local = NULL;
     netbuf *nData;
     int rv=1;
 
     if (localfile != NULL)
-    {
-  char ac[4] = "w";
-  if (typ == FTPLIB_FILE_WRITE)
-      ac[0] = 'r';
-  if (mode == FTPLIB_IMAGE)
-      ac[1] = 'b';
-  local = fopen(localfile, ac);
-  if (local == NULL)
-  {
-      strncpy(nControl->response, strerror(errno),
-                    sizeof(nControl->response));
-      return 0;
-  }
-    }
+      {
+          char ac[4] = "w";
+          if (typ == FTPLIB_FILE_WRITE)
+              ac[0] = 'r';
+          if (mode == FTPLIB_IMAGE)
+              ac[1] = 'b';
+          local = fopen(localfile, ac);
+          if (local == NULL)
+            {
+                strncpy(nControl->response, strerror(errno),
+                        sizeof(nControl->response));
+                return 0;
+            }
+      }
     if (local == NULL)
-  local = (typ == FTPLIB_FILE_WRITE) ? stdin : stdout;
+        local = (typ == FTPLIB_FILE_WRITE) ? stdin : stdout;
     if (!FtpAccess(path, typ, mode, nControl, &nData))
-  return 0;
+        return 0;
     dbuf = malloc(FTPLIB_BUFSIZ);
     if (typ == FTPLIB_FILE_WRITE)
-    {
-  while ((l = fread(dbuf, 1, FTPLIB_BUFSIZ, local)) > 0)
-      if ((c = FtpWrite(dbuf, l, nData)) < l)
       {
-    printf("short write: passed %d, wrote %d\n", l, c);
-    rv = 0;
-    break;
+          while ((l = fread(dbuf, 1, FTPLIB_BUFSIZ, local)) > 0)
+              if ((c = FtpWrite(dbuf, l, nData)) < l)
+                {
+                    printf("short write: passed %d, wrote %d\n", l, c);
+                    rv = 0;
+                    break;
+                }
       }
-    }
     else
-    {
-      while ((l = FtpRead(dbuf, FTPLIB_BUFSIZ, nData)) > 0)
-      if (fwrite(dbuf, 1, l, local) <= 0)
       {
-    perror("localfile write");
-    rv = 0;
-    break;
+          while ((l = FtpRead(dbuf, FTPLIB_BUFSIZ, nData)) > 0)
+              if (fwrite(dbuf, 1, l, local) <= 0)
+                {
+                    perror("localfile write");
+                    rv = 0;
+                    break;
+                }
       }
-    }
     free(dbuf);
     fflush(local);
     if (localfile != NULL)
-  fclose(local);
+        fclose(local);
     FtpClose(nData);
     return rv;
 }
 
 /*
  * FtpNlst - issue an NLST command and write response to output
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpNlst(const char *outputfile, const char *path,
-  netbuf *nControl)
+                      netbuf *nControl)
 {
     return FtpXfer(outputfile, path, nControl, FTPLIB_DIR, FTPLIB_ASCII);
 }
 
 /*
  * FtpDir - issue a LIST command and write response to output
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpDir(const char *outputfile, const char *path, netbuf *nControl)
 {
     return FtpXfer(outputfile, path, nControl, FTPLIB_DIR_VERBOSE, FTPLIB_ASCII);
 }
 
 /*
  * FtpSize - determine the size of a remote file
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpSize(const char *path, int *size, char mode, netbuf *nControl)
 {
     char cmd[256];
     int resp,sz,rv=1;
 
     if ((strlen(path) + 7) > sizeof(cmd))
         return 0;
     sprintf(cmd, "TYPE %c", mode);
     if (!FtpSendCmd(cmd, '2', nControl))
-  return 0;
+        return 0;
     sprintf(cmd,"SIZE %s",path);
     if (!FtpSendCmd(cmd,'2',nControl))
-  rv = 0;
+        rv = 0;
     else
-    {
-  if (sscanf(nControl->response, "%d %d", &resp, &sz) == 2)
-      *size = sz;
-  else
-      rv = 0;
-    }   
+      {
+          if (sscanf(nControl->response, "%d %d", &resp, &sz) == 2)
+              *size = sz;
+          else
+              rv = 0;
+      }   
     return rv;
 }
 
 /*
  * FtpModDate - determine the modification date of a remote file
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpModDate(const char *path, char *dt, int max, netbuf *nControl)
 {
     char buf[256];
     int rv = 1;
 
     if ((strlen(path) + 7) > sizeof(buf))
         return 0;
     sprintf(buf,"MDTM %s",path);
     if (!FtpSendCmd(buf,'2',nControl))
-  rv = 0;
+        rv = 0;
     else
-  strncpy(dt, &nControl->response[4], max);
+        strncpy(dt, &nControl->response[4], max);
     return rv;
 }
 
 /*
  * FtpGet - issue a GET command and write received data to output
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpGet(const char *outputfile, const char *path,
-  char mode, netbuf *nControl)
+                     char mode, netbuf *nControl)
 {
     return FtpXfer(outputfile, path, nControl, FTPLIB_FILE_READ, mode);
 }
 
 /*
  * FtpPut - issue a PUT command and send data from input
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpPut(const char *inputfile, const char *path, char mode,
-  netbuf *nControl)
+                     netbuf *nControl)
 {
     return FtpXfer(inputfile, path, nControl, FTPLIB_FILE_WRITE, mode);
 }
 
 /*
  * FtpRename - rename a file at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpRename(const char *src, const char *dst, netbuf *nControl)
 {
     char cmd[256];
 
     if (((strlen(src) + 7) > sizeof(cmd)) ||
         ((strlen(dst) + 7) > sizeof(cmd)))
         return 0;
     sprintf(cmd,"RNFR %s",src);
     if (!FtpSendCmd(cmd,'3',nControl))
-  return 0;
+        return 0;
     sprintf(cmd,"RNTO %s",dst);
     if (!FtpSendCmd(cmd,'2',nControl))
-  return 0;
+        return 0;
     return 1;
 }
 
 /*
  * FtpDelete - delete a file at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpDelete(const char *fnm, netbuf *nControl)
 {
     char cmd[256];
 
     if ((strlen(fnm) + 7) > sizeof(cmd))
         return 0;
     sprintf(cmd,"DELE %s",fnm);
     if (!FtpSendCmd(cmd,'2', nControl))
-  return 0;
+        return 0;
     return 1;
 }
 
 /*
  * FtpQuit - disconnect from remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF void FtpQuit(netbuf *nControl)
 {
     if (nControl->dir != FTPLIB_CONTROL)
-  return;
+        return;
     FtpSendCmd("QUIT",'2',nControl);
     net_close(nControl->handle);
     free(nControl->buf);
     free(nControl);
 }
diff --git a/noncore/net/ftplib/ftplib.control b/noncore/net/ftplib/ftplib.control
new file mode 100644
index 0000000..67765ad
--- a/dev/null
+++ b/noncore/net/ftplib/ftplib.control
@@ -0,0 +1,9 @@
+Files: $QTDIR/lib/libftplib.*
+Priority: optional
+Section: Communications
+Maintainer: L.J. Potter <ljp@llornkcor.com> 
+Architecture: arm
+Version: $QPE_VERSION-$SUB_VERSION
+Depends: opie-base ($QPE_VERSION)
+Description: Libftp
+ The ftp library for the Opie environment.
diff --git a/noncore/net/opieftp/ftplib.h b/noncore/net/ftplib/ftplib.h
index 75a90ae..75a90ae 100644
--- a/noncore/net/opieftp/ftplib.h
+++ b/noncore/net/ftplib/ftplib.h
diff --git a/noncore/net/ftplib/ftplib.pro b/noncore/net/ftplib/ftplib.pro
new file mode 100644
index 0000000..9ee3605
--- a/dev/null
+++ b/noncore/net/ftplib/ftplib.pro
@@ -0,0 +1,6 @@
+TEMPLATE  = lib
+CONFIG    = qt warn_on release
+HEADERS   = ftplib.h
+SOURCES   = ftplib.c
+DESTDIR      = $(QTDIR)/lib$(PROJMAK)
+INTERFACES  = 
diff --git a/noncore/net/opieftp/opieftp.control b/noncore/net/opieftp/opieftp.control
index 18ec80f..42590bd 100644
--- a/noncore/net/opieftp/opieftp.control
+++ b/noncore/net/opieftp/opieftp.control
@@ -1,9 +1,9 @@
 Files: bin/opieftp pics/opieftp apps/Applications/opieftp.desktop
 Priority: optional
 Section: Communications
 Maintainer: L.J. Potter <ljp@llornkcor.com> 
 Architecture: arm
 Version: $QPE_VERSION-$SUB_VERSION
-Depends: opie-base ($QPE_VERSION)
+Depends: opie-base ($QPE_VERSION), ftplib
 Description: OpieFtp
  The ftp client for the Opie environment.
diff --git a/noncore/net/opieftp/opieftp.cpp b/noncore/net/opieftp/opieftp.cpp
index 292cc9d..7c83223 100644
--- a/noncore/net/opieftp/opieftp.cpp
+++ b/noncore/net/opieftp/opieftp.cpp
@@ -1,1512 +1,1516 @@
 /***************************************************************************
    opieftp.cpp
                              -------------------
 ** Created: Sat Mar 9 23:33:09 2002
     copyright            : (C) 2002 by ljp
     email                : ljp@llornkcor.com
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 //#define DEVELOPERS_VERSION
 
 #include "opieftp.h"
 
 extern "C" {
-#include "ftplib.h"
+#include "../ftplib/ftplib.h"
 }
 
 #include "inputDialog.h"
 
 #include <qpe/qpemenubar.h>
 #include <qpe/qpetoolbar.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/config.h>
 #include <qpe/mimetype.h>
 #include <qpe/qpemessagebox.h>
 
 #include <qstringlist.h>
 #include <qtextstream.h>
 #include <qpushbutton.h>
 #include <qtoolbutton.h>
 #include <qdatetime.h>
 #include <qdir.h>
 #include <qfile.h>
 #include <qstring.h>
 #include <qcombobox.h>
 #include <qpopupmenu.h>
 #include <qlistview.h>
 #include <qmainwindow.h>
 #include <qlabel.h>
 #include <qprogressbar.h>
 #include <qspinbox.h>
 #include <qtabwidget.h>
 #include <qwidget.h>
 #include <qlayout.h>
 #include <qimage.h>
 #include <qpixmap.h>
 #include <qmessagebox.h>
 #include <qlineedit.h>
 #include <qregexp.h>
 #include <qlistbox.h>
 
 #include <unistd.h>
 #include <stdlib.h>
 
 
 QProgressBar *ProgressBar;
 static netbuf *conn=NULL;
 
 static int log_progress(netbuf *, int xfered, void *)
 {
 //    int fsz = *(int *)arg;
 //    int pct = (xfered * 100) / fsz;
 //      printf("%3d%%\r", pct);
 //      fflush(stdout);
     ProgressBar->setProgress(xfered);
     qApp->processEvents();
     return 1;
 }
 
 OpieFtp::OpieFtp( )
         : QMainWindow( )
 {
     setCaption( tr( "OpieFtp" ) );
     fuckeduphack=FALSE;
     QGridLayout *layout = new QGridLayout( this );
     layout->setSpacing( 2);
     layout->setMargin( 2);
 
     connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
 
     QPEMenuBar *menuBar = new QPEMenuBar(this);
 //     QPEToolBar *menuBar = new QPEToolBar(this);
 //     menuBar->setHorizontalStretchable( TRUE );
 
     connectionMenu  = new QPopupMenu( this );
     localMenu  = new QPopupMenu( this );
     remoteMenu  = new QPopupMenu( this );
     tabMenu = new QPopupMenu( this );
     
     layout->addMultiCellWidget( menuBar, 0, 0, 0, 2 );
 
     menuBar->insertItem( tr( "Connection" ), connectionMenu);
     menuBar->insertItem( tr( "Local" ), localMenu);
     menuBar->insertItem( tr( "Remote" ), remoteMenu);
     menuBar->insertItem( tr( "View" ), tabMenu);
 
     connectionMenu->insertItem( tr( "New" ), this,  SLOT( newConnection() ));
     connectionMenu->insertItem( tr( "Connect" ), this,  SLOT( connector() ));
     connectionMenu->insertItem( tr( "Disconnect" ), this,  SLOT( disConnector() ));
 
     localMenu->insertItem( tr( "Show Hidden Files" ), this,  SLOT( showHidden() ));
     localMenu->insertSeparator();
     localMenu->insertItem( tr( "Upload" ), this, SLOT( localUpload() ));
     localMenu->insertItem( tr( "Make Directory" ), this, SLOT( localMakDir() ));
     localMenu->insertItem( tr( "Rename" ), this, SLOT( localRename() ));
     localMenu->insertSeparator();
     localMenu->insertItem( tr( "Delete" ), this, SLOT( localDelete() ));
     localMenu->setCheckable(TRUE);
 
     remoteMenu->insertItem( tr( "Download" ), this, SLOT( remoteDownload() ));
     remoteMenu->insertItem( tr( "Make Directory" ), this, SLOT( remoteMakDir() ));
     remoteMenu->insertItem( tr( "Rename" ), this, SLOT( remoteRename() ));
     remoteMenu->insertSeparator();
     remoteMenu->insertItem( tr( "Delete" ), this, SLOT( remoteDelete() ));
 
     tabMenu->insertItem( tr( "Switch to Local" ), this, SLOT( switchToLocalTab() ));
     tabMenu->insertItem( tr( "Switch to Remote" ), this, SLOT( switchToRemoteTab() ));
     tabMenu->insertItem( tr( "Switch to Config" ), this, SLOT( switchToConfigTab() ));
     tabMenu->insertSeparator();
     tabMenu->insertItem( tr( "About" ), this, SLOT( doAbout() ));
     tabMenu->setCheckable(TRUE);
 
 
 
     cdUpButton = new QToolButton( this,"cdUpButton");
     cdUpButton->setPixmap(Resource::loadPixmap("up"));
     cdUpButton ->setFixedSize( QSize( 20, 20 ) );
     connect( cdUpButton ,SIGNAL(released()),this,SLOT( upDir()) );
     layout->addMultiCellWidget( cdUpButton, 0, 0, 3, 3 );
     cdUpButton->hide();
 
 //     docButton = new QPushButton(Resource::loadIconSet("DocsIcon"),"",this,"docsButton");
 //     docButton->setFixedSize( QSize( 20, 20 ) );
 //     connect( docButton,SIGNAL(released()),this,SLOT( docButtonPushed()) );
 //     docButton->setFlat(TRUE);
 //     layout->addMultiCellWidget( docButton, 0, 0, 6, 6 );
 
     homeButton = new QToolButton(this,"homeButton");
     homeButton->setPixmap( Resource::loadPixmap("home"));
     homeButton->setFixedSize( QSize( 20, 20 ) );
     connect(homeButton,SIGNAL(released()),this,SLOT(homeButtonPushed()) );
     layout->addMultiCellWidget( homeButton, 0, 0, 4, 4);
      homeButton->hide();
 
     TabWidget = new QTabWidget( this, "TabWidget" );
     layout->addMultiCellWidget( TabWidget, 1, 1, 0, 4 );
 
 //     TabWidget->setTabShape(QTabWidget::Triangular);
 
     tab = new QWidget( TabWidget, "tab" );
     tabLayout = new QGridLayout( tab );
     tabLayout->setSpacing( 2);
     tabLayout->setMargin( 2);
 
     Local_View = new QListView( tab, "Local_View" );
 //    Local_View->setResizePolicy( QListView::AutoOneFit );
     Local_View->addColumn( tr("File"),150);
     Local_View->addColumn( tr("Date"),-1);
     Local_View->setColumnAlignment(1,QListView::AlignRight);
     Local_View->addColumn( tr("Size"),-1);
     Local_View->setColumnAlignment(2,QListView::AlignRight);
     Local_View->setAllColumnsShowFocus(TRUE);
 
     Local_View->setMultiSelection( TRUE);
     Local_View->setSelectionMode(QListView::Extended);
     Local_View->setFocusPolicy(QWidget::ClickFocus);
 
     QPEApplication::setStylusOperation( Local_View->viewport(),QPEApplication::RightOnHold);
 
     tabLayout->addWidget( Local_View, 0, 0 );
 
      connect( Local_View, SIGNAL( clicked( QListViewItem*)),
               this,SLOT( localListClicked(QListViewItem *)) );
 //     connect( Local_View, SIGNAL( doubleClicked( QListViewItem*)),
 //              this,SLOT( localListClicked(QListViewItem *)) );
      connect( Local_View, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
               this,SLOT( ListPressed(int, QListViewItem *, const QPoint&, int)) );
 
     TabWidget->insertTab( tab, tr( "Local" ) );
 
     tab_2 = new QWidget( TabWidget, "tab_2" );
     tabLayout_2 = new QGridLayout( tab_2 );
     tabLayout_2->setSpacing( 2);
     tabLayout_2->setMargin( 2);
 
     Remote_View = new QListView( tab_2, "Remote_View" );
     Remote_View->addColumn( tr("File"),150);
     Remote_View->addColumn( tr("Date"),-1);
 //    Remote_View->setColumnAlignment(1,QListView::AlignRight);
     Remote_View->addColumn( tr("Size"),-1);
     Remote_View->setColumnAlignment(2,QListView::AlignRight);
     Remote_View->setColumnAlignment(3,QListView::AlignCenter);
     Remote_View->addColumn( tr("Dir"),-1);
     Remote_View->setColumnAlignment(4,QListView::AlignRight);
     Remote_View->setAllColumnsShowFocus(TRUE);
 
     Remote_View->setMultiSelection( FALSE);
     Remote_View->setSelectionMode(QListView::Extended);
     Remote_View->setFocusPolicy(QWidget::ClickFocus);
 
     QPEApplication::setStylusOperation( Remote_View->viewport(),QPEApplication::RightOnHold);
 
     connect( Remote_View, SIGNAL( clicked( QListViewItem*)),
              this,SLOT( remoteListClicked(QListViewItem *)) );
     connect( Remote_View, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
              this,SLOT( RemoteListPressed(int, QListViewItem *, const QPoint&, int)) );
 
     tabLayout_2->addWidget( Remote_View, 0, 0 );
 
     TabWidget->insertTab( tab_2, tr( "Remote" ) );
 
     tab_3 = new QWidget( TabWidget, "tab_3" );
     tabLayout_3 = new QGridLayout( tab_3 );
     tabLayout_3->setSpacing( 2);
     tabLayout_3->setMargin( 2);
 
     TextLabel1 = new QLabel( tab_3, "TextLabel1" );
     TextLabel1->setText( tr( "Username" ) );
     tabLayout_3->addMultiCellWidget( TextLabel1, 0, 0, 0, 1 );
 
     UsernameComboBox = new QComboBox( FALSE, tab_3, "UsernameComboBox" );
     UsernameComboBox->setEditable(TRUE);
     tabLayout_3->addMultiCellWidget( UsernameComboBox, 1, 1, 0, 1 );
 
     connect( UsernameComboBox,SIGNAL(textChanged(const QString &)),this,
              SLOT( UsernameComboBoxEdited(const QString & ) ));
 
     TextLabel2 = new QLabel( tab_3, "TextLabel2" );
     TextLabel2->setText( tr( "Password" ) );
     tabLayout_3->addMultiCellWidget( TextLabel2, 0, 0, 2, 3 );
 
     PasswordEdit = new QLineEdit( "", tab_3, "PasswordComboBox" );
     PasswordEdit->setEchoMode(QLineEdit::Password);
     tabLayout_3->addMultiCellWidget( PasswordEdit, 1, 1, 2, 3 );
 
     connect( PasswordEdit,SIGNAL(textChanged(const QString &)),this,
              SLOT( PasswordEditEdited(const QString & ) ));
 
 //PasswordEdit->setFixedWidth(85);
     TextLabel3 = new QLabel( tab_3, "TextLabel3" );
     TextLabel3->setText( tr( "Remote server" ) );
     tabLayout_3->addMultiCellWidget( TextLabel3, 2, 2, 0, 1 );
 
     ServerComboBox = new QComboBox( FALSE, tab_3, "ServerComboBox" );
     ServerComboBox->setEditable(TRUE);
     tabLayout_3->addMultiCellWidget( ServerComboBox, 3, 3, 0, 1 );
 
     connect(ServerComboBox,SIGNAL(activated(int)),this,SLOT(serverComboSelected(int ) ));
     connect(ServerComboBox,SIGNAL(textChanged(const QString &)),this,
             SLOT(serverComboEdited(const QString & ) ));
 
     QLabel *TextLabel5 = new QLabel( tab_3, "TextLabel5" );
     TextLabel5->setText( tr( "Remote path" ) );
     tabLayout_3->addMultiCellWidget( TextLabel5, 2, 2, 2, 3 );
 
 
     remotePath = new QLineEdit( "/", tab_3, "remotePath" );
     tabLayout_3->addMultiCellWidget( remotePath, 3, 3, 2, 3 );
     TextLabel4 = new QLabel( tab_3, "TextLabel4" );
     TextLabel4->setText( tr( "Port" ) );
     tabLayout_3->addMultiCellWidget( TextLabel4, 4, 4, 0, 1 );
 
     PortSpinBox = new QSpinBox( tab_3, "PortSpinBox" );
     PortSpinBox->setButtonSymbols( QSpinBox::UpDownArrows );
     PortSpinBox->setMaxValue(32786);
     tabLayout_3->addMultiCellWidget( PortSpinBox, 4, 4, 1, 1);
 
     serverListView = new QListBox( tab_3, "ServerListView" );
     tabLayout_3->addMultiCellWidget( serverListView , 5, 5, 0, 5);
 
     connect( serverListView, SIGNAL( highlighted( const QString &)),
              this,SLOT( serverListClicked( const QString &) ) );
   
     connectServerBtn = new QPushButton( "Connect", tab_3 , "ConnectButton" );
     tabLayout_3->addMultiCellWidget( connectServerBtn, 6, 6, 0, 1);
     connectServerBtn->setToggleButton(TRUE);
     connect(connectServerBtn,SIGNAL( toggled( bool)),SLOT( connectorBtnToggled(bool) ));
 
     newServerButton= new QPushButton( "Add", tab_3 , "NewServerButton" );
     tabLayout_3->addMultiCellWidget( newServerButton, 6, 6, 2, 2);
     connect( newServerButton,SIGNAL( clicked()),SLOT( NewServer() ));
 
     QPushButton *deleteServerBtn;
     deleteServerBtn = new QPushButton( "Delete", tab_3 , "OpenButton" );
     tabLayout_3->addMultiCellWidget( deleteServerBtn, 6, 6, 3, 3);
 
     connect(deleteServerBtn,SIGNAL(clicked()),SLOT(deleteServer()));
 
 
     QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding );
     tabLayout_3->addItem( spacer, 5, 0 );
 
     TabWidget->insertTab( tab_3, tr( "Config" ) );
 
     connect(TabWidget,SIGNAL(currentChanged(QWidget *)),
             this,SLOT(tabChanged(QWidget*)));
 
     currentDir.setFilter( QDir::Files | QDir::Dirs/* | QDir::Hidden*/ | QDir::All);
     currentDir.setPath( QDir::currentDirPath());
 //      currentDir.setSorting(/* QDir::Size*/ /*| QDir::Reversed | */QDir::DirsFirst);
 
     currentPathCombo = new QComboBox( FALSE, this, "currentPathCombo" );
     layout->addMultiCellWidget( currentPathCombo, 3, 3, 0, 4);
    currentPathCombo ->setFixedWidth(220);
     currentPathCombo->setEditable(TRUE);
     currentPathCombo->lineEdit()->setText( currentDir.canonicalPath());
 
     connect( currentPathCombo, SIGNAL( activated( const QString & ) ),
               this, SLOT(  currentPathComboActivated( const QString & ) ) );
 
     connect( currentPathCombo->lineEdit(),SIGNAL(returnPressed()),
              this,SLOT(currentPathComboChanged()));
 
     ProgressBar = new QProgressBar( this, "ProgressBar" );
     layout->addMultiCellWidget( ProgressBar, 4, 4, 0, 4);
     ProgressBar->setMaximumHeight(10);
     filterStr="*";
     b=FALSE;
     populateLocalView();
     readConfig();
 
 //    ServerComboBox->setCurrentItem(currentServerConfig);
     
     TabWidget->setCurrentPage(2);
 }
 
 OpieFtp::~OpieFtp()
 {
 }
 
 void OpieFtp::cleanUp()
 {
     if(conn)
         FtpQuit(conn);
     QString sfile=QDir::homeDirPath();
     if(sfile.right(1) != "/")
         sfile+="/._temp";
     else
         sfile+="._temp";
     QFile file( sfile);
     if(file.exists())
         file.remove();
     Config cfg("opieftp");
     cfg.setGroup("Server");
     cfg.writeEntry("currentServer", currentServerConfig);
 
     exit(0);
 }
 
 void OpieFtp::tabChanged(QWidget *)
 {
     if (TabWidget->currentPageIndex() == 0) {
         currentPathCombo->lineEdit()->setText( currentDir.canonicalPath());
         tabMenu->setItemChecked(tabMenu->idAt(0),TRUE);
         tabMenu->setItemChecked(tabMenu->idAt(1),FALSE);
         tabMenu->setItemChecked(tabMenu->idAt(2),FALSE);
         if(cdUpButton->isHidden())
             cdUpButton->show();
         if(homeButton->isHidden())
             homeButton->show();
             
     }
     if (TabWidget->currentPageIndex() == 1) {
         currentPathCombo->lineEdit()->setText( currentRemoteDir );
         tabMenu->setItemChecked(tabMenu->idAt(1),TRUE);
         tabMenu->setItemChecked(tabMenu->idAt(0),FALSE);
         tabMenu->setItemChecked(tabMenu->idAt(2),FALSE);
         if(cdUpButton->isHidden())
             cdUpButton->show();
         homeButton->hide();
 
     }
     if (TabWidget->currentPageIndex() == 2) {
         tabMenu->setItemChecked(tabMenu->idAt(2),TRUE);
         tabMenu->setItemChecked(tabMenu->idAt(0),FALSE);
         tabMenu->setItemChecked(tabMenu->idAt(1),FALSE);
         cdUpButton->hide();
         homeButton->hide();
     }
 }
 
 void OpieFtp::newConnection()
 {
    UsernameComboBox->lineEdit()->setText("");
    PasswordEdit->setText( "" );
    ServerComboBox->lineEdit()->setText( "");
    remotePath->setText( currentRemoteDir = "/");
    PortSpinBox->setValue( 21);
    TabWidget->setCurrentPage(2);
 }
 
 void OpieFtp::serverComboEdited(const QString & )
 {
 //   if(  ServerComboBox->text(currentServerConfig) != edit /*edit.isEmpty() */) {
 //       qDebug("ServerComboEdited");
 //  //        currentServerConfig = -1;
 //      }
 }
 
 void OpieFtp::UsernameComboBoxEdited(const QString &) {
 //        currentServerConfig = -1;
 }
 
 void OpieFtp::PasswordEditEdited(const QString & ) {
 //        currentServerConfig = -1;
 }
 
 void OpieFtp::connectorBtnToggled(bool On)
 {
     if(On) {
         connector();
     } else {
         disConnector();
     }
 
 }
 
 void OpieFtp::connector()
 {
 //    QCopEnvelope ( "QPE/System", "busy()" );
 //    qApp->processEvents();
     currentRemoteDir=remotePath->text();
 
     if( ServerComboBox->currentText().isEmpty()) {
 
         QMessageBox::warning(this,tr("Ftp"),tr("Please set the server info"),tr("Ok"),0,0);
         TabWidget->setCurrentPage(2);
         ServerComboBox->setFocus();
         connectServerBtn->setOn(FALSE);
         connectServerBtn->setText( tr("Connect"));
         return;
     }
 
     FtpInit();
 
     TabWidget->setCurrentPage(1);
     QString ftp_host = ServerComboBox->currentText();
     QString ftp_user = UsernameComboBox->currentText();
     QString ftp_pass = PasswordEdit->text();
     QString port=PortSpinBox->cleanText();
     port.stripWhiteSpace();
 
     Config cfg("opieftp");
     cfg.setGroup("Server");
 //    int current=cfg.readNumEntry("currentServer", 1);
 
 //      if(ftp_host!= cfg.readEntry(QString::number( current)))
 //         currentServerConfig=-1;
 //      cfg.setGroup(QString::number(current));
 //      if( ftp_user != cfg.readEntry("Username"))
 //         currentServerConfig=-1;
 //      if(ftp_pass != cfg.readEntry(cfg.readEntry("Username")))
 //         currentServerConfig=-1;    
 
 
     if(ftp_host.find("ftp://",0, TRUE) != -1 )
         ftp_host=ftp_host.right(ftp_host.length()-6);
     ftp_host+=":"+port;
 
     if (!FtpConnect( ftp_host.latin1(), &conn)) {
         QMessageBox::message(tr("Note"),tr("Unable to connect to\n")+ftp_host);
         connectServerBtn->setOn(FALSE);
         connectServerBtn->setText( tr("Connect"));
         return ;
     }
 
     if (!FtpLogin( ftp_user.latin1(), ftp_pass.latin1(),conn )) {
         QString msg;
         msg.sprintf(tr("Unable to log in\n")+"%s",FtpLastResponse(conn));
         msg.replace(QRegExp(":"),"\n");
         QMessageBox::message(tr("Note"),msg);
         if(conn)
             FtpQuit(conn);
         connectServerBtn->setOn(FALSE);
         connectServerBtn->setText( tr("Connect"));
         return ;
     }
 
     remoteDirList("/") ;
     setCaption(ftp_host);
    if( currentServerConfig == -1)
         writeConfig();
     connectServerBtn->setText( tr("Disconnect"));
 //     QCopEnvelope ( "QPE/System", "notBusy()" );
 }
 
 void OpieFtp::disConnector()
 {
     if(conn)
         FtpQuit(conn);
     setCaption("OpieFtp");
     currentRemoteDir="/";
     Remote_View->clear();
     connectServerBtn->setText( tr("Connect"));
     connectServerBtn->setOn(FALSE);
     setCaption("OpieFtp");
 }
 
 void OpieFtp::localUpload()
 {
     int fsz;
 //    QCopEnvelope ( "QPE/System", "busy()" );
 //    qApp->processEvents();
     QList<QListViewItem> * getSelectedItems( QListView * Local_View );
     QListViewItemIterator it( Local_View );
     for ( ; it.current(); ++it ) {
         if ( it.current()->isSelected() ) {
             QString strItem = it.current()->text(0);
             QString localFile = currentDir.canonicalPath()+"/"+strItem;
             QString remoteFile= currentRemoteDir+strItem;
             QFileInfo fi(localFile);
             if( !fi.isDir()) {
                 fsz=fi.size();
                 ProgressBar->setTotalSteps(fsz);
 
                 FtpOptions(FTPLIB_CALLBACK, (long) log_progress, conn);
                 FtpOptions(FTPLIB_IDLETIME, (long) 1000, conn);
                 FtpOptions(FTPLIB_CALLBACKARG, (long) &fsz, conn);
                 FtpOptions(FTPLIB_CALLBACKBYTES, (long) fsz/10, conn);
                 qDebug("Put: %s, %s",localFile.latin1(),remoteFile.latin1());
 
                 if( !FtpPut( localFile.latin1(), remoteFile.latin1(),FTPLIB_IMAGE, conn ) ) {
                     QString msg;
                     msg.sprintf(tr("Unable to upload\n")+"%s",FtpLastResponse(conn));
                     msg.replace(QRegExp(":"),"\n");
                     QMessageBox::message(tr("Note"),msg);
                 }
             } else {
                 QMessageBox::message(tr("Note"),tr("Cannot upload directories"));
             }
             ProgressBar->reset();
             nullifyCallBack();
         it.current()->setSelected(FALSE);
         } //end currentSelected
     }
     for ( ; it.current(); ++it ) {
         Local_View->clearSelection();
     }
     Local_View->clearFocus();
     TabWidget->setCurrentPage(1);
     remoteDirList( (const QString &)currentRemoteDir); //this also calls populate
 //    QCopEnvelope ( "QPE/System", "notBusy()" );
 }
 
 void OpieFtp::nullifyCallBack()
 {
         FtpOptions(FTPLIB_CALLBACK, 0, conn);
         FtpOptions(FTPLIB_IDLETIME, 0, conn);
         FtpOptions(FTPLIB_CALLBACKARG, 0, conn);
         FtpOptions(FTPLIB_CALLBACKBYTES, 0, conn);
 }
 
 void OpieFtp::remoteDownload()
 {
 //    qApp->processEvents();
     int fsz;
 //    QCopEnvelope ( "QPE/System", "busy()" );
 
     QList<QListViewItem> * getSelectedItems( QListView * Remote_View );
     QListViewItemIterator it( Remote_View );
     for ( ; it.current(); ++it ) {
         if ( it.current()->isSelected() ) {
             QString strItem = it.current()->text(0);
 //      strItem=strItem.right(strItem.length()-1);
             QString localFile = currentDir.canonicalPath();
             if(localFile.right(1).find("/",0,TRUE) == -1)
                 localFile += "/";
             localFile += strItem;
 //    QString localFile = currentDir.canonicalPath()+"/"+strItem;
             QString remoteFile= currentRemoteDir+strItem;
             if (!FtpSize( remoteFile.latin1(), &fsz, FTPLIB_ASCII, conn))
                 fsz = 0;
             QString temp;
             temp.sprintf( remoteFile+" "+" %dkb", fsz);
 
             ProgressBar->setTotalSteps(fsz);
             FtpOptions(FTPLIB_CALLBACK, (long) log_progress, conn);
             FtpOptions(FTPLIB_IDLETIME, (long) 1000, conn);
             FtpOptions(FTPLIB_CALLBACKARG, (long) &fsz, conn);
             FtpOptions(FTPLIB_CALLBACKBYTES, (long) fsz/10, conn);
             qDebug("Get: %s, %s",localFile.latin1(),remoteFile.latin1());
 
             if(!FtpGet( localFile.latin1(), remoteFile.latin1(),FTPLIB_IMAGE, conn ) ) {
                 QString msg;
                 msg.sprintf(tr("Unable to download \n")+"%s",FtpLastResponse(conn));
                 msg.replace(QRegExp(":"),"\n");
                 QMessageBox::message(tr("Note"),msg);
             }
             ProgressBar->reset();
             nullifyCallBack();
         it.current()->setSelected(FALSE);
         }
     }
     for ( ; it.current(); ++it ) {
         Remote_View->clearSelection();
     }
     Remote_View->setFocus();    
     TabWidget->setCurrentPage(0);
     populateLocalView();
 //    QCopEnvelope ( "QPE/System", "notBusy()" );
 }
 
 bool OpieFtp::remoteDirList(const QString &dir)
 {
     QString tmp = QDir::homeDirPath();
     if(tmp.right(1) != "/")
         tmp+="/._temp";
     else
         tmp+="._temp";
 //    qDebug("Listing remote dir "+tmp);
 //    QCopEnvelope ( "QPE/System", "busy()" );
     if (!FtpDir( tmp.latin1(), dir.latin1(), conn) ) {
         QString msg;
         msg.sprintf(tr("Unable to list the directory\n")+dir+"\n%s",FtpLastResponse(conn) );
         msg.replace(QRegExp(":"),"\n");
         QMessageBox::message(tr("Note"),msg);
         return false;
     }
     populateRemoteView() ;
 //    QCopEnvelope ( "QPE/System", "notBusy()" );
     return true;
 }
 
 bool OpieFtp::remoteChDir(const QString &dir)
 {
 //    QCopEnvelope ( "QPE/System", "busy()" );
     if (!FtpChdir( dir.latin1(), conn )) {
         QString msg;
         msg.sprintf(tr("Unable to change directories\n")+dir+"\n%s",FtpLastResponse(conn));
         msg.replace(QRegExp(":"),"\n");
         QMessageBox::message(tr("Note"),msg);
 //        qDebug(msg);
 //        QCopEnvelope ( "QPE/System", "notBusy()" );
         return FALSE;
     }
 //    QCopEnvelope ( "QPE/System", "notBusy()" );
     return TRUE;
 }
 
 void OpieFtp::populateLocalView()
 {
     Local_View->clear();
     currentDir.setSorting(/* QDir::Size*/ /*| QDir::Reversed | */QDir::DirsFirst);
     currentDir.setMatchAllDirs(TRUE);
     currentDir.setNameFilter(filterStr);
     QString fileL, fileS, fileDate;
     bool isDir=FALSE;
     const QFileInfoList *list = currentDir.entryInfoList( /*QDir::All*/ /*, QDir::SortByMask*/);
     QFileInfoListIterator it(*list);
     QFileInfo *fi;
     while ( (fi=it.current()) ) {
         if (fi->isSymLink() ){
             QString symLink=fi->readLink();
 //         qDebug("Symlink detected "+symLink);
             QFileInfo sym( symLink);
             fileS.sprintf( "%10i", sym.size() );
             fileL.sprintf( "%s ->  %s",  fi->fileName().data(),sym.absFilePath().data() );
             fileDate = sym.lastModified().toString();
         } else {
 //        qDebug("Not a dir: "+currentDir.canonicalPath()+fileL);
             fileS.sprintf( "%10i", fi->size() );
             fileL.sprintf( "%s",fi->fileName().data() );
             fileDate= fi->lastModified().toString();
             if( QDir(QDir::cleanDirPath(currentDir.canonicalPath()+"/"+fileL)).exists() ) {
                 fileL+="/";
                 isDir=TRUE;
 //     qDebug( fileL);
             }
         }
         if(fileL !="./" && fi->exists()) {
             item = new QListViewItem( Local_View,fileL, fileDate, fileS );
             QPixmap pm;
          
             if(isDir || fileL.find("/",0,TRUE) != -1) {
                 if( !QDir( fi->filePath() ).isReadable())
                     pm = Resource::loadPixmap( "lockedfolder" );
                 else
                     pm= Resource::loadPixmap( "folder" );
                 item->setPixmap( 0,pm );
             } else {
                 if( !fi->isReadable() )
                     pm = Resource::loadPixmap( "locked" );
                 else {
                     MimeType mt(fi->filePath());
                     pm=mt.pixmap(); //sets the correct pixmap for mimetype
                     if(pm.isNull())
                         pm =  Resource::loadPixmap( "UnknownDocument-14" );
                     item->setPixmap( 0,pm);
                 }
             }
             if(  fileL.find("->",0,TRUE) != -1) {
                   // overlay link image
                 pm= Resource::loadPixmap( "folder" );
                 QPixmap lnk = Resource::loadPixmap( "opie/symlink" );
                 QPainter painter( &pm );
                 painter.drawPixmap( pm.width()-lnk.width(), pm.height()-lnk.height(), lnk );
                 pm.setMask( pm.createHeuristicMask( FALSE ) );
                 item->setPixmap( 0, pm);
             }
         }
         isDir=FALSE;
         ++it;
     }
     Local_View->setSorting( 3,FALSE);
     currentPathCombo->lineEdit()->setText( currentDir.canonicalPath() );
     fillCombo( (const QString &)currentDir);
 }
 
 bool OpieFtp::populateRemoteView( )
 {
 //    qDebug("populate remoteview");
     QString sfile=QDir::homeDirPath();
     if(sfile.right(1) != "/")
         sfile+="/._temp";
     else
         sfile+="._temp";
     QFile file( sfile);
     Remote_View->clear();
     QString s, File_Name;
     QListViewItem *itemDir=NULL, *itemFile=NULL;
     QRegExp monthRe(" [JFMASOND][eapuecoe][brynlgptvc] [ 0-9][0-9] [ 0-9][0-9][:0-9][0-9][0-9] ");
     QString fileL, fileS, fileDate;
     if ( file.open(IO_ReadOnly)) {
         QTextStream t( &file );   // use a text stream
         while ( !t.eof()) {
             s = t.readLine();
 
             if(s.find("total",0,TRUE) == 0)
                continue;
 
            int len, month = monthRe.match(s, 0, &len);
            fileDate = s.mid(month + 1, len - 2);       // minus spaces
            fileL = s.right(s.length() - month - len);
             if(s.left(1) == "d") 
                 fileL = fileL+"/";
             fileS = s.mid(month - 8, 8);  // FIXME
             fileS = fileS.stripWhiteSpace();
 
            if(s.left(1) == "d" || fileL.find("/",0,TRUE) != -1) {
                QListViewItem * item = new QListViewItem( Remote_View, fileL, fileDate, fileS,"d");
                item->setPixmap( 0, Resource::loadPixmap( "folder" ));
 //                      if(itemDir)
                      item->moveItem(itemDir);
                  itemDir=item;
            } else {
                QListViewItem * item = new QListViewItem( Remote_View, fileL, fileDate, fileS,"f");
                item->setPixmap( 0, Resource::loadPixmap( "fileopen" ));
 //                      if(itemFile)
                      item->moveItem(itemDir);
                      item->moveItem(itemFile);
                  itemFile=item;
            }
         }
         QListViewItem * item1 = new QListViewItem( Remote_View, "../");
         item1->setPixmap( 0, Resource::loadPixmap( "folder" ));
         file.close();
         if( file.exists())
             file. remove();
     } else
         qDebug("temp file not opened successfullly "+sfile);
     Remote_View->setSorting( 4,TRUE);
     return true;
 }
 
 void OpieFtp::remoteListClicked(QListViewItem *selectedItem)
 {
     if( selectedItem) {
 //         QCopEnvelope ( "QPE/System", "busy()" );
         QString  oldRemoteCurrentDir =  currentRemoteDir;
         QString strItem=selectedItem->text(0);
         strItem=strItem.simplifyWhiteSpace();
         if(strItem == "../") { // the user wants to go ^
             if( FtpCDUp( conn) == 0) {
                 QString msg;
                 msg.sprintf(tr("Unable to cd up\n")+"%s",FtpLastResponse(conn));
                 msg.replace(QRegExp(":"),"\n");
                 QMessageBox::message(tr("Note"),msg);
 //                qDebug(msg);
             }
             char path[256];
             if( FtpPwd( path,sizeof(path),conn) == 0) { //this is easier than fudging the string
                 QString msg;
                 msg.sprintf(tr("Unable to get working dir\n")+"%s",FtpLastResponse(conn));
                 msg.replace(QRegExp(":"),"\n");
                 QMessageBox::message(tr("Note"),msg);
 //                qDebug(msg);
             }
             currentRemoteDir=path;
         } else {
             if(strItem.find("->",0,TRUE) != -1) { //symlink on some servers
                 strItem=strItem.right( strItem.length() - strItem.find("->",0,TRUE) - 2 );
                 strItem = strItem.stripWhiteSpace();
                 currentRemoteDir = strItem;
                 if( !remoteChDir( (const QString &)strItem)) {
                     currentRemoteDir = oldRemoteCurrentDir;
                     strItem="";
 //                     qDebug("RemoteCurrentDir1 "+oldRemoteCurrentDir);
                 }
             } else if(strItem.find("/",0,TRUE) != -1) { // this is a directory
                 if( !remoteChDir( (const QString &)currentRemoteDir + strItem)) {
                     currentRemoteDir = oldRemoteCurrentDir;
                     strItem="";
 //                     qDebug("RemoteCurrentDir1 "+oldRemoteCurrentDir);
 
                 } else {
                     currentRemoteDir = currentRemoteDir+strItem;
                 }
             } else {
 //                QCopEnvelope ( "QPE/System", "notBusy()" );
                 return;
             }
         }
         remoteDirList( (const QString &)currentRemoteDir); //this also calls populate
         if(currentRemoteDir.right(1) !="/")
             currentRemoteDir +="/";
         currentPathCombo->lineEdit()->setText( currentRemoteDir);
         fillRemoteCombo( (const QString &)currentRemoteDir);
 //        QCopEnvelope ( "QPE/System", "notBusy()" );
     Remote_View->ensureItemVisible(Remote_View->firstChild());    
         
     }
 }
 
 void OpieFtp::localListClicked(QListViewItem *selectedItem)
 {
     if(selectedItem!= NULL) {
     
     QString strItem=selectedItem->text(0);
         QString strSize=selectedItem->text(1);
         strSize=strSize.stripWhiteSpace();
         if(strItem.find("@",0,TRUE) !=-1 || strItem.find("->",0,TRUE) !=-1 ) { //if symlink
               // is symlink
             QString strItem2 = strItem.right( (strItem.length() - strItem.find("->",0,TRUE)) - 4);
             if(QDir(strItem2).exists() ) {
                 currentDir.cd(strItem2, TRUE);
                 populateLocalView();
             }
         } else { // not a symlink
             if(strItem.find(". .",0,TRUE) && strItem.find("/",0,TRUE)!=-1 ) {
                 
                 if(QDir(QDir::cleanDirPath(currentDir.canonicalPath()+"/"+strItem)).exists() ) {
                     strItem=QDir::cleanDirPath(currentDir.canonicalPath()+"/"+strItem);
                     currentDir.cd(strItem,FALSE);
                     populateLocalView();
                 } else {
                     currentDir.cdUp();
                     populateLocalView();
                 }
                 if(QDir(strItem).exists()){
                     currentDir.cd(strItem, TRUE);
                     populateLocalView();
                 }
             } else {
                 strItem=QDir::cleanDirPath(currentDir.canonicalPath()+"/"+strItem);
                 if( QFile::exists(strItem ) ) {
                       //  qDebug("upload "+strItem);
                     return;
                 }
             } //end not symlink
             chdir(strItem.latin1());
         }
     Local_View->ensureItemVisible(Local_View->firstChild());    
     }
 }
 
 void OpieFtp::doLocalCd()
 {
     localListClicked( Local_View->currentItem());
 }
 
 void OpieFtp:: doRemoteCd()
 {
     remoteListClicked( Remote_View->currentItem());
 
 }
 
 void OpieFtp::showHidden()
 {
     if (!b) {
     currentDir.setFilter( QDir::Files | QDir::Dirs | QDir::Hidden | QDir::All);
     localMenu->setItemChecked(localMenu->idAt(0),TRUE);
 //    currentDir.setSorting(/* QDir::Size*/ /*| QDir::Reversed | */QDir::DirsFirst);
     b=TRUE;
 
     }  else {
     currentDir.setFilter( QDir::Files | QDir::Dirs/* | QDir::Hidden*/ | QDir::All);
     localMenu->setItemChecked(localMenu->idAt(0),FALSE);
 //    currentDir.setSorting(/* QDir::Size*/ /*| QDir::Reversed | */QDir::DirsFirst);
     b=FALSE;
     }
     populateLocalView();
 }
 
 void OpieFtp::ListPressed( int mouse, QListViewItem *item, const QPoint &, int)
 {
 // if(item)
     if (mouse == 2) {
         showLocalMenu(item);
     }
 }
 
 void OpieFtp::RemoteListPressed( int mouse, QListViewItem *item, const QPoint &, int )
 {
     if(mouse == 2) {
         showRemoteMenu(item);
     }
 }
 
 void OpieFtp::showRemoteMenu(QListViewItem * item)
 {
     QPopupMenu * m;// = new QPopupMenu( Local_View );
     m = new QPopupMenu(this);
     if( /*item->text(0).right(1) == "/" ||*/ item->text(0).find("/",0,TRUE) != -1)
         m->insertItem( tr( "Change Directory" ), this, SLOT( doRemoteCd() ));
     else
     m->insertItem( tr( "Download" ), this, SLOT( remoteDownload() ));
     m->insertItem( tr( "Make Directory" ), this, SLOT( remoteMakDir() ));
     m->insertItem( tr("Rescan"), this, SLOT( populateLocalView() ));
     m->insertItem( tr( "Rename" ), this, SLOT( remoteRename() ));
     m->insertSeparator();
     m->insertItem( tr( "Delete" ), this, SLOT( remoteDelete() ));
     m->exec( QCursor::pos() );
     delete m;
 }
 
 void OpieFtp::showLocalMenu(QListViewItem * item)
 {
 
  QPopupMenu  *m;
  m = new QPopupMenu( this);
     m->insertItem(  tr( "Show Hidden Files" ), this,  SLOT( showHidden() ));
     m->insertSeparator();
     if( /*item->text(0).right(1) == "/" ||*/ item->text(0).find("/",0,TRUE) !=-1)
     m->insertItem( tr( "Change Directory" ), this, SLOT( doLocalCd() ));
     else
     m->insertItem( tr( "Upload" ), this, SLOT( localUpload() ));
     m->insertItem( tr( "Make Directory" ), this, SLOT( localMakDir() ));
     m->insertItem( tr("Rescan"), this, SLOT( populateRemoteView() ));
     m->insertItem( tr( "Rename" ), this, SLOT( localRename() ));
     m->insertSeparator();
     m->insertItem( tr( "Delete" ), this, SLOT( localDelete() ));
     m->setCheckable(TRUE);
     if (b)
         m->setItemChecked(m->idAt(0),TRUE);
     else
         m->setItemChecked(m->idAt(0),FALSE);
 
     m->exec( QCursor::pos() );
     delete m;
 }
 
 void OpieFtp::localMakDir()
 {
     InputDialog *fileDlg;
     fileDlg = new InputDialog(this,tr("Make Directory"),TRUE, 0);
     fileDlg->exec();
     if( fileDlg->result() == 1 ) {
        QString  filename = fileDlg->LineEdit1->text();
        currentDir.mkdir( currentDir.canonicalPath()+"/"+filename);
     }
     populateLocalView();
 }
 
 void OpieFtp::localDelete()
 {
     QList<QListViewItem> * getSelectedItems( QListView * Local_View );
     QListViewItemIterator it( Local_View );
     for ( ; it.current(); ++it ) {
         if ( it.current()->isSelected() ) {
             QString f = it.current()->text(0);
             it.current()->setSelected(FALSE);
             
 //    QString f = Local_View->currentItem()->text(0);
             if(QDir(f).exists() ) {
                 switch ( QMessageBox::warning(this,tr("Delete"),tr("Do you really want to delete\n")+f+
                                               tr(" ?\nIt must be empty"),tr("Yes"),tr("No"),0,0,1) ) {
                   case 0: {
                       f=currentDir.canonicalPath()+"/"+f;
                       QString cmd="rmdir "+f;
                       system( cmd.latin1());
                   }
                       break;
                   case 1:
                         // exit
                       break;
                 };
 
             } else {
                 switch ( QMessageBox::warning(this,tr("Delete"),tr("Do you really want to delete\n")+f
                                               +" ?",tr("Yes"),tr("No"),0,0,1) ) {
                   case 0: {
                       f=currentDir.canonicalPath()+"/"+f;
                       QString cmd="rm "+f;
                       system( cmd.latin1());
                   }
                       break;
                   case 1: 
                         // exit
                       break;
                 };
             }
         }
     }
     populateLocalView();
     
 }
 
 void OpieFtp::remoteMakDir()
 {
     InputDialog *fileDlg;
     fileDlg = new InputDialog(this,tr("Make Directory"),TRUE, 0);
     fileDlg->exec();
     if( fileDlg->result() == 1 ) {
        QString  filename = fileDlg->LineEdit1->text();//+".playlist";
        QString tmp=currentRemoteDir+filename;
 //       QCopEnvelope ( "QPE/System", "busy()" );
        if(FtpMkdir( tmp.latin1(), conn) == 0) {
            QString msg;
            msg.sprintf(tr("Unable to make directory\n")+"%s",FtpLastResponse(conn));
            msg.replace(QRegExp(":"),"\n");
            QMessageBox::message(tr("Note"),msg);
        }
 //       QCopEnvelope ( "QPE/System", "notBusy()" );
     remoteDirList( (const QString &)currentRemoteDir); //this also calls populate
     }
 }
 
 void OpieFtp::remoteDelete()
 {
     QList<QListViewItem> * getSelectedItems( QListView * Remote_View );
     QListViewItemIterator it( Remote_View );
     for ( ; it.current(); ++it ) {
         if ( it.current()->isSelected() ) {
             QString f = it.current()->text(0);
 //    QString f = Remote_View->currentItem()->text(0);
 //            QCopEnvelope ( "QPE/System", "busy()" );
             if( f.right(1) =="/") {
                 QString path= currentRemoteDir+f;
                 switch ( QMessageBox::warning(this,tr("Delete"),tr("Do you really want to delete\n")+f+"?"
                                               ,tr("Yes"),tr("No"),0,0,1) ) {
                   case 0: {
                       f=currentDir.canonicalPath()+"/"+f;
                       if(FtpRmdir( path.latin1(), conn) ==0) {
                           QString msg;
                           msg.sprintf(tr("Unable to remove directory\n")+"%s",FtpLastResponse(conn));
                           msg.replace(QRegExp(":"),"\n");
                           QMessageBox::message(tr("Note"),msg);
                       }
                       remoteDirList( (const QString &)currentRemoteDir); //this also calls populate
                   }
                       break;
                 };
             } else {
                 switch ( QMessageBox::warning(this,tr("Delete"),tr("Do you really want to delete\n")+f+"?"
                                               ,tr("Yes"),tr("No"),0,0,1) ) {
                   case 0: {
                       QString path= currentRemoteDir+f;
                       if(FtpDelete( path.latin1(), conn)==0) {
                           QString msg;
                           msg.sprintf(tr("Unable to delete file\n")+"%s",FtpLastResponse(conn));
                           msg.replace(QRegExp(":"),"\n");
                           QMessageBox::message(tr("Note"),msg);
                       }
                       remoteDirList( (const QString &)currentRemoteDir); //this also calls populate
                   }
                       break;
                 };
             }
         }
     }
 //    QCopEnvelope ( "QPE/System", "notBusy()" );
 }
 
 void OpieFtp::remoteRename()
 {
     QString curFile = Remote_View->currentItem()->text(0);
     InputDialog *fileDlg;
     fileDlg = new InputDialog(this,tr("Rename"),TRUE, 0);
     fileDlg->setTextEdit((const QString &)curFile);
     fileDlg->exec();
     if( fileDlg->result() == 1 ) {
         QString oldName = currentRemoteDir +"/"+ curFile;
         QString newName = currentRemoteDir  +"/"+ fileDlg->LineEdit1->text();//+".playlist";
 //        QCopEnvelope ( "QPE/System", "busy()" );
         if(FtpRename( oldName.latin1(), newName.latin1(),conn) == 0) {
             QString msg;
             msg.sprintf(tr("Unable to rename file\n")+"%s",FtpLastResponse(conn));
             msg.replace(QRegExp(":"),"\n");
             QMessageBox::message(tr("Note"),msg);
         }
 //        QCopEnvelope ( "QPE/System", "notBusy()" );
     remoteDirList( (const QString &)currentRemoteDir); //this also calls populate
     }
 }
 
 void OpieFtp::localRename()
 {
     QString curFile = Local_View->currentItem()->text(0);
     InputDialog *fileDlg;
     fileDlg = new InputDialog(this,tr("Rename"),TRUE, 0);
     fileDlg->setTextEdit((const QString &)curFile);
     fileDlg->exec();
     if( fileDlg->result() == 1 ) {
         QString oldname =  currentDir.canonicalPath() + "/" + curFile;
         QString newName =  currentDir.canonicalPath() + "/" + fileDlg->LineEdit1->text();//+".playlist";
         if( rename(oldname.latin1(), newName.latin1())== -1)
             QMessageBox::message(tr("Note"),tr("Could not rename"));
     }
     populateLocalView();
 }
 
 void OpieFtp::currentPathComboActivated(const QString & currentPath) {
     if (TabWidget->currentPageIndex() == 0) {
     chdir( currentPath.latin1() );
     currentDir.cd( currentPath, TRUE);
     populateLocalView();
     update();
     } else {
 //     chdir( currentPath.latin1() );
 //     currentDir.cd( currentPath, TRUE);
 //     populateList();
 //     update();
 
     }
 }
 
 void OpieFtp::fillCombo(const QString &currentPath) {
 
         currentPathCombo->lineEdit()->setText(currentPath);
         if( localDirPathStringList.grep(currentPath,TRUE).isEmpty() ) {
             currentPathCombo->clear();
             localDirPathStringList.prepend(currentPath );
             currentPathCombo->insertStringList( localDirPathStringList,-1);
         }
         currentPathCombo->lineEdit()->setText(currentPath);
         if( remoteDirPathStringList.grep(currentPath,TRUE).isEmpty() ) {
             currentPathCombo->clear();
             remoteDirPathStringList.prepend(currentPath );
             currentPathCombo->insertStringList( remoteDirPathStringList,-1);
         }
 }
 
 void OpieFtp::fillRemoteCombo(const QString &currentPath) {
 
         currentPathCombo->lineEdit()->setText(currentPath);
         if( remoteDirPathStringList.grep(currentPath,TRUE).isEmpty() ) {
             currentPathCombo->clear();
             remoteDirPathStringList.prepend(currentPath );
             currentPathCombo->insertStringList( remoteDirPathStringList,-1);
         }
 }
 
 void OpieFtp::currentPathComboChanged()
 {
     QString  oldRemoteCurrentDir =  currentRemoteDir;
 //    qDebug("oldRemoteCurrentDir "+oldRemoteCurrentDir);
     if (TabWidget->currentPageIndex() == 0) {
         if(QDir( currentPathCombo->lineEdit()->text()).exists()) {
             currentDir.setPath( currentPathCombo->lineEdit()->text() );
             populateLocalView();
         } else {
             QMessageBox::message(tr("Note"),tr("That directory does not exist"));
         }
     }
     if (TabWidget->currentPageIndex() == 1) {
         currentRemoteDir = currentPathCombo->lineEdit()->text();
         if(currentRemoteDir.right(1) !="/") {
             currentRemoteDir = currentRemoteDir +"/";
             currentPathCombo->lineEdit()->setText( currentRemoteDir );
         }
             if( !remoteChDir( (const QString &)currentRemoteDir) ) {
                 currentRemoteDir = oldRemoteCurrentDir;
                 currentPathCombo->lineEdit()->setText( currentRemoteDir );
             }
 
         remoteDirList( (const QString &)currentRemoteDir);
     }
 }
 
 void OpieFtp::switchToLocalTab()
 {
     TabWidget->setCurrentPage(0);
 }
 
 void OpieFtp::switchToRemoteTab()
 {
     TabWidget->setCurrentPage(1);
 }
 
 void OpieFtp::switchToConfigTab()
 {
     TabWidget->setCurrentPage(2);
 }
 
 void OpieFtp::readConfig()
 {
     fillCombos();
     Config cfg("opieftp");
     cfg.setGroup("Server");
     currentServerConfig = cfg.readNumEntry("currentServer", -1);
     
 //    qDebug("Reading %d", currentServerConfig);
     serverComboSelected( currentServerConfig-1);
     
 }
 
 void OpieFtp::writeConfig()
 {
     qDebug("write config");
     Config cfg("opieftp");
     cfg.setGroup("Server");
 
     QString username, remoteServerStr, remotePathStr, password, port, temp;
 
     int numberOfEntries = cfg.readNumEntry("numberOfEntries",0);
 
     if( currentServerConfig == -1) {
 
         for (int i = 1; i <= numberOfEntries; i++) {
         temp.setNum(i);
         cfg.setGroup("Server");
         QString tempStr = cfg.readEntry( temp,"");
     }
 
         temp.setNum( numberOfEntries + 1);
         cfg.setGroup("Server");
 
         remoteServerStr = cfg.readEntry( temp,"");
 
         int divider = remoteServerStr.length() - remoteServerStr.find(":",0,TRUE);
         remoteServerStr = remoteServerStr.left(remoteServerStr.length()-divider);
 
         temp.setNum(numberOfEntries+1);
         cfg.setGroup("Server");
 
         cfg.writeEntry( temp, ServerComboBox->currentText() +":"+PortSpinBox->cleanText() );
         cfg.writeEntry("currentServer", numberOfEntries+1);
 
         currentServerConfig = numberOfEntries+1;
         qDebug("setting currentserverconfig to %d",        currentServerConfig);
 
         cfg.setGroup(temp);
         if(!newServerName.isEmpty())
             cfg.writeEntry("ServerName", newServerName);
 
         cfg.writeEntry("RemotePath", remotePath->text());
 
         cfg.writeEntry("Username", UsernameComboBox->currentText());
 
         cfg.writeEntryCrypt( UsernameComboBox->currentText(), PasswordEdit->text());
         cfg.setGroup("Server");
 
         cfg.writeEntry("numberOfEntries", QString::number(numberOfEntries + 1 ));
         
     }
 }
 
 void OpieFtp::clearCombos() {
     qDebug("clearing");
     ServerComboBox->clear();
     UsernameComboBox->clear();
     PasswordEdit->clear();
     serverListView->clear();
 }
 
 
 void OpieFtp::fillCombos()
 {
     clearCombos();
 
     Config cfg("opieftp");
     cfg.setGroup("Server");
     QString username, remoteServerStr, remotePathStr, password, port, temp;
     int numberOfEntries = cfg.readNumEntry("numberOfEntries",0);
 
     for (int i = 1; i <= numberOfEntries; i++) {
         temp.setNum(i);
         qDebug(temp);
         cfg.setGroup("Server");
         remoteServerStr = cfg.readEntry( temp,"");
         qDebug( remoteServerStr);
 
         int divider = remoteServerStr.length() - remoteServerStr.find(":",0,TRUE);
         port = remoteServerStr.right( divider - 1);
         bool ok;
         PortSpinBox->setValue( port.toInt(&ok,10));
 
         remoteServerStr = remoteServerStr.left(remoteServerStr.length()-divider);
         qDebug( "remote server string "+remoteServerStr);
         ServerComboBox->insertItem( remoteServerStr );
 
         cfg.setGroup(temp);
 
         username = cfg.readEntry(temp);
         UsernameComboBox->insertItem(username);
         password = cfg.readEntryCrypt(username,"");
         PasswordEdit->setText(password);
 
         serverListView->insertItem( cfg.readEntry("ServerName"));
     }
 }
 
 
 void OpieFtp::serverComboSelected(int index)
 {
     currentServerConfig = index+1;
     qDebug("server combo selected %d", index+1);
     QString username, remoteServerStr, remotePathStr, password, port, temp;
 //    remoteServerStr = ServerComboBox->text(index);
 
     Config cfg("opieftp");
     cfg.setGroup("Server");
 //    int numberOfEntries = cfg.readNumEntry("numberOfEntries",0);
 
     temp.setNum(index+1);
     remoteServerStr = cfg.readEntry( temp,"");
 
     qDebug("Group" +temp);
     cfg.setGroup(temp);
 //    qDebug(temp);
     int divider = remoteServerStr.length() - remoteServerStr.find(":",0,TRUE);
     port = remoteServerStr.right( divider - 1);
     bool ok;
     int portInt = port.toInt(&ok,10);
     if( portInt == 0) portInt = 21;
     
     ServerComboBox->lineEdit()->setText(remoteServerStr.left( remoteServerStr.find(":",0,TRUE)));
     
     PortSpinBox->setValue( portInt);
 
     remotePath->setText(cfg.readEntry("RemotePath", "/"));
 
     username =  cfg.readEntry("Username", "anonymous");
     UsernameComboBox->lineEdit()->setText(username);
     qDebug(username);
 //    qDebug("Password is "+cfg.readEntryCrypt(username, "me@opieftp.org"));
     PasswordEdit->setText(cfg.readEntryCrypt(username, "me@opieftp.org"));
 //   UsernameComboBox
 //        PasswordEdit
      
     cfg.setGroup("Server");
     temp.sprintf("%d",currentServerConfig);
     cfg.writeEntry("currentServer", temp);
 
    fuckeduphack = TRUE;
    serverListView->setCurrentItem( index);
    fuckeduphack=FALSE;
    qDebug("server list set selected %d",index);
     update();
 }
 
 void OpieFtp::deleteServer()
 {
     QString username, remoteServerStr, remotePathStr, password, port, temp, servername;
     remoteServerStr = ServerComboBox->currentText( );
     username = UsernameComboBox->currentText();
     servername=serverListView->currentText();
     
     Config cfg("opieftp");
     cfg.setGroup("Server");
     QString tempname;
     int numberOfEntries = cfg.readNumEntry("numberOfEntries",0);
 
     for (int i = 1; i <= numberOfEntries; i++) {
         temp.setNum(i);
 //        cfg.setGroup("Server");
         cfg.setGroup(QString::number(i));
         tempname=cfg.readEntry( "ServerName","");
 
         if( tempname.find( servername,0,TRUE)  != -1 ) {
 //             servername.find( cfg.readEntry("ServerName"))  != -1 &&
 //             remoteServerStr.find( cfg.readEntry("RemotePath")) != -1 &&
 //             username.find( cfg.readEntry("Username")) != -1) {
 
             serverListView->removeItem(i);
 
             qDebug("OK DELETE "+tempname);
             cfg.removeEntry(QString::number(i));
             for ( ; i <= numberOfEntries; i++) {
                 cfg.setGroup("Server");
                 cfg.writeEntry("Server", QString::number(numberOfEntries + 1 ));
 
                 cfg.setGroup(QString::number(i+1)); //get next server config
                 servername=cfg.readEntry("ServerName");
                 remoteServerStr=cfg.readEntry("RemotePath");
                 username=cfg.readEntry("Username");
                 password=cfg.readEntryCrypt( username);
 
                 cfg.setGroup(QString::number(i));
 
                 cfg.writeEntry("RemotePath", remoteServerStr);
                 cfg.writeEntry("ServerName", servername);
                 cfg.writeEntry("Username", username);
                 cfg.writeEntryCrypt( username, password);
 
             }
             cfg.setGroup("Server");
             cfg.writeEntry("numberOfEntries", QString::number(numberOfEntries - 1 ));
         }
     }
     cfg.setGroup(QString::number(numberOfEntries));
     cfg.removeEntry("Server");
     cfg.removeEntry("RemotePath");
     cfg.removeEntry("ServerName");
      username=cfg.readEntry("Username");
     cfg.removeEntry("Username");
     cfg.removeEntry(username);
 
     currentServerConfig=currentServerConfig-1;
 
     fillCombos();
     update();
 }
 
 void OpieFtp::upDir()
 {
     if (TabWidget->currentPageIndex() == 0) {
         QString current = currentDir.canonicalPath();
         QDir dir(current);
         dir.cdUp();
         current = dir.canonicalPath();
         chdir( current.latin1() );
         currentDir.cd(  current, TRUE);
         populateLocalView();
         update();
     } else {
         if( FtpCDUp( conn) == 0) {
             QString msg;
             msg.sprintf(tr("Unable to cd up\n")+"%s",FtpLastResponse(conn));
             msg.replace(QRegExp(":"),"\n");
             QMessageBox::message(tr("Note"),msg);
 //                qDebug(msg);
         }
         char path[256];
         if( FtpPwd( path,sizeof(path),conn) == 0) { //this is easier than fudging the string
             QString msg;
             msg.sprintf(tr("Unable to get working dir\n")+"%s",FtpLastResponse(conn));
             msg.replace(QRegExp(":"),"\n");
             QMessageBox::message(tr("Note"),msg);
 //                qDebug(msg);
         }
         currentRemoteDir=path;
         remoteDirList( (const QString &)currentRemoteDir); //this also calls populate
         if(currentRemoteDir.right(1) !="/")
             currentRemoteDir +="/";
         currentPathCombo->lineEdit()->setText( currentRemoteDir);
         fillRemoteCombo( (const QString &)currentRemoteDir);
 
     }
 }
 
 void OpieFtp::docButtonPushed() {
     QString current = QPEApplication::documentDir();
     chdir( current.latin1() );
     currentDir.cd( current, TRUE);
      populateLocalView();
     update();
 
 }
 
 void OpieFtp::homeButtonPushed() {
     QString current = QDir::homeDirPath();
     chdir( current.latin1() );
     currentDir.cd(  current, TRUE);
      populateLocalView();
     update();
 }
 
 void OpieFtp::doAbout() {
     QMessageBox::message("OpieFtp","Opie ftp client is copyright 2002 by\n"
                          "L.J.Potter<llornkcor@handhelds.org>\n"
                          "and uses ftplib copyright 1996-2000\n"
                          "by Thomas Pfau, pfau@cnj.digex.net\n\n"
                          "and is licensed by the GPL");
 }
 
 void OpieFtp::NewServer() {
     InputDialog *fileDlg;
     fileDlg = new InputDialog(this,tr("New Server name"),TRUE, 0);
     fileDlg->exec();
     Config cfg("opieftp");
     if( fileDlg->result() == 1 ) {
       newServerName = fileDlg->LineEdit1->text();
       for(int i=1;i<serverListView->count();i++) {
           cfg.setGroup( QString::number(i));
           if(cfg.readEntry("ServerName").find(newServerName,0,TRUE) != -1) {
               QMessageBox::message(tr("OpieFtp"),tr("Sorry name already taken"));
               return;
           }
       }
       currentServerConfig =-1;
       writeConfig();
       serverListView->insertItem( newServerName );    
       serverListView->setCurrentItem( serverListView->count());
     }
 }
 
 void OpieFtp::serverListClicked( const QString &item) {
     if(item.isEmpty()) return;
     Config cfg("opieftp");
     qDebug("highltined "+item);
     int numberOfEntries = cfg.readNumEntry("numberOfEntries",0);
         for (int i = 1; i <= numberOfEntries; i++) {
             cfg.setGroup(QString::number(i));
               if(cfg.readEntry( "ServerName").find(item) != -1 && !fuckeduphack)
                   serverComboSelected(i-1);
     }
 }
+
+void OpieFtp::timerOut() {
+
+}
diff --git a/noncore/net/opieftp/opieftp.h b/noncore/net/opieftp/opieftp.h
index 2aa691a..109b5f8 100644
--- a/noncore/net/opieftp/opieftp.h
+++ b/noncore/net/opieftp/opieftp.h
@@ -1,138 +1,140 @@
 /***************************************************************************
    opieftp.h
                              -------------------
 ** Created: Sat Mar 9 23:33:09 2002
     copyright            : (C) 2002 by ljp
     email                : ljp@llornkcor.com
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 #ifndef OPIEFTP_H
 #define OPIEFTP_H
 
 #include <qvariant.h>
 #include <qdialog.h>
 #include <qmainwindow.h>
 #include <qdir.h>
 #include <qstring.h>
 #include <qpoint.h>
 
 class QVBoxLayout; 
 class QHBoxLayout; 
 class QGridLayout; 
 class QComboBox;
 class QListView;
 class QListViewItem;
 class QLabel;
 class QProgressBar;
 class QSpinBox;
 class QTabWidget;
 class QWidget;
 class QPEToolBar;
 class QPEMenuBar;
 class QPopupMenu;
 class QFile;
 class QLineEdit;
 class QPushButton;
 class QToolButton;
 class QStringList;
 class QListBox;
+class QTimer;
 
 class OpieFtp : public QMainWindow
 {
     Q_OBJECT
 
 public:
     OpieFtp(  );
     ~OpieFtp();
 
     QTabWidget *TabWidget;
     QWidget *tab, *tab_2, *tab_3;
     QListView *Local_View, *Remote_View;
     QListBox *serverListView;
 
     QComboBox *UsernameComboBox, *ServerComboBox, *currentPathCombo;
     QLineEdit *PasswordEdit, *remotePath;
     QLabel *TextLabel2, *TextLabel1, *TextLabel3, *TextLabel4;;
     QSpinBox* PortSpinBox;
     QPopupMenu *connectionMenu, *localMenu, *remoteMenu, *tabMenu, *aboutMenu;
     QDir currentDir;
     QString currentRemoteDir;
     QString filterStr;
     QListViewItem * item;
     QPushButton *connectServerBtn, *newServerButton;//
     QToolButton  *cdUpButton, *homeButton, *docButton;
     bool b;
     int currentServerConfig;
 protected slots:
+    void timerOut();
     void upDir();
     void homeButtonPushed();
     void docButtonPushed();
     void doAbout(); 
 
     void serverComboEdited(const QString & );
     void UsernameComboBoxEdited(const QString & );
     void PasswordEditEdited(const QString & );
 
     void showLocalMenu( QListViewItem *);
     void showRemoteMenu( QListViewItem *);
     void doLocalCd();
     void doRemoteCd();
     void localUpload();
     void remoteDownload();
     void newConnection();
     void connector();
     void disConnector();
     void populateLocalView();
     bool populateRemoteView();
     void showHidden();
     void writeConfig();
     void readConfig();
     void localListClicked(QListViewItem *);
     void remoteListClicked(QListViewItem *);
     void ListPressed( int, QListViewItem *, const QPoint&, int);
     void RemoteListPressed( int, QListViewItem *, const QPoint&, int);
     void localMakDir();
     void localDelete();
     void remoteMakDir();
     void remoteDelete();
 
     bool remoteDirList(const QString &);
     bool remoteChDir(const QString &);
 
     void tabChanged(QWidget*);
     void cleanUp();
 
     void remoteRename();
     void localRename();
 
     void currentPathComboChanged();
     void currentPathComboActivated(const QString &);
     void switchToLocalTab();
     void switchToRemoteTab();
     void switchToConfigTab();
 
     void fillCombos();
     void clearCombos();
     void fillRemoteCombo(const QString&);
     void fillCombo(const QString &);
     void serverComboSelected(int);
     void deleteServer();
     void connectorBtnToggled(bool);
     void NewServer();
     void serverListClicked( const QString &);
     
 protected:
     bool fuckeduphack;
   QStringList remoteDirPathStringList, localDirPathStringList;
   QString newServerName;
     void nullifyCallBack();
     QGridLayout* tabLayout;
     QGridLayout* tabLayout_2;
     QGridLayout* tabLayout_3;
     
 };
 
 #endif // OPIEFTP_H
diff --git a/noncore/net/opieftp/opieftp.pro b/noncore/net/opieftp/opieftp.pro
index 6d88530..ae72ff3 100644
--- a/noncore/net/opieftp/opieftp.pro
+++ b/noncore/net/opieftp/opieftp.pro
@@ -1,24 +1,24 @@
 TEMPLATE  = app
 CONFIG    += qt warn_on release
 HEADERS   = opieftp.h inputDialog.h ftplib.h
-SOURCES   = opieftp.cpp inputDialog.cpp ftplib.c main.cpp
+SOURCES   = opieftp.cpp inputDialog.cpp main.cpp
 TARGET    = opieftp
 DESTDIR   = $(OPIEDIR)/bin
 INCLUDEPATH += $(OPIEDIR)/include
 DEPENDPATH  += $(OPIEDIR)/include
-LIBS            += -lqpe
+LIBS            += -lqpe -lftplib
 
 TRANSLATIONS = ../../../i18n/de/opieftp.ts \
          ../../../i18n/en/opieftp.ts \
          ../../../i18n/es/opieftp.ts \
          ../../../i18n/fr/opieftp.ts \
          ../../../i18n/hu/opieftp.ts \
          ../../../i18n/ja/opieftp.ts \
          ../../../i18n/ko/opieftp.ts \
          ../../../i18n/no/opieftp.ts \
          ../../../i18n/pl/opieftp.ts \
          ../../../i18n/pt/opieftp.ts \
          ../../../i18n/pt_BR/opieftp.ts \
          ../../../i18n/sl/opieftp.ts \
          ../../../i18n/zh_CN/opieftp.ts \
          ../../../i18n/zh_TW/opieftp.ts