Changeset bd489cf


Ignore:
Timestamp:
Apr 4, 2009 7:47:36 PM (11 years ago)
Author:
sponge <sponge@…>
Branches:
master
Children:
884663d0
Parents:
a4b5c63
Message:

2009-04-04 sponge

  • Hopeful fixups to the infamous orpahned tunnel problem.
  • BOB now 0.0.5
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • apps/BOB/nbproject/project.properties

    ra4b5c63 rbd489cf  
    2828file.reference.i2p.jar=../../core/java/build/i2p.jar
    2929file.reference.i2ptunnel.jar=../i2ptunnel/java/build/i2ptunnel.jar
     30file.reference.jbigi.jar=../../installer/lib/jbigi/jbigi.jar
    3031file.reference.mstreaming.jar=../ministreaming/java/build/mstreaming.jar
    3132file.reference.router.jar=../../router/java/build/router.jar
  • apps/BOB/src/net/i2p/BOB/BOB.java

    ra4b5c63 rbd489cf  
    3535import net.i2p.client.streaming.RetransmissionTimer;
    3636import net.i2p.util.Log;
     37
    3738/**
    3839 * <span style="font-size:8px;font-family:courier;color:#EEEEEE;background-color:#000000">
     
    158159                // Set up all defaults to be passed forward to other threads.
    159160                // Re-reading the config file in each thread is pretty damn stupid.
    160                 // I2PClient client = I2PClientFactory.createClient();
    161161                String configLocation = System.getProperty(PROP_CONFIG_LOCATION, "bob.config");
    162162
     
    164164                RetransmissionTimer Y = RetransmissionTimer.getInstance();
    165165                i = Y.hashCode();
     166
    166167                {
    167168                        try {
  • apps/BOB/src/net/i2p/BOB/DoCMDS.java

    ra4b5c63 rbd489cf  
    4747        // FIX ME
    4848        // I need a better way to do versioning, but this will do for now.
    49         public static final String BMAJ = "00",  BMIN = "00",  BREV = "04",  BEXT = "";
     49        public static final String BMAJ = "00",  BMIN = "00",  BREV = "05",  BEXT = "";
    5050        public static final String BOBversion = BMAJ + "." + BMIN + "." + BREV + BEXT;
    5151        private Socket server;
  • apps/BOB/src/net/i2p/BOB/I2Plistener.java

    ra4b5c63 rbd489cf  
    6363        }
    6464
     65        private void rlock() throws Exception {
     66                database.getReadLock();
     67                info.getReadLock();
     68        }
     69
     70        private void runlock() throws Exception {
     71                database.releaseReadLock();
     72                info.releaseReadLock();
     73        }
     74
     75        private void wlock() throws Exception {
     76                database.getWriteLock();
     77                info.getWriteLock();
     78        }
     79
     80        private void wunlock() throws Exception {
     81                info.releaseWriteLock();
     82                database.releaseWriteLock();
     83        }
     84
    6585        /**
    6686         * Simply listen on I2P port, and thread connections
     
    7191                I2PSocket sessSocket = null;
    7292
    73                 serverSocket.setSoTimeout(50);
    74                 database.getReadLock();
    75                 info.getReadLock();
    76                 if(info.exists("INPORT")) {
    77                         tgwatch = 2;
    78                 }
    79                 info.releaseReadLock();
    80                 database.releaseReadLock();
    81                 boolean spin = true;
    82                 while(spin) {
     93die:            {
    8394
    84                         database.getReadLock();
    85                         info.getReadLock();
    86                         spin = info.get("RUNNING").equals(Boolean.TRUE);
    87                         info.releaseReadLock();
    88                         database.releaseReadLock();
     95                        serverSocket.setSoTimeout(50);
    8996                        try {
     97                                if (info.exists("INPORT")) {
     98                                        tgwatch = 2;
     99                                }
     100                        } catch (Exception e) {
    90101                                try {
    91                                         sessSocket = serverSocket.accept();
    92                                         g = true;
    93                                 } catch(ConnectException ce) {
    94                                         g = false;
    95                                 } catch(SocketTimeoutException ste) {
    96                                         g = false;
     102                                        runlock();
     103                                } catch (Exception e2) {
     104                                        break die;
    97105                                }
    98                                 if(g) {
    99                                         g = false;
    100                                         // toss the connection to a new thread.
    101                                         I2PtoTCP conn_c = new I2PtoTCP(sessSocket, info, database);
    102                                         Thread t = new Thread(conn_c, "BOBI2PtoTCP");
    103                                         t.start();
     106                                break die;
     107                        }
     108                        boolean spin = true;
     109                        while (spin) {
     110
     111                                try {
     112                                        rlock();
     113                                } catch (Exception e) {
     114                                        break die;
    104115                                }
     116                                try {
     117                                        spin = info.get("RUNNING").equals(Boolean.TRUE);
     118                                } catch (Exception e) {
     119                                        try {
     120                                                runlock();
     121                                        } catch (Exception e2) {
     122                                                break die;
     123                                        }
     124                                        break die;
     125                                }
     126                                try {
     127                                        try {
     128                                                sessSocket = serverSocket.accept();
     129                                                g = true;
     130                                        } catch (ConnectException ce) {
     131                                                g = false;
     132                                        } catch (SocketTimeoutException ste) {
     133                                                g = false;
     134                                        }
     135                                        if (g) {
     136                                                g = false;
     137                                                // toss the connection to a new thread.
     138                                                I2PtoTCP conn_c = new I2PtoTCP(sessSocket, info, database);
     139                                                Thread t = new Thread(conn_c, "BOBI2PtoTCP");
     140                                                t.start();
     141                                        }
    105142
    106                         } catch(I2PException e) {
    107                                 //      System.out.println("Exception " + e);
     143                                } catch (I2PException e) {
     144                                        //      System.out.println("Exception " + e);
     145                                }
    108146                        }
    109147                }
     
    111149                try {
    112150                        serverSocket.close();
    113                 } catch(I2PException e) {
     151                } catch (I2PException e) {
    114152                        // nop
    115153                }
    116154                // need to kill off the socket manager too.
    117155                I2PSession session = socketManager.getSession();
    118                 if(session != null) {
     156                if (session != null) {
    119157                        // System.out.println("I2Plistener: destroySession");
    120158                        try {
    121159                                session.destroySession();
    122                         } catch(I2PSessionException ex) {
     160                        } catch (I2PSessionException ex) {
    123161                                // nop
    124162                        }
    125163                }
    126164                // System.out.println("I2Plistener: Waiting for children");
    127                 while(Thread.activeCount() > tgwatch) { // wait for all threads in our threadgroup to finish
     165                while (Thread.activeCount() > tgwatch) { // wait for all threads in our threadgroup to finish
    128166                        try {
    129167                                Thread.sleep(100); //sleep for 100 ms (One tenth second)
    130                         } catch(Exception e) {
     168                        } catch (Exception e) {
    131169                                // nop
    132170                        }
    133171                }
    134172
    135                 // System.out.println("I2Plistener: Done.");
     173        // System.out.println("I2Plistener: Done.");
    136174        }
    137175}
  • apps/BOB/src/net/i2p/BOB/I2PtoTCP.java

    ra4b5c63 rbd489cf  
    106106                                }
    107107                                // setup to cross the streams
    108                                 TCPio conn_c = new TCPio(in, Iout, info, database); // app -> I2P
    109                                 TCPio conn_a = new TCPio(Iin, out, info, database); // I2P -> app
     108                                TCPio conn_c = new TCPio(in, Iout /*, info, database */ ); // app -> I2P
     109                                TCPio conn_a = new TCPio(Iin, out /* , info, database */); // I2P -> app
    110110                                Thread t = new Thread(conn_c, "TCPioA");
    111111                                Thread q = new Thread(conn_a, "TCPioB");
  • apps/BOB/src/net/i2p/BOB/MUXlisten.java

    ra4b5c63 rbd489cf  
    101101                this.database.getWriteLock();
    102102                this.info.getWriteLock();
    103                 this.info.add("STARTING", Boolean.TRUE);
     103                this.info.add("STARTING", new Boolean(true));
    104104                this.info.releaseWriteLock();
    105105                this.database.releaseWriteLock();
     
    135135                        wlock();
    136136                        try {
    137                                 info.add("RUNNING", Boolean.TRUE);
    138                                 info.add("STARTING", Boolean.FALSE);
     137                                info.add("RUNNING", new Boolean(true));
     138                                info.add("STARTING", new Boolean(false));
    139139                        } catch(Exception e) {
    140140                                wunlock();
     
    199199                                                wlock();
    200200                                                try {
    201                                                         info.add("RUNNING", Boolean.FALSE);
     201                                                        info.add("RUNNING", new Boolean(false));
    202202                                                } catch(Exception e) {
    203203                                                        wunlock();
     
    256256                        wlock();
    257257                        try {
    258                                 info.add("STARTING", Boolean.FALSE);
    259                                 info.add("STOPPING", Boolean.FALSE);
    260                                 info.add("RUNNING", Boolean.FALSE);
     258                                info.add("STARTING", new Boolean(false));
     259                                info.add("STOPPING", new Boolean(false));
     260                                info.add("RUNNING", new Boolean(false));
    261261                        } catch(Exception e) {
    262262                                wunlock();
  • apps/BOB/src/net/i2p/BOB/Main.java

    ra4b5c63 rbd489cf  
    2525
    2626import net.i2p.client.streaming.RetransmissionTimer;
    27 
     27import net.i2p.util.SimpleScheduler;
    2828/**
    2929 * Start from command line
     
    4040                // THINK THINK THINK THINK THINK THINK
    4141                RetransmissionTimer Y = RetransmissionTimer.getInstance();
     42                // needs SimpleScheduler
     43                // no way to stop the scheduler?!?
     44                SimpleScheduler.getInstance();
    4245                BOB.main(args);
    4346                Y.stop();
  • apps/BOB/src/net/i2p/BOB/TCPio.java

    ra4b5c63 rbd489cf  
    3636        private InputStream Ain;
    3737        private OutputStream Aout;
    38         private NamedDB info,  database;
     38        // private NamedDB info,  database;
    3939
    4040        /**
     
    4444         * @param Aout
    4545         * @param info
    46          * @param database
     46         *
     47         * param database
    4748         */
    48         TCPio(InputStream Ain, OutputStream Aout, NamedDB info, NamedDB database) {
     49        TCPio(InputStream Ain, OutputStream Aout /*, NamedDB info , NamedDB database */) {
    4950                this.Ain = Ain;
    5051                this.Aout = Aout;
    51                 this.info = info;
    52                 this.database = database;
     52                // this.info = info;
     53                // this.database = database;
    5354        }
    5455
     
    8788                try {
    8889                        while(spin) {
    89                                 database.getReadLock();
    90                                 info.getReadLock();
    91                                 spin = info.get("RUNNING").equals(Boolean.TRUE);
    92                                 info.releaseReadLock();
    93                                 database.releaseReadLock();
     90                                // database.getReadLock();
     91                                // info.getReadLock();
     92                                // spin = info.get("RUNNING").equals(Boolean.TRUE);
     93                                // info.releaseReadLock();
     94                                // database.releaseReadLock();
    9495                                b = Ain.read(a, 0, 1);
    9596                                // System.out.println(info.get("NICKNAME").toString() + " " + b);
  • apps/BOB/src/net/i2p/BOB/TCPlistener.java

    ra4b5c63 rbd489cf  
    6464        }
    6565
     66        private void rlock() throws Exception {
     67                database.getReadLock();
     68                info.getReadLock();
     69        }
     70
     71        private void runlock() throws Exception {
     72                database.releaseReadLock();
     73                info.releaseReadLock();
     74        }
     75
     76        private void wlock() throws Exception {
     77                database.getWriteLock();
     78                info.getWriteLock();
     79        }
     80
     81        private void wunlock() throws Exception {
     82                info.releaseWriteLock();
     83                database.releaseWriteLock();
     84        }
     85
    6686        /**
    6787         * Simply listen on TCP port, and thread connections
     
    7191                boolean g = false;
    7292                boolean spin = true;
    73                 database.getReadLock();
    74                 info.getReadLock();
    75                 if(info.exists("OUTPORT")) {
    76                         tgwatch = 2;
     93
     94die:            {
     95                        try {
     96                                rlock();
     97                        } catch (Exception e) {
     98                                break die;
     99                        }
     100                        try {
     101                                if (info.exists("OUTPORT")) {
     102                                        tgwatch = 2;
     103                                }
     104                        } catch (Exception e) {
     105                                try {
     106                                        runlock();
     107                                } catch (Exception e2) {
     108                                        break die;
     109                                }
     110                                break die;
     111                        }
     112                        try {
     113                                runlock();
     114                        } catch (Exception e) {
     115                                break die;
     116                        }
     117                        try {
     118                                Socket server = new Socket();
     119                                listener.setSoTimeout(50); // Half of the expected time from MUXlisten
     120                                while (spin) {
     121                                        try {
     122                                                rlock();
     123                                        } catch (Exception e) {
     124                                                break die;
     125                                        }
     126                                        try {
     127                                                spin = info.get("RUNNING").equals(Boolean.TRUE);
     128                                        } catch (Exception e) {
     129                                                try {
     130                                                        runlock();
     131                                                } catch (Exception e2) {
     132                                                        break die;
     133                                                }
     134                                                break die;
     135                                        }
     136                                        try {
     137                                                server = listener.accept();
     138                                                g = true;
     139                                        } catch (SocketTimeoutException ste) {
     140                                                g = false;
     141                                        }
     142                                        if (g) {
     143                                                // toss the connection to a new thread.
     144                                                TCPtoI2P conn_c = new TCPtoI2P(socketManager, server /* , info, database */);
     145                                                Thread t = new Thread(conn_c, "BOBTCPtoI2P");
     146                                                t.start();
     147                                                g = false;
     148                                        }
     149                                }
     150                                //System.out.println("TCPlistener: destroySession");
     151                                listener.close();
     152                        } catch (IOException ioe) {
     153                                try {
     154                                        listener.close();
     155                                } catch (IOException e) {
     156                                }
     157                                // Fatal failure, cause a stop event
     158                                try {
     159                                        rlock();
     160                                        try {
     161                                                spin = info.get("RUNNING").equals(Boolean.TRUE);
     162                                        } catch (Exception e) {
     163                                                runlock();
     164                                                break die;
     165                                        }
     166                                } catch (Exception e) {
     167                                        break die;
     168                                }
     169                                if (spin) {
     170                                        try {
     171                                                wlock();
     172                                                try {
     173                                                        info.add("STOPPING", new Boolean(true));
     174                                                        info.add("RUNNING", new Boolean(false));
     175                                                } catch (Exception e) {
     176                                                        wunlock();
     177                                                        break die;
     178                                                }
     179                                        } catch (Exception e) {
     180                                                break die;
     181                                        }
     182                                        try {
     183                                                wunlock();
     184                                        } catch (Exception e) {
     185                                                break die;
     186                                        }
     187                                }
     188                        }
    77189                }
    78                 try {
    79                         Socket server = new Socket();
    80                         listener.setSoTimeout(50); // Half of the expected time from MUXlisten
    81                         info.releaseReadLock();
    82                         database.releaseReadLock();
    83                         while(spin) {
    84                                 database.getReadLock();
    85                                 info.getReadLock();
    86                                 spin = info.get("RUNNING").equals(Boolean.TRUE);
    87                                 info.releaseReadLock();
    88                                 database.releaseReadLock();
    89                                 try {
    90                                         server = listener.accept();
    91                                         g = true;
    92                                 } catch(SocketTimeoutException ste) {
    93                                         g = false;
    94                                 }
    95                                 if(g) {
    96                                         // toss the connection to a new thread.
    97                                         TCPtoI2P conn_c = new TCPtoI2P(socketManager, server, info, database);
    98                                         Thread t = new Thread(conn_c, "BOBTCPtoI2P");
    99                                         t.start();
    100                                         g = false;
    101                                 }
    102                         }
    103                         //System.out.println("TCPlistener: destroySession");
    104                         listener.close();
    105                 } catch(IOException ioe) {
    106                         try {
    107                                 listener.close();
    108                         } catch(IOException e) {
    109                         }
    110                         // Fatal failure, cause a stop event
    111                         database.getReadLock();
    112                         info.getReadLock();
    113                         spin = info.get("RUNNING").equals(Boolean.TRUE);
    114                         info.releaseReadLock();
    115                         database.releaseReadLock();
    116                         if(spin) {
    117                                 database.getWriteLock();
    118                                 info.getWriteLock();
    119                                 info.add("STOPPING", new Boolean(true));
    120                                 info.add("RUNNING", new Boolean(false));
    121                                 info.releaseWriteLock();
    122                                 database.releaseWriteLock();
    123                         }
    124                 }
    125 
    126190                // need to kill off the socket manager too.
    127191                I2PSession session = socketManager.getSession();
    128                 if(session != null) {
     192                if (session != null) {
    129193                        try {
    130194                                session.destroySession();
    131                         } catch(I2PSessionException ex) {
     195                        } catch (I2PSessionException ex) {
    132196                                // nop
    133197                        }
    134198                }
    135199                //System.out.println("TCPlistener: Waiting for children");
    136                 while(Thread.activeCount() > tgwatch) { // wait for all threads in our threadgroup to finish
     200                while (Thread.activeCount() > tgwatch) { // wait for all threads in our threadgroup to finish
    137201                        try {
    138202                                Thread.sleep(100); //sleep for 100 ms (One tenth second)
    139                         } catch(Exception e) {
     203                        } catch (Exception e) {
    140204                                // nop
    141                                 }
     205                        }
    142206                }
    143                 //System.out.println("TCPlistener: Done.");
     207        //System.out.println("TCPlistener: Done.");
    144208        }
    145209}
  • apps/BOB/src/net/i2p/BOB/TCPtoI2P.java

    ra4b5c63 rbd489cf  
    4646
    4747        private I2PSocket I2P;
    48         private NamedDB info,  database;
     48        // private NamedDB info,  database;
    4949        private Socket sock;
    5050        private I2PSocketManager socketManager;
     
    8585         * @param i2p
    8686         * @param socket
    87          * @param info
    88          * @param database
     87         * param info
     88         * param database
    8989         */
    90         TCPtoI2P(I2PSocketManager i2p, Socket socket, NamedDB info, NamedDB database) {
     90        TCPtoI2P(I2PSocketManager i2p, Socket socket /*, NamedDB info, NamedDB database */) {
    9191                this.sock = socket;
    92                 this.info = info;
    93                 this.database = database;
     92                // this.info = info;
     93                // this.database = database;
    9494                this.socketManager = i2p;
    9595        }
     
    111111        /**
    112112         * TCP stream to I2P stream thread starter
     113         *
    113114         */
    114115        public void run() {
     
    139140                                        OutputStream Iout = I2P.getOutputStream();
    140141                                        // setup to cross the streams
    141                                         TCPio conn_c = new TCPio(in, Iout, info, database); // app -> I2P
    142                                         TCPio conn_a = new TCPio(Iin, out, info, database); // I2P -> app
     142                                        TCPio conn_c = new TCPio(in, Iout /*, info, database */); // app -> I2P
     143                                        TCPio conn_a = new TCPio(Iin, out /*, info, database */); // I2P -> app
    143144                                        Thread t = new Thread(conn_c, "TCPioA");
    144145                                        Thread q = new Thread(conn_a, "TCPioB");
     
    168169                                Emsg("ERROR " + e.toString(), out);
    169170                        }
    170                 } catch(IOException ioe) {
     171                } catch(Exception e) {
     172                        // bail on anything else
    171173                }
    172174                try {
     
    182184                }
    183185                // System.out.println("TCPtoI2P: Done.");
    184 
    185186        }
    186187}
  • router/java/src/net/i2p/router/RouterVersion.java

    ra4b5c63 rbd489cf  
    1818    public final static String ID = "$Revision: 1.548 $ $Date: 2008-06-07 23:00:00 $";
    1919    public final static String VERSION = CoreVersion.VERSION;
    20     public final static long BUILD = 7;
     20    public final static long BUILD = 8;
    2121    public static void main(String args[]) {
    2222        System.out.println("I2P Router version: " + VERSION + "-" + BUILD);
Note: See TracChangeset for help on using the changeset viewer.