Changeset 8f690a8


Ignore:
Timestamp:
Apr 8, 2009 11:55:51 AM (11 years ago)
Author:
sponge <sponge@…>
Branches:
master
Children:
0f1f33e, 977d6eec
Parents:
f9f9aa4
Message:

2009-04-08 sponge

  • More hopeful fixups to the infamous orpahned tunnel problem. *Sigh*
Files:
4 edited

Legend:

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

    rf9f9aa4 r8f690a8  
    4949        /**
    5050         * Constructor
     51         * @param SS
    5152         * @param S
    5253         * @param info
     
    5455         * @param _log
    5556         */
    56         I2Plistener(I2PSocketManager S, NamedDB info, NamedDB database, Log _log) {
     57        I2Plistener(I2PServerSocket SS, I2PSocketManager S, NamedDB info, NamedDB database, Log _log) {
    5758                this.database = database;
    5859                this.info = info;
    5960                this._log = _log;
    6061                this.socketManager = S;
    61                 serverSocket = this.socketManager.getServerSocket();
     62                serverSocket = SS;
    6263                tgwatch = 1;
    6364        }
     
    7172                database.releaseReadLock();
    7273                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();
    8374        }
    8475
  • apps/BOB/src/net/i2p/BOB/MUXlisten.java

    rf9f9aa4 r8f690a8  
    2929import java.net.ServerSocket;
    3030import java.util.Properties;
     31import java.util.logging.Level;
     32import java.util.logging.Logger;
    3133import net.i2p.I2PException;
     34import net.i2p.client.streaming.I2PServerSocket;
    3235import net.i2p.client.streaming.I2PSocketManager;
    3336import net.i2p.client.streaming.I2PSocketManagerFactory;
     
    7477                this.info.getReadLock();
    7578                N = this.info.get("NICKNAME").toString();
    76                 prikey = new ByteArrayInputStream((byte[])info.get("KEYS"));
     79                prikey = new ByteArrayInputStream((byte[]) info.get("KEYS"));
    7780                // Make a new copy so that anything else won't muck with our database.
    78                 Properties R = (Properties)info.get("PROPERTIES");
     81                Properties R = (Properties) info.get("PROPERTIES");
    7982                Properties Q = new Properties();
    8083                Lifted.copyProperties(R, Q);
     
    8689                this.go_out = info.exists("OUTPORT");
    8790                this.come_in = info.exists("INPORT");
    88                 if(this.come_in) {
     91                if (this.come_in) {
    8992                        port = Integer.parseInt(info.get("INPORT").toString());
    9093                        host = InetAddress.getByName(info.get("INHOST").toString());
     
    9497
    9598                socketManager = I2PSocketManagerFactory.createManager(prikey, Q);
    96                 if(this.come_in) {
     99                if (this.come_in) {
    97100                        this.listener = new ServerSocket(port, backlog, host);
    98101                }
     
    131134         */
    132135        public void run() {
    133 
     136                I2PServerSocket SS = null;
    134137                try {
    135138                        wlock();
     
    137140                                info.add("RUNNING", new Boolean(true));
    138141                                info.add("STARTING", new Boolean(false));
    139                         } catch(Exception e) {
     142                        } catch (Exception e) {
    140143                                wunlock();
    141144                                return;
    142145                        }
    143                 } catch(Exception e) {
     146                } catch (Exception e) {
    144147                        return;
    145148                }
    146149                try {
    147150                        wunlock();
    148                 } catch(Exception e) {
     151                } catch (Exception e) {
    149152                        return;
    150153                }
    151 
    152 quit:           {
     154//              socketManager.addDisconnectListener(new DisconnectListener());
     155
     156quit:
     157                {
    153158                        try {
    154159                                tg = new ThreadGroup(N);
    155 die:                            {
     160die:
     161                                {
    156162                                        // toss the connections to a new threads.
    157163                                        // will wrap with TCP and UDP when UDP works
    158164
    159                                         if(go_out) {
     165                                        if (go_out) {
    160166                                                // I2P -> TCP
    161                                                 I2Plistener conn = new I2Plistener(socketManager, info, database, _log);
     167                                                SS = socketManager.getServerSocket();
     168                                                I2Plistener conn = new I2Plistener(SS, socketManager, info, database, _log);
    162169                                                Thread t = new Thread(tg, conn, "BOBI2Plistener " + N);
    163170                                                t.start();
    164171                                        }
    165172
    166                                         if(come_in) {
     173                                        if (come_in) {
    167174                                                // TCP -> I2P
    168175                                                TCPlistener conn = new TCPlistener(listener, socketManager, info, database, _log);
     
    172179
    173180                                        boolean spin = true;
    174                                         while(spin) {
     181                                        while (spin) {
    175182                                                try {
    176183                                                        Thread.sleep(200); //sleep for 200 ms (Two thenths second)
    177                                                 } catch(InterruptedException e) {
     184                                                } catch (InterruptedException e) {
    178185                                                        // nop
    179186                                                }
     
    182189                                                        try {
    183190                                                                spin = info.get("STOPPING").equals(Boolean.FALSE);
    184                                                         } catch(Exception e) {
     191                                                        } catch (Exception e) {
    185192                                                                runlock();
    186193                                                                break die;
    187194                                                        }
    188                                                 } catch(Exception e) {
     195                                                } catch (Exception e) {
    189196                                                        break die;
    190197                                                }
    191198                                                try {
    192199                                                        runlock();
    193                                                 } catch(Exception e) {
     200                                                } catch (Exception e) {
    194201                                                        break die;
    195202                                                }
     
    200207                                                try {
    201208                                                        info.add("RUNNING", new Boolean(false));
    202                                                 } catch(Exception e) {
     209                                                } catch (Exception e) {
    203210                                                        wunlock();
    204211                                                        break die;
    205212                                                }
    206                                         } catch(Exception e) {
     213                                        } catch (Exception e) {
    207214                                                break die;
    208215                                        }
    209216                                        try {
    210217                                                wunlock();
    211                                         } catch(Exception e) {
     218                                        } catch (Exception e) {
    212219                                                break die;
    213220                                        }
    214221                                } // die
    215222
    216                                 try {
    217                                         Thread.sleep(500); //sleep for 500 ms (One half second)
    218                                 } catch(InterruptedException ex) {
    219                                         // nop
    220                                 }
     223//                              try {
     224//                                      Thread.sleep(500); //sleep for 500 ms (One half second)
     225//                              } catch (InterruptedException ex) {
     226//                                      // nop
     227//                              }
    221228                                // wait for child threads and thread groups to die
    222229                                // System.out.println("MUXlisten: waiting for children");
    223                                 if(tg.activeCount() + tg.activeGroupCount() != 0) {
    224                                         tg.interrupt(); // unwedge any blocking threads.
    225                                         while(tg.activeCount() + tg.activeGroupCount() != 0) {
     230                                if (tg.activeCount() + tg.activeGroupCount() != 0) {
     231                                        while (tg.activeCount() + tg.activeGroupCount() != 0) {
     232                                                tg.interrupt(); // unwedge any blocking threads.
    226233                                                try {
    227234                                                        Thread.sleep(100); //sleep for 100 ms (One tenth second)
    228                                                 } catch(InterruptedException ex) {
    229                                                         // nop
     235                                                } catch (InterruptedException ex) {
     236                                                        // NOP
    230237                                                }
    231238                                        }
     
    234241                                // Zap reference to the ThreadGroup so the JVM can GC it.
    235242                                tg = null;
    236                         } catch(Exception e) {
     243                        } catch (Exception e) {
    237244                                // System.out.println("MUXlisten: Caught an exception" + e);
    238245                                break quit;
     
    240247                } // quit
    241248                // This is here to catch when something fucks up REALLY bad.
    242                 if(tg != null) {
     249                if (tg != null) {
    243250                        System.out.println("BOB: MUXlisten: Something fucked up REALLY bad!");
    244251                        System.out.println("BOB: MUXlisten: Please email the following dump to sponge@mail.i2p");
     
    247254                        System.out.println("BOB: MUXlisten: Please email the above dump to sponge@mail.i2p");
    248255                }
    249                         // zero out everything, just incase.
     256
     257                // This is here to catch when something fucks up REALLY bad.
     258                if (tg != null) {
     259                        if (tg.activeCount() + tg.activeGroupCount() != 0) {
     260                                tg.interrupt(); // unwedge any blocking threads.
     261                                while (tg.activeCount() + tg.activeGroupCount() != 0) {
     262                                        try {
     263                                                Thread.sleep(100); //sleep for 100 ms (One tenth second)
     264                                        } catch (InterruptedException ex) {
     265                                                // nop
     266                                        }
     267                                }
     268                        }
     269                        tg.destroy();
     270                        // Zap reference to the ThreadGroup so the JVM can GC it.
     271                        tg = null;
     272                }
     273
     274                if (SS != null) {
     275                        try {
     276                                SS.close();
     277                        } catch (I2PException ex) {
     278                                //Logger.getLogger(MUXlisten.class.getName()).log(Level.SEVERE, null, ex);
     279                        }
     280                }
     281                // Lastly try to close things again.
     282                if (this.come_in) {
     283                        try {
     284                                listener.close();
     285                        } catch (IOException e) {
     286                        }
     287                }
    250288                try {
    251289                        socketManager.destroySocketManager();
    252                 } catch(Exception e) {
     290                } catch (Exception e) {
    253291                        // nop
    254292                }
     293                // zero out everything.
    255294                try {
    256295                        wlock();
     
    259298                                info.add("STOPPING", new Boolean(false));
    260299                                info.add("RUNNING", new Boolean(false));
    261                         } catch(Exception e) {
     300                        } catch (Exception e) {
    262301                                wunlock();
    263302                                return;
    264303                        }
    265304                        wunlock();
    266                 } catch(Exception e) {
    267                 }
    268                 // This is here to catch when something fucks up REALLY bad.
    269                 if(tg != null) {
    270                         if(tg.activeCount() + tg.activeGroupCount() != 0) {
    271                                         tg.interrupt(); // unwedge any blocking threads.
    272                                 while(tg.activeCount() + tg.activeGroupCount() != 0) {
    273                                         try {
    274                                                 Thread.sleep(100); //sleep for 100 ms (One tenth second)
    275                                         } catch(InterruptedException ex) {
    276                                                 // nop
    277                                         }
    278                                 }
    279                         }
    280                         tg.destroy();
    281                         // Zap reference to the ThreadGroup so the JVM can GC it.
    282                         tg = null;
    283                 }
    284 
    285                 // Lastly try to close things again.
    286                 if(this.come_in) {
    287                         try {
    288                                 listener.close();
    289                         } catch(IOException e) {
    290                         }
    291                 }
    292                 try {
    293                         socketManager.destroySocketManager();
    294                 } catch(Exception e) {
    295                         // nop
    296                 }
    297 
    298         }
     305                } catch (Exception e) {
     306                }
     307
     308        }
     309
     310//      private class DisconnectListener implements I2PSocketManager.DisconnectListener {
     311//
     312//              public void sessionDisconnected() {
     313//                      close();
     314//              }
     315//      }
     316//      public void close() {
     317//              socketManager.destroySocketManager();
     318//      }
    299319}
  • history.txt

    rf9f9aa4 r8f690a8  
     12009-04-08 sponge
     2    * More hopeful fixups to the infamous orpahned tunnel problem. *Sigh*
     3
    142009-04-08 zzz
    25    * IPV6/localhost:
  • router/java/src/net/i2p/router/RouterVersion.java

    rf9f9aa4 r8f690a8  
    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 = 13;
     20    public final static long BUILD = 14;
    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.