import java.net.*;
import java.io.*;
import java.util.*;

class FtpClient {
    static final boolean debug = false;

    public static final int FTP_PORT = 21; 

    static int  FTP_SUCCESS = 1;
    static int  FTP_TRY_AGAIN = 2;
    static int  FTP_ERROR = 3;

    /** socket for data transfer */
    private Socket      dataSocket = null;
    private boolean     replyPending = false;
    private boolean     binaryMode = false;
    private boolean     passiveMode = false;
    /** user name for login */
    String              user = null;
    /** password for login */
    String              password = null;

    /** last command issued */
    String              command;

    /** The last reply code from the ftp daemon. */
    int                 lastReplyCode;

    /** Welcome message from the server, if any. */
    public String       welcomeMsg;

    /** Array of strings (usually 1 entry) for the last reply
        from the server. */
    protected Vector    serverResponse = new Vector(1);

    /** Socket for communicating with server. */
    protected Socket    serverSocket = null;

    /** Stream for printing to the server. */
    public PrintWriter  serverOutput;

    /** Buffered stream for reading replies from server. */
    public InputStream  serverInput;


    /** Return server connection status */
    public boolean serverIsOpen() {
        return serverSocket != null;
    }

	/**Set Passive mode Trasfers*/
	public void setPassive(boolean mode) {
		passiveMode = mode;
	}
	
    public int readServerResponse() throws IOException {
        StringBuffer    replyBuf = new StringBuffer(32);
        int             c;
        int             continuingCode = -1;
        int             code = -1;
        String          response;
        if (debug) System.out.println("readServerResponse start");
 
        try{
        while (true) {
            //if (debug) System.out.println("readServerResponse outer while loop: "+ serverInput.available());
           
            while ((c = serverInput.read()) != -1) {
  
               if (c == '\r') {
                    if ((c = serverInput.read()) != '\n')
                        replyBuf.append('\r');
                }
                replyBuf.append((char)c);               
                if (c == '\n')
                    break;                
            }
 
            if (debug) System.out.println("Now past inner while loop");

            response = replyBuf.toString();
            replyBuf.setLength(0);
            if (debug) {
                System.out.print(response);
            }
            try {
                code = Integer.parseInt(response.substring(0, 3));
            } catch (NumberFormatException e) {
                code = -1;
            } catch (StringIndexOutOfBoundsException e) {
                /* this line doesn't contain a response code, so
                   we just completely ignore it */
                continue;
            }
            serverResponse.addElement(response);
            if (continuingCode != -1) {
                /* we've seen a XXX- sequence */
                if (code != continuingCode ||
                    (response.length() >= 4 && response.charAt(3) == '-')) {
                    continue;
                } else {
                    /* seen the end of code sequence */
                    continuingCode = -1;
                    break;
                }
            } else if (response.length() >= 4 && response.charAt(3) == '-') {
                continuingCode = code;
                continue;
            } else {
                break;
            }
        }
        }catch(Exception e){e.printStackTrace();}
        if (debug) System.out.println("readServerResponse done");
        return lastReplyCode = code;
    }

    /** Sends command <i>cmd</i> to the server. */
    public void sendServer(String cmd) {
        if (debug) System.out.println("sendServer start");
        serverOutput.println(cmd);
        if (debug) System.out.println("sendServer done");

    }
   
    /** Returns all server response strings. */
    public String getResponseString() {
        String s = new String();
        for(int i = 0;i < serverResponse.size();i++) {
           s+=serverResponse.elementAt(i);
        }
        serverResponse = new Vector(1);
        return s;
    }

   public String getResponseStringNoReset() {
        String s = new String();
        for(int i = 0;i < serverResponse.size();i++) {
           s+=serverResponse.elementAt(i);
        }
        return s;
    }


    /** 
     * issue the QUIT command to the FTP server and close the connection. 
     */
    public void closeServer() throws IOException {
        if (serverIsOpen()) {
            issueCommand("QUIT");
        if (! serverIsOpen()) {
              return;
            }
            serverSocket.close();
            serverSocket = null;
            serverInput = null;
            serverOutput = null;
        }
    }

    protected int issueCommand(String cmd) throws IOException {
        command = cmd;

        int reply;
        if (debug) System.out.println(cmd);
        if (replyPending) {
            if (debug) System.out.println("replyPending");
            if (readReply() == FTP_ERROR)
                System.out.print("Error reading pending reply\n");
        }
        replyPending = false;
        do {
            sendServer(cmd);
            reply = readReply();
            //if (debug) System.out.println("in while loop of issueCommand method");
        } while (reply == FTP_TRY_AGAIN);
        return reply;
    }

    protected void issueCommandCheck(String cmd) throws IOException {
        if (debug) System.out.println("issueCommandCheck");
        if (issueCommand(cmd) != FTP_SUCCESS) {            
            throw new FtpProtocolException(cmd);
            }
    }

    protected int readReply() throws IOException {
        lastReplyCode = readServerResponse();

        switch (lastReplyCode / 100) {
        case 1:
            replyPending = true;
            /* falls into ... */

        case 2://This case is for future purposes. If not properly used, it might cause an infinite loop. 
               //Don't add any code here , unless you know what you are doing.
                
        case 3:
            return FTP_SUCCESS;

        case 5:
            if (lastReplyCode == 530) {
                if (user == null) {
                    throw new FtpLoginException("Not logged in");
                }
                return FTP_ERROR;
            }
            if (lastReplyCode == 550) {
                if (!command.startsWith("PASS"))
                     throw new FileNotFoundException(command);
                else
                     throw new FtpLoginException("Error: Wrong Password!");     
            }
        }

        /* this statement is not reached */
        return FTP_ERROR;
    }

     protected Socket openDataConnection(String cmd) throws IOException {
        ServerSocket portSocket = null;
        String       portCmd;
        InetAddress  myAddress = InetAddress.getLocalHost();
        byte         addr[] = myAddress.getAddress();
        int          shift;
        String       ipaddress;
        int          port = 0;
        IOException  e;
		if (this.passiveMode) {

        /* First let's attempt to initiate Passive transfers */
	
      try {    // PASV code
        getResponseString();
        if (issueCommand("PASV") == FTP_ERROR) {
          e = new FtpProtocolException("PASV");
          throw e;
        }
        String reply = getResponseStringNoReset();
        reply = reply.substring(reply.lastIndexOf("(")+1,reply.lastIndexOf(")"));
        StringTokenizer st = new StringTokenizer(reply, ",");
        String[] nums = new String[6];
        int i = 0;
			  while(st.hasMoreElements()) {
				  try {
					  nums[i] = st.nextToken();
					  i++;
				  } catch(Exception a){a.printStackTrace();}
			  }
			  ipaddress = nums[0]+"."+nums[1]+"."+nums[2]+"."+nums[3];

			  try {
				  int firstbits = Integer.parseInt(nums[4]) << 8;
				  int lastbits = Integer.parseInt(nums[5]);
				  port = firstbits + lastbits;
			  } catch(Exception b) {b.printStackTrace();}

			  if((ipaddress != null) && (port != 0)) {
				  dataSocket = new Socket(ipaddress, port);}
			  else{
				  e = new FtpProtocolException("PASV");
				  throw e;
			  }

			  if (issueCommand(cmd) == FTP_ERROR) {
				  e = new FtpProtocolException(cmd);
				  throw e;
			  }

			} catch (FtpProtocolException fpe) {  // PASV was not supported...resort to PORT

			portCmd = "PORT ";

			/* append host addr */
			for (int i = 0; i < addr.length; i++) {
				portCmd = portCmd + (addr[i] & 0xFF) + ",";
			}
      try {
        portSocket = new ServerSocket(20000);
         /* append port number */
        portCmd = portCmd + ((portSocket.getLocalPort() >>> 8) & 0xff) + ","
             + (portSocket.getLocalPort() & 0xff);
        if (issueCommand(portCmd) == FTP_ERROR) {
          e = new FtpProtocolException("PORT");
          throw e;
        }

        if (issueCommand(cmd) == FTP_ERROR) {
          e = new FtpProtocolException(cmd);
          throw e;
        }
        dataSocket = portSocket.accept();
      }
      finally {
        if(portSocket != null)
          portSocket.close();
      }

			dataSocket = portSocket.accept();
			portSocket.close();

			}
		}//end if passive
		else
    {  //do a port transfer

      portCmd = "PORT ";

      /* append host addr */
      for (int i = 0; i < addr.length; i++) {
        portCmd = portCmd + (addr[i] & 0xFF) + ",";
      }
      try {
        portSocket = new ServerSocket(20000);
         /* append port number */
        portCmd = portCmd + ((portSocket.getLocalPort() >>> 8) & 0xff) + ","
             + (portSocket.getLocalPort() & 0xff);
        if (issueCommand(portCmd) == FTP_ERROR) {
          e = new FtpProtocolException("PORT");
          throw e;
        }

        if (issueCommand(cmd) == FTP_ERROR) {
          e = new FtpProtocolException(cmd);
          throw e;
        }
        dataSocket = portSocket.accept();
      }
      finally {
        if(portSocket != null)
          portSocket.close();
      }

      dataSocket = portSocket.accept();