//CYCLONE MATRIX HOST NODE APPLICATION
//Hermann L. Johnson, 2019
//Free for unmodified distribution and non-commercial use.

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

public class ClientThread extends Thread
{

   private int DOWNLOAD_PORT;
   private int[] UPLOAD_PORTS;
   private String SERVER_ADDRESS;

   private Socket downloadSocket, uploadSocket;
   private InputStream d_in;   //Download input
   private BufferedWriter d_out, u_out; //Download and upload output
   private boolean running;
   private Vector<String> indexLines;
   private Vector<String[]> index_lines;

   private static int SOCKET_TIMEOUT = 4000;

   private DataManager data_manager;

   private byte[] blankbytes;


//NOTE: Do not even look up mac addresses from IP if nothing is blacklisted
//or whitelisted.  This will waste a lot of time.

//TEST LONG ENTRY DOWNLOADS

   public ClientThread(String serverAddr, int downloadPort, int[] uploadPorts,
                       DataManager dataManager)
   {

     super("ClientThread");
     setRunning(false);
     SERVER_ADDRESS = serverAddr;
     DOWNLOAD_PORT = downloadPort;
     UPLOAD_PORTS = uploadPorts;
     data_manager = dataManager;
     blankbytes = new byte[10000];
     for(int count=0;count<10000;count++) {
         blankbytes[count] = 127;
     }

   }

   public synchronized boolean running() {

       return running;

   }

   public synchronized void setRunning(boolean newValue) {
       running = newValue;
   }

   public void killThread() {

       setRunning(false);

   }

   public void run()
   {

       setRunning(true);
       boolean shutdownNow = false;
       indexLines = new Vector<String>();
       index_lines = new Vector<String[]>();

       //Set up the network socket.
       try {
           downloadSocket = new Socket(SERVER_ADDRESS,DOWNLOAD_PORT);
           downloadSocket.setSoTimeout(SOCKET_TIMEOUT);
       } catch(Exception e) { System.err.println(
         "**Error setting up client download socket!  Client failure.");
           shutdownNow = true;
       }
       if(shutdownNow) {
           try {
               downloadSocket.close();
           } catch(Exception e) {
               System.err.println(
     "Error shutting down client download socket after socket setup failure!");
           }
           setRunning(false);
           return;
       }

       //Acquire index from the server.
       indexLines = acquireIndexOrHashes(true,"");
       if(!running) return;

       //Build the index as a string array vector.
       try {
           buildStringIndex();
       } catch(Exception e) {
          System.err.println("Error building index string array!");
       }

       Vector<String> missing_datafiles = new Vector<String>();

       finalizeIndexForUse(index_lines, missing_datafiles);

       //Add the remote datafiles that are missing entirely to local data.

       int num_new_lines;
       for(int count=0;count<missing_datafiles.size();count++) {
           acquireDataFile(missing_datafiles.elementAt(count));
           if(!running) return;
       }

       Vector<String> hashesToUpload = new Vector<String>();
       Vector<String> remoteHashes = new Vector<String>();
       Vector<String> localHashes = new Vector<String>();
       Vector<String> entriesToDownload = new Vector<String>();

       String currentDataFile = "";
       for(int count=0;count<index_lines.size();count++) {
           hashesToUpload.clear();
           remoteHashes.clear();
           localHashes.clear();
           entriesToDownload.clear();
           currentDataFile = index_lines.elementAt(count)[0]+"-"+
               index_lines.elementAt(count)[1];
           remoteHashes = acquireIndexOrHashes(false,currentDataFile);
           if(!running()) {
              System.err.println("Error acquiring all hashes. Exiting.");
              return;
           }
System.err.println(remoteHashes.size()+" hashes downloaded from remote "+
                  currentDataFile);

           //Set up the localHashes vector.
           localHashes = data_manager.getHashList(currentDataFile);

           //This is the main method for determining differences.
           //It is very important.
           setupDownloadsAndUploads(localHashes, remoteHashes,
                                   entriesToDownload,
                                   hashesToUpload);

           //Pull all of the necessary downloads.
           requestDownloads(currentDataFile, entriesToDownload, false);
           try {
               downloadSocket.close();
           } catch(Exception e) {
               System.err.println(
         "Error shutting down client download socket at end of cycle!");
           }
           if(!running()) {
               System.err.println("Error requesting downloads. Exiting.");
               return;
           }

           //Upload the necessary uploads.
           uploadData(currentDataFile, hashesToUpload);
           try {
               uploadSocket.close();
           } catch(Exception e) {
               System.err.println(
         "Error shutting down client upload socket at end of cycle!");
           }
           if(!running()) {
               System.err.println("Error uploading all hashes. Exiting.");
               return;
           }

       }

       setRunning(false);
       return;

   }

   //This method can request an entire file (in which case the hashes
   //are ignored) or it can request hashes and hash spans.
   private void requestDownloads(String currentDataFile,
                                 Vector<String> downloadHashes,
                                 boolean entireFile) {

       //If there is nothing to do.
       if((downloadHashes.size()==0)&&!entireFile) return;

       boolean breakWhile = false;
       boolean shutdownNow = false;

       //Input and Output strings for communications.
       String inputString, outputString;

       TrueStringTokenizer sttok;

       //This tries to get either the first entry or the entire file as
       //a ZIP.  If we were seeking the entire file and it succeeds, it is
       //done.  If we were just seeking certain entries, it continues to try
       //to get those entries as ZIP, skipping the first one.
       //Failure to get ZIP causes a retry for TXT, whether for the entire
       //file or for specific entries, starting at the first one.
       try {

           //Set up the input and output streams.
           d_out = new BufferedWriter(new PrintWriter(
                          downloadSocket.getOutputStream(), true));
           d_in = downloadSocket.getInputStream();

           byte[] readBytes = new byte[10000];
           int bufferContentSize = 0;
           String entryLine = new String("");
           BufferedInputStream bis = new BufferedInputStream(d_in);

           ZipInputStream zis = new ZipInputStream(bis);

           boolean zipcapable = false;

           //If entireFile, get the entire file.
           if(entireFile) outputString = "GET /"+currentDataFile+".zip\n";

           //Or get the first hash member, to test for ZIP capabilities.
           else outputString = "GET /"+currentDataFile+".zip/"+
               downloadHashes.elementAt(0)+"\n";

           d_out.write(outputString,0,outputString.length());
           d_out.flush();

           breakWhile = false;
           try {
               zis.getNextEntry();
           } catch(Exception e) {
               System.err.println("ZIP input stream error.");
               zipcapable = false;
               breakWhile = true;
           }

           //Reading with a buffer is more efficient than reading byte
           //by byte, but knowing where the data ends becomes an issue.
           //Thus the timeout is relied upon.  The exception would
           //result in a lost data count, thus the precautions.

           //This section is for reading ZIP data.
           while(!breakWhile) {

               try {
                   //Clear readBytes.
                   System.arraycopy(blankbytes, 0, readBytes, 0, 10000);
                   //Fill readBytes.
                   bufferContentSize = zis.read(readBytes,0,10000);
               } catch(Exception e) {
                   //Likely a port timeout.
                   //No more reading.
                   breakWhile = true;
                   //If there is a port failure, close connection after work.
                   shutdownNow = true;

                   //Examine the buffer to see how many bytes are there.
                   //The zis.read, with exception, will not tell us.
                   bufferContentSize = 0;
                   for(int count=0;count<10000;count++) {
                       if(readBytes[count]==127) {
                           bufferContentSize = count;
                           count = 10000;
                       }
                   }
               }

               //If the buffer is empty at this point, ensure that there
               //will be no more reads.
               if(bufferContentSize<=0) breakWhile = true;
               //The buffer has data.  Add it to entryLine.
               else {
                   entryLine = entryLine + new String(
                            readBytes,0,bufferContentSize);
                   //If EOF, remove the marker from entryLine and quit reading.
                   if(entryLine.contains("%EOF%")) {
                       entryLine = entryLine.substring(
                                      0,entryLine.indexOf("%EOF%"));
                       breakWhile = true;
                   }
                   //If the buffer has data, ZIP reading is OK.
                   zipcapable = true;
System.err.println("ZIP download accepted: "+currentDataFile);

                   sttok = new TrueStringTokenizer(entryLine,"%LBK%");

                   //The remainder is recycled in case we are reading
                   //data longer than the buffer and the looping is necessary.
                   //Do not use, individually, the last bit after tokens.
                   while( sttok.hasMoreTokens()
                          && sttok.getRemainder().contains("%LBK%")  ) {
                       entryLine = sttok.nextToken();
                       if(!entryLine.equals("")) {
                           data_manager.takeDataLine(entryLine+"%LBK%");
                       }
                   }
                   entryLine = sttok.getRemainder();
               }

           }

           //If it is zipcapable, do the other entries in the hashes.
           //This does nothing if in entireFile mode.
           if(zipcapable&&!shutdownNow) {

               //Entries counter is one because of zip testing.
               //This is skipped for entireFile.
               for(int entriescounter=1;
                   (entriescounter<downloadHashes.size())&&!entireFile;
                        entriescounter++)
               {
                   entryLine = "";
                   outputString = "GET /"+currentDataFile+".zip/"+
                       downloadHashes.elementAt(entriescounter)+"\n";

                   d_out.write(outputString,0,outputString.length());
                   d_out.flush();

                   //The zip mode has been verified, so bad zip data
                   //may as well result in disposing of the connection
                   //by going to the main catch.
                   zis.getNextEntry();

                   breakWhile = false;
                   while(!breakWhile) {

                       try {
                           System.arraycopy(blankbytes, 0, readBytes, 0
                                            , 10000);
                           bufferContentSize = zis.read(readBytes,0,10000);
                       } catch(Exception e) {
                           //Likely a port timeout.
                           breakWhile = true;
                           shutdownNow = true;
                           bufferContentSize = 0;
                           for(int count=0;count<10000;count++) {
                               if(readBytes[count]==127) {
                                   bufferContentSize = count;
                                   count = 10000;
                               }
                           }
                       }

                       if(bufferContentSize<=0) breakWhile = true;
                       //The buffer has data, add it to entryLine.
                       else {
                           entryLine = entryLine + new String(
                                      readBytes,0,bufferContentSize);
                           if(entryLine.contains("%EOF%")) {
                               entryLine = entryLine.substring(
                                      0,entryLine.indexOf("%EOF%"));
                               breakWhile = true;
                           }
                           sttok = new TrueStringTokenizer(entryLine,"%LBK%");
                           while(sttok.hasMoreTokens()
                                 && sttok.getRemainder().contains("%LBK%")) {
                               entryLine = sttok.nextToken();
                               if(!entryLine.equals("")) {
                                   data_manager.takeDataLine(entryLine+
                                                             "%LBK%");
                               }
                           }
                           entryLine = sttok.getRemainder();
                       }
                   }
               }

           } else if(!shutdownNow) {
System.err.println("ZIP download rejected. Going TXT for: "+currentDataFile);
               //TXT mode.  Runs on all hashes or the entireFile.
               for(int count=0;(count<downloadHashes.size())||entireFile;
                       count++) {
                   entryLine = "";
                   if(entireFile) {
                       outputString =
                           "GET /"+currentDataFile+".txt\n";
                       //Make sure it only runs once.
                       //Ensure only one iteration through for loop.
                       count = downloadHashes.size();
                       entireFile = false;
                   } else
                       outputString = "GET /"+currentDataFile+".txt/"+
                       downloadHashes.elementAt(count)+"\n";
                   d_out.write(outputString,0,outputString.length());
                   d_out.flush();

                   breakWhile = false;
                   while(!breakWhile) {

                       try {
                           System.arraycopy(blankbytes, 0, readBytes, 0
                                            , 10000);
                           bufferContentSize = bis.read(readBytes,0,10000);
                       } catch(Exception e) {
                           //Likely a port timeout.
                           breakWhile = true;
                           shutdownNow = true;
                           bufferContentSize = 0;
                           for(int count_buf=0;count_buf<10000;
                               count_buf++) {
                               if(readBytes[count_buf]==127) {
                                   bufferContentSize = count_buf;
                                   count_buf = 10000;
                               }
                           }
                       }

                       if(bufferContentSize>=0) {
                           entryLine = entryLine + new String(
                                  readBytes,0,bufferContentSize);
                           if(entryLine.contains("%EOF%")) {
                               entryLine = entryLine.substring(
                                      0,entryLine.indexOf("%EOF%"));
                               breakWhile = true;
                           }
                           sttok = new TrueStringTokenizer(entryLine,
                                                               "%LBK%");
                           while(sttok.hasMoreTokens()
                                 && sttok.getRemainder().contains("%LBK%")) {
                               entryLine = sttok.nextToken();
                               if(!entryLine.equals("")) {
                                   data_manager.takeDataLine(entryLine+
                                                                 "%LBK%");
                               }
                           }
                           entryLine = sttok.getRemainder();
                       }
                   }
               }
           }
       } catch(Exception e) {
           System.err.println(
                  "Client error processing "+currentDataFile+
                  "! Client failure.");
           shutdownNow = true;
       }
       if(shutdownNow) {
           //If there is a major error found when working on data, shut
           //down the connection and thread.
           try {
               downloadSocket.close();
           } catch(Exception e) {
               System.err.println(
            "Error closing client download socket after "+currentDataFile+
                         " failure!");
           }
           setRunning(false);
       }

   }

   //To upload local entries identified by uploadHashes
   private void uploadData(String dataFileName, Vector<String> uploadHashes) {

       if(uploadHashes.size()==0) return;
       boolean zipcapable = true;
       //ZIPs go to every other port.  These ports should be tried first.
       //For this implementation, only one ZIP port will be tried.

       int uploadingPort = 0;
       boolean zipsuccess = true;
       String outputString = new String("");
       boolean shutdownNow = false;

       //Try a ZIP port.
       if(UPLOAD_PORTS.length>1) {

           uploadingPort = UPLOAD_PORTS[1];

           //Set up the network socket.
           try {

               uploadSocket = new Socket(SERVER_ADDRESS,uploadingPort);
               uploadSocket.setSoTimeout(SOCKET_TIMEOUT);

               ZipOutputStream zos = new ZipOutputStream(
                   new BufferedOutputStream(uploadSocket.getOutputStream()));
               zos.putNextEntry(new ZipEntry(dataFileName+".txt"));

               for(int count=0;count<uploadHashes.size();count++) {
                   outputString = data_manager.getDataEntry(dataFileName,
                                            uploadHashes.elementAt(count));
                   zos.write(outputString.getBytes(),0,outputString.length());
                   zos.flush();
               }
               outputString = "%EOF%";
               zos.write(outputString.getBytes(),0,outputString.length());
               zos.closeEntry();
               zos.finish();
               zos.flush();
               zos.close();
               uploadSocket.close();

           } catch(Exception e) { System.err.println(
             "**Error working the client ZIP upload socket! Client failure.");
               zipsuccess = false;
           }

       } else zipsuccess = false;

       if(!zipsuccess) {

           try {
               uploadSocket.close();
           } catch(Exception e) {
               System.err.println(
            "Error shutting down the client ZIP upload socket!");
           }

           uploadingPort = UPLOAD_PORTS[0];

           //Set up the network socket.
           try {

               uploadSocket = new Socket(SERVER_ADDRESS,uploadingPort);
               uploadSocket.setSoTimeout(SOCKET_TIMEOUT);

               u_out = new BufferedWriter(new PrintWriter(
                           uploadSocket.getOutputStream(), true));

               for(int count=0;count<uploadHashes.size();count++) {
                   outputString = data_manager.getDataEntry(dataFileName,
                                uploadHashes.elementAt(count));
                   u_out.write(outputString,0,outputString.length());
                   u_out.flush();
               }
               outputString = "%EOF%";
               u_out.write(outputString,0,outputString.length());
               u_out.flush();
               u_out.close();
               uploadSocket.close();

           } catch(Exception e) { System.err.println(
             "**Error working the client TXT upload socket! Client failure.");
               shutdownNow = true;
           }
       }
       if(shutdownNow) {
           try {
               uploadSocket.close();
           } catch(Exception e) {
               System.err.println(
     "Error shutting down client upload socket after socket setup failure!");
           }
           setRunning(false);
           return;
       }
   }

   //Populate the last two vectors.
   //This method is the most critical.
   private void setupDownloadsAndUploads(Vector<String> localHashes,
                Vector<String> remoteHashes, Vector<String> entriesToDownload,
                Vector<String> hashesToUpload) {

       String spanFirst = new String("");
       String spanSecond = new String("");
       String current = new String("");

       //Set up downloads.
       for(int count=0;count<remoteHashes.size();count++) {
           //Go through remoteHashes, making a span list.
           //Go through the span list, to remove the single entries.

           current = remoteHashes.elementAt(count);

           if(!localHashes.contains(current)) {
               if(spanFirst.equals(""))
                   spanFirst = current;
               else
                   spanSecond = current;
           } else {
               //current is already on hand locally. Add current span, if it
               //has anything, and clear it.
               if((!spanFirst.equals("")) && (!spanSecond.equals(""))) {
                   entriesToDownload.addElement(spanFirst+"-"+spanSecond);
                   spanFirst = "";
                   spanSecond = "";
               } else if((!spanFirst.equals(""))) {
                   //If only the second one is empty...
                   entriesToDownload.addElement(spanFirst);
                   spanFirst = "";
               }
           }
       }
       if((!spanFirst.equals("")) && (!spanSecond.equals("")))
           entriesToDownload.addElement(spanFirst+"-"+spanSecond);
       else if((!spanFirst.equals("")))
           entriesToDownload.addElement(spanFirst);

       //Set up necessary uploads.
       for(int count=0;count<localHashes.size();count++) {
           current = localHashes.elementAt(count);
           if(!remoteHashes.contains(current))
               hashesToUpload.addElement(current);
       }

   }

   //Strip index entries that are locally up to date as well as those
   //TRANSFER entries that are not locally existent to missing_datafiles.
   //The transferred entries are removed from the index so they are not
   //reprocessed in search of differences.
   private void finalizeIndexForUse(Vector<String[]> index_lines,
                                    Vector<String> missing_datafiles) {
      int datafilestatus;
      for(int count=0;count<index_lines.size();count++) {
          datafilestatus = 0;
          datafilestatus = data_manager.hasExactDataFile(
                  index_lines.elementAt(count)[0],
                  index_lines.elementAt(count)[1],
                  index_lines.elementAt(count)[3]);
          if(datafilestatus==1) {
              index_lines.removeElementAt(count);
              count--;
          } else if(datafilestatus==0) {
              missing_datafiles.addElement(new String(
                           index_lines.elementAt(count)[0]+
                           "-"+index_lines.elementAt(count)[1]));
              index_lines.removeElementAt(count);
              count--;
          }
      }
   }

   private void buildStringIndex() throws Exception {

       String workingLine;
       String abbrLocation, entriesDateStamp, fileDateTimeStamp, entireFileSha,
           regularDataSha, txtSize, zipSize;
       TrueStringTokenizer sttok;
       String[] new_entry;

       for(int count=0;count<indexLines.size();count++) {
           abbrLocation = "";
           entriesDateStamp = "";
           fileDateTimeStamp = "";
           entireFileSha = "";
           regularDataSha = "";
           txtSize = "";
           zipSize = "";
           workingLine = indexLines.elementAt(count);
           sttok = new TrueStringTokenizer(workingLine,"%BK%");
           StringTokenizer sttok2;
           if(sttok.hasMoreTokens()) {
               entriesDateStamp = abbrLocation = sttok.nextToken();
               sttok2 = new StringTokenizer(abbrLocation,"-");
               if(sttok2.hasMoreTokens()) abbrLocation = sttok2.nextToken();
               if(sttok2.hasMoreTokens()) entriesDateStamp =
                                              sttok2.nextToken(".");
               if(entriesDateStamp.length()>0)
                   entriesDateStamp = entriesDateStamp.substring(1,
                                 entriesDateStamp.length());
           }
           if(sttok.hasMoreTokens())
               fileDateTimeStamp = sttok.nextToken();
           if(sttok.hasMoreTokens())
               entireFileSha = sttok.nextToken();
           if(sttok.hasMoreTokens())
               regularDataSha = sttok.nextToken();
           if(sttok.hasMoreTokens())
               txtSize = sttok.nextToken();
           if(sttok.hasMoreTokens())
               zipSize = sttok.nextToken();
           abbrLocation.trim();
           entriesDateStamp.trim();
           fileDateTimeStamp.trim();
           entireFileSha.trim();
           regularDataSha.trim();
           txtSize.trim();
           zipSize.trim();
           //Validate abbrLocation and set to uppercase.
           //Validate date stamps.
           //If the SHAs or file sizesare wrong, they will just trick us into
           //not taking their data, which is fine.  Our own sizes and SHAs
           //will always be recalculated.
           if(isLettersAndDigits(abbrLocation)) {
               abbrLocation = abbrLocation.toUpperCase();
               if(abbrLocation.length()>0) {
                   if(DataManager.isValidDate(entriesDateStamp)) {
                       if(DataManager.isValidDateTime(fileDateTimeStamp)) {
                           new_entry = new String[7];
                           new_entry[0] = abbrLocation;
                           new_entry[1] = entriesDateStamp;
                           new_entry[2] = fileDateTimeStamp;
                           new_entry[3] = entireFileSha;
                           new_entry[4] = regularDataSha;
                           new_entry[5] = txtSize;
                           new_entry[6] = zipSize;
                           index_lines.addElement(new_entry);
                       }
                   }
               }
           }

       }

   }

   private boolean isLettersAndDigits(String toTest) {
       for(int count=0;count<toTest.length();count++) {
           if( !Character.isLetterOrDigit(toTest.charAt(count))
              &&  (toTest.charAt(count)!='-')
               )
               return false;
       }
       return true;
   }

   //The dataFileName should not have an extension.
   private Vector<String> acquireIndexOrHashes(boolean isIndex,
                                               String dataFileName) {

//DO NOT FORGET TO SKIP DATES THAT ARE TOO OLD

       String inputString, outputString;
       boolean breakWhile = false;
       boolean zipcapable = false;
       boolean shutdownNow = false;

       Vector<String> results = new Vector<String>();

       try {

           //Open the streams.
           d_out = new BufferedWriter(new PrintWriter(
                          downloadSocket.getOutputStream(), true));
           d_in = downloadSocket.getInputStream();

           if(isIndex) outputString = "GET /index.zip\n";
           else outputString = "GET /"+dataFileName+".txt/hashlist.zip\n";

           d_out.write(outputString,0,outputString.length());
           d_out.flush();
           byte[] readBytes = new byte[10000];
           int bufferContentSize = 0;
           String entryLine = new String("");
           TrueStringTokenizer sttok;

           BufferedInputStream bis = new BufferedInputStream(d_in);
           ZipInputStream zis = new ZipInputStream(bis);

           breakWhile = false;
           try {
               zis.getNextEntry();
           } catch(Exception e) {
               System.err.println("ZIP input stream error.");
               zipcapable = false;
               breakWhile = true;
           }

           while(!breakWhile) {
               try {
                   System.arraycopy(blankbytes, 0, readBytes, 0, 10000);
                   bufferContentSize = zis.read(readBytes,0,10000);
               } catch(Exception e) {
                   //Likely a port timeout.
                   breakWhile = true;
                   //Port timeout means to dispose of connection.
                   shutdownNow = true;
                   bufferContentSize = 0;
                   for(int count=0;count<10000;count++) {
                       if(readBytes[count]==127) {
                           bufferContentSize = count;
                           count = 10000;
                       }
                   }
               }
               if(bufferContentSize<=0) breakWhile = true;
               else {
System.err.println("ZIP index or hashes download accepted.");
                   zipcapable = true;
                   entryLine = entryLine + new String(
                            readBytes,0,bufferContentSize);
                   if(entryLine.contains("%EOF%")) {
                       entryLine = entryLine.substring(
                                      0,entryLine.indexOf("%EOF%"));
                       breakWhile = true;
                   }
                   sttok = new TrueStringTokenizer(entryLine,"%LBK%");

                   //The remainder is recycled in case we are reading
                   //data longer than the buffer and the looping is necessary.
                   //Do not use, individually, the last bit after tokens.
                   while( sttok.hasMoreTokens()
                          && sttok.getRemainder().contains("%LBK%")  ) {
                       entryLine = sttok.nextToken();
                       if(!entryLine.equals("")) {
                           results.addElement(entryLine);
                       }
                   }
                   entryLine = sttok.getRemainder();
               }

           }
           //The zip reading while statement has ceased.
           if(!zipcapable&&!shutdownNow) {
System.err.println("ZIP Index or Hashes Download Rejected.  Going TXT.");

               if(isIndex) outputString = "GET /index.txt\n";
               else outputString = "GET /"+dataFileName+".txt/hashlist.txt\n";

               d_out.write(outputString,0,outputString.length());
               d_out.flush();
               entryLine = "";

               breakWhile = false;

               while(!breakWhile) {

                   try {
                       System.arraycopy(blankbytes, 0, readBytes, 0, 10000);
                       bufferContentSize = bis.read(readBytes,0,10000);
                   } catch(Exception e) {
                       //Likely a port timeout.
                       breakWhile = true;
                       shutdownNow = true;
                       bufferContentSize = 0;
                       for(int count=0;count<10000;count++) {
                           if(readBytes[count]==127) {
                               bufferContentSize = count;
                               count = 10000;
                           }
                       }
                   }

                   if(bufferContentSize<=0) breakWhile = true;
                   else {
                       entryLine = entryLine + new String(
                                  readBytes,0,bufferContentSize);
                       if(entryLine.contains("%EOF%")) {
                           entryLine = entryLine.substring(
                                      0,entryLine.indexOf("%EOF%"));
                           breakWhile = true;
                       }

System.err.println("TXT index or hashes download accepted.");
                       sttok = new TrueStringTokenizer(entryLine,"%LBK%");

                       //The remainder is recycled in case we are reading
                       //data longer than the buffer and the looping is
                       //necessary.
                       //Do not use, individually, the last bit after tokens.
                       while( sttok.hasMoreTokens()
                          && sttok.getRemainder().contains("%LBK%")  ) {
                           entryLine = sttok.nextToken();
                           if(!entryLine.equals("")) {
                               results.addElement(entryLine);
                           }
                       }
                       entryLine = sttok.getRemainder();
                   }
               }
           }
       } catch(Exception e) {
           System.err.println(
                  "Client error processing index or hashes!  Client failure.");
           shutdownNow = true;
       }
       if(shutdownNow) {
 System.err.println("Shutting down client socket due to completion or error.");
           try {
               downloadSocket.close();
           } catch(Exception e) {
               System.err.println(
                "Error closing client download socket after index "+
                "or hashes processing failure!");
           }
           setRunning(false);
           return results;
       }

       return results;
   }

   //The datafile name should not have the extension.
   private void acquireDataFile(String dataFileName) {
       requestDownloads(dataFileName, new Vector<String>(), true);
   }

}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.