Changeset 7151590


Ignore:
Timestamp:
Jun 8, 2009 8:34:54 AM (11 years ago)
Author:
sponge <sponge@…>
Branches:
master
Children:
0382120
Parents:
51faed2
Message:

2009-06-08 sponge

  • Fixed NPE and some other goofups in BOB.
  • BOB bump version
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • apps/BOB/src/net/i2p/BOB/BOB.java

    r51faed2 r7151590  
    3939import net.i2p.util.Log;
    4040import net.i2p.util.SimpleScheduler;
    41 import net.i2p.util.SimpleStore;
    4241import net.i2p.util.SimpleTimer2;
    4342
  • apps/BOB/src/net/i2p/BOB/DoCMDS.java

    r51faed2 r7151590  
    4848        // FIX ME
    4949        // I need a better way to do versioning, but this will do for now.
    50         public static final String BMAJ = "00",  BMIN = "00",  BREV = "06",  BEXT = "";
     50        public static final String BMAJ = "00",  BMIN = "00",  BREV = "07",  BEXT = "";
    5151        public static final String BOBversion = BMAJ + "." + BMIN + "." + BREV + BEXT;
    5252        private Socket server;
  • apps/BOB/src/net/i2p/BOB/I2PtoTCP.java

    r51faed2 r7151590  
    5353        }
    5454
    55         private void rlock() throws Exception {
     55        private void rlock() {
    5656                database.getReadLock();
    5757                info.getReadLock();
    5858        }
    5959
    60         private void runlock() throws Exception {
     60        private void runlock() {
    6161                database.releaseReadLock();
    6262                info.releaseReadLock();
  • apps/BOB/src/net/i2p/BOB/MUXlisten.java

    r51faed2 r7151590  
    4444public class MUXlisten implements Runnable {
    4545
    46         private NamedDB database,  info;
     46        private NamedDB database, info;
    4747        private Log _log;
    4848        private I2PSocketManager socketManager;
  • apps/BOB/src/net/i2p/BOB/TCPlistener.java

    r51faed2 r7151590  
    4343        private NamedDB info,  database;
    4444        private Log _log;
    45         private int tgwatch;
    4645        public I2PSocketManager socketManager;
    4746        public I2PServerSocket serverSocket;
     
    6160                this.socketManager = S;
    6261                this.listener = listener;
    63                 tgwatch = 1;
    6462        }
    6563
     
    8583                        die:
    8684                        {
    87                                 try {
    88                                         rlock();
    89                                 } catch (Exception e) {
    90                                         break die;
    91                                 }
    92                                 try {
    93                                         if (info.exists("OUTPORT")) {
    94                                                 tgwatch = 2;
    95                                         }
    96                                 } catch (Exception e) {
    97                                         try {
    98                                                 runlock();
    99                                         } catch (Exception e2) {
    100                                                 break die;
    101                                         }
    102                                         break die;
    103                                 }
    104                                 try {
    105                                         runlock();
    106                                 } catch (Exception e) {
    107                                         break die;
    108                                 }
    10985                                try {
    11086                                        Socket server = new Socket();
     
    135111                                                        conn++;
    136112                                                        // toss the connection to a new thread.
    137                                                         TCPtoI2P conn_c = new TCPtoI2P(socketManager, server);
     113                                                        TCPtoI2P conn_c = new TCPtoI2P(socketManager, server, info, database);
    138114                                                        Thread t = new Thread(conn_c, Thread.currentThread().getName() + " TCPtoI2P " + conn);
    139115                                                        t.start();
  • apps/BOB/src/net/i2p/BOB/TCPtoI2P.java

    r51faed2 r7151590  
    3434import net.i2p.client.streaming.I2PSocket;
    3535import net.i2p.client.streaming.I2PSocketManager;
     36import net.i2p.data.DataFormatException;
    3637import net.i2p.data.Destination;
    3738import net.i2p.i2ptunnel.I2PTunnel;
     
    4950        private Socket sock;
    5051        private I2PSocketManager socketManager;
     52
     53        /**
     54         * Constructor
     55         * @param i2p
     56         * @param socket
     57         * param info
     58         * param database
     59         */
     60        TCPtoI2P(I2PSocketManager i2p, Socket socket , NamedDB info, NamedDB database) {
     61                this.sock = socket;
     62                this.info = info;
     63                this.database = database;
     64                this.socketManager = i2p;
     65        }
    5166
    5267        /**
     
    5671         * @param in
    5772         * @return line of text as a String
    58          * @throws Exception
    59          */
    60         private static String lnRead(InputStream in) throws Exception {
     73         * @throws IOException
     74         */
     75        private static String lnRead(InputStream in) throws IOException {
    6176                String S;
    6277                int b;
     
    8297
    8398        /**
    84          * Constructor
    85          * @param i2p
    86          * @param socket
    87          * param info
    88          * param database
    89          */
    90         TCPtoI2P(I2PSocketManager i2p, Socket socket /*, NamedDB info, NamedDB database */) {
    91                 this.sock = socket;
    92                 // this.info = info;
    93                 // this.database = database;
    94                 this.socketManager = i2p;
    95         }
    96 
    97         /**
    9899         * Print an error message to out
    99100         *
     
    104105        private void Emsg(String e, OutputStream out) throws IOException {
    105106// Debugging            System.out.println("ERROR TCPtoI2P: " + e);
    106                 out.write("ERROR".concat(e).getBytes());
    107                 out.write(13); // cr
     107                out.write("ERROR ".concat(e).getBytes());
     108                out.write(13);
     109                out.write(10);
    108110                out.flush();
    109111        }
    110112
    111         private void rlock() throws Exception {
     113//      private void rlock() throws Exception {
     114        private void rlock() {
    112115                database.getReadLock();
    113116                info.getReadLock();
    114117        }
    115118
    116         private void runlock() throws Exception {
     119//      private void runlock() throws Exception {
     120        private void runlock() {
     121                info.releaseReadLock();
    117122                database.releaseReadLock();
    118                 info.releaseReadLock();
    119123        }
    120124
     
    136140                                in = sock.getInputStream();
    137141                                out = sock.getOutputStream();
     142                                line = lnRead(in);
     143                                input = line.toLowerCase();
     144                                Destination dest = null;
     145                                if (input.endsWith(".i2p")) {
     146                                        dest = I2PTunnel.destFromName(input);
     147                                        line = dest.toBase64();
     148                                }
     149                                dest = new Destination();
     150                                dest.fromBase64(line);
     151
    138152                                try {
    139                                         line = lnRead(in);
    140                                         input = line.toLowerCase();
    141                                         Destination dest = null;
    142 
    143                                         if (input.endsWith(".i2p")) {
    144                                                 dest = I2PTunnel.destFromName(input);
    145                                                 line = dest.toBase64();
     153                                        // get a client socket
     154                                        I2P = socketManager.connect(dest);
     155                                        I2P.setReadTimeout(0); // temp bugfix, this *SHOULD* be the default
     156                                        // make readers/writers
     157                                        Iin = I2P.getInputStream();
     158                                        Iout = I2P.getOutputStream();
     159                                        // setup to cross the streams
     160                                        TCPio conn_c = new TCPio(in, Iout /*, info, database */); // app -> I2P
     161                                        TCPio conn_a = new TCPio(Iin, out /*, info, database */); // I2P -> app
     162                                        t = new Thread(conn_c, Thread.currentThread().getName() + " TCPioA");
     163                                        q = new Thread(conn_a, Thread.currentThread().getName() + " TCPioB");
     164                                        // Fire!
     165                                        t.start();
     166                                        q.start();
     167                                        boolean spin = true;
     168                                        while (t.isAlive() && q.isAlive()) { // AND is used here to kill off the other thread
     169                                                Thread.sleep(10); //sleep for 10 ms
     170                                                rlock();
     171                                                spin = info.get("RUNNING").equals(Boolean.TRUE);
     172                                                runlock();
    146173                                        }
    147                                         dest = new Destination();
    148                                         dest.fromBase64(line);
    149 
    150                                         try {
    151                                                 // get a client socket
    152                                                 I2P = socketManager.connect(dest);
    153                                                 I2P.setReadTimeout(0); // temp bugfix, this *SHOULD* be the default
    154                                                 // make readers/writers
    155                                                 Iin = I2P.getInputStream();
    156                                                 Iout = I2P.getOutputStream();
    157                                                 // setup to cross the streams
    158                                                 TCPio conn_c = new TCPio(in, Iout /*, info, database */); // app -> I2P
    159                                                 TCPio conn_a = new TCPio(Iin, out /*, info, database */); // I2P -> app
    160                                                 t = new Thread(conn_c, Thread.currentThread().getName() + " TCPioA");
    161                                                 q = new Thread(conn_a, Thread.currentThread().getName() + " TCPioB");
    162                                                 // Fire!
    163                                                 t.start();
    164                                                 q.start();
    165                                                 boolean spin = true;
    166                                                 while (t.isAlive() && q.isAlive()) { // AND is used here to kill off the other thread
    167                                                         Thread.sleep(10); //sleep for 10 ms
    168                                                         rlock();
    169                                                         spin = info.get("RUNNING").equals(Boolean.TRUE);
    170                                                         runlock();
    171                                                 }
    172                                         } catch (I2PException e) {
    173                                                 Emsg("ERROR " + e.toString(), out);
    174                                         } catch (ConnectException e) {
    175                                                 Emsg("ERROR " + e.toString(), out);
    176                                         } catch (NoRouteToHostException e) {
    177                                                 Emsg("ERROR " + e.toString(), out);
    178                                         } catch (InterruptedIOException e) {
    179                                                 // We're breaking away.
    180                                         }
    181 
    182                                 } catch (Exception e) {
    183                                         Emsg("ERROR " + e.toString(), out);
    184                                 }
    185                         } catch (Exception e) {
    186                                 // bail on anything else
    187                         }
     174                                } catch (I2PException e) {
     175                                        Emsg(e.toString(), out);
     176                                } catch (ConnectException e) {
     177                                        Emsg(e.toString(), out);
     178                                } catch (NoRouteToHostException e) {
     179                                        Emsg(e.toString(), out);
     180                                }
     181
     182                        } catch (InterruptedIOException e) {
     183                                // We're breaking away.
     184                        } catch (InterruptedException e) {
     185                                // ditto
     186                        } catch (IOException e) {
     187                                try {
     188                                        Emsg(e.toString(), out);
     189                                } catch (IOException ex) {
     190                                        // ditto
     191                                }
     192                        } catch (DataFormatException e) {
     193                                try {
     194                                        Emsg(e.toString(), out);
     195                                } catch (IOException ex) {
     196                                        // ditto
     197                                }
     198                        }
     199
    188200                } finally {
    189201                        try {
  • history.txt

    r51faed2 r7151590  
     12009-06-08 sponge
     2    * Fixed NPE and some other goofups in BOB.
     3    * BOB bump version
     4
    152009-06-07 zzz
    26    * Build file:
  • router/java/src/net/i2p/router/RouterVersion.java

    r51faed2 r7151590  
    1919    public final static String ID = "Monotone";
    2020    public final static String VERSION = CoreVersion.VERSION;
    21     public final static long BUILD = 15;
     21    public final static long BUILD = 16;
    2222    /** for example "-test" */
    2323    public final static String EXTRA = "-rc";
Note: See TracChangeset for help on using the changeset viewer.