Changeset 384d655


Ignore:
Timestamp:
Apr 10, 2009 11:12:41 PM (12 years ago)
Author:
sponge <sponge@…>
Branches:
master
Children:
56c6f41
Parents:
2a2d3c0
Message:

2009-04-10 sponge

  • More BOB threadgroup fixes, plus debug dump when things go wrong.
  • Fixes to streaminglib, I2CP, which are related to the TG problem.
  • JavaDocs? fixups.
Files:
18 edited

Legend:

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

    r2a2d3c0 r384d655  
    749749                                                                        if (!tunnelactive(nickinfo)) {
    750750                                                                                nickinfo = null;
    751                                                                                 ns =
    752                                                                                         true;
     751                                                                                ns = true;
    753752                                                                        }
    754753
    755754                                                                } catch (Exception b) {
    756755                                                                        nickinfo = null;
    757                                                                         ns =
    758                                                                                 true;
     756                                                                        ns = true;
    759757                                                                }
    760758
     
    776774                                                                                database.add(Arg, nickinfo);
    777775                                                                                nickinfo.add(P_NICKNAME, Arg);
    778                                                                                 nickinfo.add(P_STARTING, Boolean.FALSE);
    779                                                                                 nickinfo.add(P_RUNNING, Boolean.FALSE);
    780                                                                                 nickinfo.add(P_STOPPING, Boolean.FALSE);
    781                                                                                 nickinfo.add(P_QUIET, Boolean.FALSE);
     776                                                                                nickinfo.add(P_STARTING, new Boolean(false));
     777                                                                                nickinfo.add(P_RUNNING, new Boolean(false));
     778                                                                                nickinfo.add(P_STOPPING, new Boolean(false));
     779                                                                                nickinfo.add(P_QUIET, new Boolean(false));
    782780                                                                                nickinfo.add(P_INHOST, "localhost");
    783781                                                                                nickinfo.add(P_OUTHOST, "localhost");
     
    12661264                                                                                                Thread t = new Thread(tunnel);
    12671265                                                                                                t.start();
     1266                                                                                                try {
     1267                                                                                                        Thread.sleep(1000 * 10); // Slow down the startup.
     1268                                                                                                } catch(InterruptedException ie) {
     1269                                                                                                        // ignore it
     1270                                                                                                }
    12681271                                                                                                out.println("OK tunnel starting");
    12691272                                                                                        } catch (I2PException e) {
     
    12721275                                                                                                out.println("ERROR starting tunnel: " + e);
    12731276                                                                                        }
    1274 
    12751277                                                                                }
    12761278                                                                        } catch (Exception ex) {
     
    13051307                                                                                        }
    13061308
    1307                                                                                         nickinfo.add(P_STOPPING, Boolean.TRUE);
     1309                                                                                        nickinfo.add(P_STOPPING, new Boolean(true));
    13081310                                                                                        try {
    13091311                                                                                                wunlock();
  • apps/BOB/src/net/i2p/BOB/I2Plistener.java

    r2a2d3c0 r384d655  
    2727import java.net.SocketTimeoutException;
    2828import net.i2p.I2PException;
    29 import net.i2p.client.I2PSession;
    30 import net.i2p.client.I2PSessionException;
    3129import net.i2p.client.streaming.I2PServerSocket;
    3230import net.i2p.client.streaming.I2PSocket;
     
    4341        private NamedDB info,  database;
    4442        private Log _log;
    45         private int tgwatch;
     43//      private int tgwatch;
    4644        public I2PSocketManager socketManager;
    4745        public I2PServerSocket serverSocket;
     
    6159                this.socketManager = S;
    6260                serverSocket = SS;
    63                 tgwatch = 1;
     61//              tgwatch = 1;
    6462        }
    6563
     
    8583
    8684                        serverSocket.setSoTimeout(50);
    87                         try {
    88                                 if (info.exists("INPORT")) {
    89                                         tgwatch = 2;
    90                                 }
    91                         } catch (Exception e) {
    92                                 try {
    93                                         runlock();
    94                                 } catch (Exception e2) {
    95                                         break die;
    96                                 }
    97                                 break die;
    98                         }
     85//                      try {
     86//                              if (info.exists("INPORT")) {
     87//                                      tgwatch = 2;
     88//                              }
     89//                      } catch (Exception e) {
     90//                              try {
     91//                                      runlock();
     92//                              } catch (Exception e2) {
     93//                                      break die;
     94//                              }
     95//                              break die;
     96//                      }
    9997                        boolean spin = true;
    10098                        while (spin) {
     
    138136                }
    139137                // System.out.println("I2Plistener: Close");
    140                 try {
    141                         serverSocket.close();
    142                 } catch (I2PException e) {
     138
     139
     140                // Previous level does this cleanup now.
     141                //
     142                // try {
     143                //      serverSocket.close();
     144                // } catch (I2PException e) {
    143145                        // nop
    144                 }
     146                //}
    145147                // need to kill off the socket manager too.
    146                 I2PSession session = socketManager.getSession();
    147                 if (session != null) {
     148                // I2PSession session = socketManager.getSession();
     149                // if (session != null) {
    148150                        // System.out.println("I2Plistener: destroySession");
    149                         try {
    150                                 session.destroySession();
    151                         } catch (I2PSessionException ex) {
     151                //      try {
     152                //              session.destroySession();
     153                //      } catch (I2PSessionException ex) {
    152154                                // nop
    153                         }
    154                 }
     155                //      }
     156                //}
    155157                // System.out.println("I2Plistener: Waiting for children");
    156                 while (Thread.activeCount() > tgwatch) { // wait for all threads in our threadgroup to finish
    157                         try {
    158                                 Thread.sleep(100); //sleep for 100 ms (One tenth second)
    159                         } catch (Exception e) {
     158                // while (Thread.activeCount() > tgwatch) { // wait for all threads in our threadgroup to finish
     159                //      try {
     160                //              Thread.sleep(100); //sleep for 100 ms (One tenth second)
     161                //      } catch (Exception e) {
    160162                                // nop
    161                         }
    162                 }
     163                //      }
     164                //}
    163165
    164166        // System.out.println("I2Plistener: Done.");
  • apps/BOB/src/net/i2p/BOB/I2PtoTCP.java

    r2a2d3c0 r384d655  
    2424package net.i2p.BOB;
    2525
     26import java.io.IOException;
    2627import java.io.InputStream;
    2728import java.io.OutputStream;
     
    117118                                                Thread.sleep(10); //sleep for 10 ms
    118119                                        } catch(InterruptedException e) {
    119                                                 // nop
     120                                                try {
     121                                                        in.close();
     122                                                } catch(Exception ex) {
     123                                                }
     124                                                try {
     125                                                        out.close();
     126                                                } catch(Exception ex) {
     127                                                }
     128                                                try {
     129                                                        Iin.close();
     130                                                } catch(Exception ex) {
     131                                                }
     132                                                try {
     133                                                        Iout.close();
     134                                                } catch(Exception ex) {
     135                                                }
    120136                                        }
    121137                                }
  • apps/BOB/src/net/i2p/BOB/MUXlisten.java

    r2a2d3c0 r384d655  
    2929import java.net.ServerSocket;
    3030import java.util.Properties;
    31 import java.util.logging.Level;
    32 import java.util.logging.Logger;
    3331import net.i2p.I2PException;
     32import net.i2p.client.I2PSession;
     33import net.i2p.client.I2PSessionException;
    3434import net.i2p.client.streaming.I2PServerSocket;
    3535import net.i2p.client.streaming.I2PSocketManager;
    3636import net.i2p.client.streaming.I2PSocketManagerFactory;
    3737import net.i2p.util.Log;
    38 import org.tanukisoftware.wrapper.WrapperManager;
    3938
    4039/**
     
    6059         * Constructor Will fail if INPORT is occupied.
    6160         *
    62          * @param info
    63          * @param database
     61         * @param info DB entry for this tunnel
     62         * @param database master database of tunnels
    6463         * @param _log
    6564         * @throws net.i2p.I2PException
     
    135134        public void run() {
    136135                I2PServerSocket SS = null;
     136                int ticks = 1200; // Allow 120 seconds, no more.
    137137                try {
    138138                        wlock();
    139139                        try {
    140140                                info.add("RUNNING", new Boolean(true));
    141                                 info.add("STARTING", new Boolean(false));
    142141                        } catch (Exception e) {
    143142                                wunlock();
     
    178177                                        }
    179178
     179                                        try {
     180                                                wlock();
     181                                                try {
     182                                                        info.add("STARTING", new Boolean(false));
     183                                                } catch (Exception e) {
     184                                                        wunlock();
     185                                                        break die;
     186                                                }
     187                                        } catch (Exception e) {
     188                                                break die;
     189                                        }
     190                                        try {
     191                                                wunlock();
     192                                        } catch (Exception e) {
     193                                                break die;
     194                                        }
    180195                                        boolean spin = true;
    181196                                        while (spin) {
    182197                                                try {
    183                                                         Thread.sleep(200); //sleep for 200 ms (Two thenths second)
     198                                                        Thread.sleep(1000); //sleep for 1 second
    184199                                                } catch (InterruptedException e) {
    185                                                         // nop
     200                                                        break die;
    186201                                                }
    187202                                                try {
     
    221236                                } // die
    222237
    223 //                              try {
    224 //                                      Thread.sleep(500); //sleep for 500 ms (One half second)
    225 //                              } catch (InterruptedException ex) {
    226 //                                      // nop
    227 //                              }
    228                                 // wait for child threads and thread groups to die
     238                                if (SS != null) {
     239                                        try {
     240                                                SS.close();
     241                                        } catch (I2PException ex) {
     242                                                //Logger.getLogger(MUXlisten.class.getName()).log(Level.SEVERE, null, ex);
     243                                        }
     244                                }
     245                                if (this.come_in) {
     246                                        try {
     247                                                listener.close();
     248                                        } catch (IOException e) {
     249                                        }
     250                                }
     251
     252                                I2PSession session = socketManager.getSession();
     253                                if (session != null) {
     254                                        // System.out.println("I2Plistener: destroySession");
     255                                        try {
     256                                                session.destroySession();
     257                                        } catch (I2PSessionException ex) {
     258                                        // nop
     259                                        }
     260                                }
     261                                try {
     262                                        socketManager.destroySocketManager();
     263                                } catch (Exception e) {
     264                                        // nop
     265                                }
     266                                // Wait for child threads and thread groups to die
    229267                                // System.out.println("MUXlisten: waiting for children");
    230268                                if (tg.activeCount() + tg.activeGroupCount() != 0) {
    231                                         while (tg.activeCount() + tg.activeGroupCount() != 0) {
     269                                        while ((tg.activeCount() + tg.activeGroupCount() != 0) && ticks != 0) {
    232270                                                tg.interrupt(); // unwedge any blocking threads.
     271                                                ticks--;
    233272                                                try {
    234273                                                        Thread.sleep(100); //sleep for 100 ms (One tenth second)
    235274                                                } catch (InterruptedException ex) {
    236                                                         // NOP
    237                                                 }
     275                                                        break quit;
     276                                                }
     277                                        }
     278                                        if (tg.activeCount() + tg.activeGroupCount() != 0) {
     279                                                break quit; // Uh-oh.
    238280                                        }
    239281                                }
     
    246288                        }
    247289                } // quit
     290
    248291                // This is here to catch when something fucks up REALLY bad.
    249292                if (tg != null) {
    250                         System.out.println("BOB: MUXlisten: Something fucked up REALLY bad!");
    251                         System.out.println("BOB: MUXlisten: Please email the following dump to sponge@mail.i2p");
    252                         WrapperManager.requestThreadDump();
    253                         System.out.println("BOB: MUXlisten: Something fucked up REALLY bad!");
    254                         System.out.println("BOB: MUXlisten: Please email the above dump to sponge@mail.i2p");
    255                 }
    256 
    257                 // This is here to catch when something fucks up REALLY bad.
    258                 if (tg != null) {
     293                        if (SS != null) {
     294                                try {
     295                                        SS.close();
     296                                } catch (I2PException ex) {
     297                                        //Logger.getLogger(MUXlisten.class.getName()).log(Level.SEVERE, null, ex);
     298                                }
     299                        }
     300                        if (this.come_in) {
     301                                try {
     302                                        listener.close();
     303                                } catch (IOException e) {
     304                                }
     305                        }
     306                        try {
     307                                socketManager.destroySocketManager();
     308                        } catch (Exception e) {
     309                                // nop
     310                        }
     311                        ticks = 600; // 60 seconds
    259312                        if (tg.activeCount() + tg.activeGroupCount() != 0) {
    260                                 tg.interrupt(); // unwedge any blocking threads.
    261                                 while (tg.activeCount() + tg.activeGroupCount() != 0) {
     313                                while ((tg.activeCount() + tg.activeGroupCount() != 0) && ticks != 0) {
     314                                        tg.interrupt(); // unwedge any blocking threads.
     315                                        ticks--;
    262316                                        try {
    263317                                                Thread.sleep(100); //sleep for 100 ms (One tenth second)
     
    267321                                }
    268322                        }
    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                 }
    288                 try {
    289                         socketManager.destroySocketManager();
    290                 } catch (Exception e) {
    291                         // nop
    292                 }
     323                        if (tg.activeCount() + tg.activeGroupCount() == 0) {
     324                                tg.destroy();
     325                                // Zap reference to the ThreadGroup so the JVM can GC it.
     326                                tg = null;
     327                        } else {
     328                                System.out.println("BOB: MUXlisten: Can't kill threads. Please send the following dump to sponge@mail.i2p");
     329                                System.out.println("\n\nBOB: MUXlisten: ThreadGroup dump BEGIN");
     330                                visit(tg, 0);
     331                                System.out.println("BOB: MUXlisten: ThreadGroup dump END\n\n");
     332                        }
     333                }
     334
     335                // This is here to catch when something fucks up REALLY bad.
     336//              if (tg != null) {
     337//                      System.out.println("BOB: MUXlisten: Something fucked up REALLY bad!");
     338//                      System.out.println("BOB: MUXlisten: Please email the following dump to sponge@mail.i2p");
     339//                      WrapperManager.requestThreadDump();
     340//                      System.out.println("BOB: MUXlisten: Something fucked up REALLY bad!");
     341//                      System.out.println("BOB: MUXlisten: Please email the above dump to sponge@mail.i2p");
     342//              }
    293343                // zero out everything.
    294344                try {
     
    308358        }
    309359
    310 //      private class DisconnectListener implements I2PSocketManager.DisconnectListener {
    311 //
    312 //              public void sessionDisconnected() {
    313 //                      close();
    314 //              }
    315 //      }
    316 //      public void close() {
    317 //              socketManager.destroySocketManager();
    318 //      }
     360
     361        // Debugging...
     362
     363        /**
     364         *      Find the root thread group and print them all.
     365         *
     366         */
     367        private void visitAllThreads() {
     368                ThreadGroup root = Thread.currentThread().getThreadGroup().getParent();
     369                while (root.getParent() != null) {
     370                        root = root.getParent();
     371                }
     372
     373                // Visit each thread group
     374                visit(root, 0);
     375        }
     376
     377        /**
     378         * Recursively visits all thread groups under `group' and dumps them.
     379         * @param group ThreadGroup to visit
     380         * @param level Current level
     381         */
     382        private static void visit(ThreadGroup group, int level) {
     383                // Get threads in `group'
     384                int numThreads = group.activeCount();
     385                Thread[] threads = new Thread[numThreads * 2];
     386                numThreads = group.enumerate(threads, false);
     387                String indent = "------------------------------------".substring(0, level) + "-> ";
     388                // Enumerate each thread in `group' and print it.
     389                for (int i = 0; i < numThreads; i++) {
     390                        // Get thread
     391                        Thread thread = threads[i];
     392                        System.out.println("BOB: MUXlisten: " + indent + thread.toString());
     393                }
     394
     395                // Get thread subgroups of `group'
     396                int numGroups = group.activeGroupCount();
     397                ThreadGroup[] groups = new ThreadGroup[numGroups * 2];
     398                numGroups = group.enumerate(groups, false);
     399
     400                // Recursively visit each subgroup
     401                for (int i = 0; i < numGroups; i++) {
     402                        visit(groups[i], level + 1);
     403                }
     404        }
    319405}
  • apps/BOB/src/net/i2p/BOB/TCPio.java

    r2a2d3c0 r384d655  
    2424package net.i2p.BOB;
    2525
     26import java.io.IOException;
    2627import java.io.InputStream;
    2728import java.io.OutputStream;
     
    4142         * Constructor
    4243         *
    43          * @param Ain
    44          * @param Aout
    45          * @param info
     44         * @param Ain InputStream
     45         * @param Aout OutputStream
    4646         *
    4747         * param database
     
    100100                                        Thread.yield(); // this should act like a mini sleep.
    101101                                        if(Ain.available() == 0) {
    102                                                 try {
     102//                                              try {
    103103                                                        // Thread.yield();
    104104                                                        Thread.sleep(10);
    105                                                 } catch(InterruptedException ex) {
    106                                                 }
     105//                                              } catch(InterruptedException ex) {
     106//                                              }
    107107                                        }
    108108                                } else {
     
    115115                                         */
    116116                                        // System.out.println("TCPio: End Of Stream");
     117                                        Ain.close();
     118                                        Aout.close();
    117119                                        return;
    118120                                }
     
    121123                } catch(Exception e) {
    122124                        // Eject!!! Eject!!!
    123                         // System.out.println("TCPio: Caught an exception " + e);
     125                        //System.out.println("TCPio: Caught an exception " + e);
     126                        try {
     127                                Ain.close();
     128                        } catch (IOException ex) {
     129//                              Logger.getLogger(TCPio.class.getName()).log(Level.SEVERE, null, ex);
     130                        }
     131                        try {
     132                                Aout.close();
     133                        } catch (IOException ex) {
     134//                              Logger.getLogger(TCPio.class.getName()).log(Level.SEVERE, null, ex);
     135                        }
    124136                        return;
    125137                }
  • apps/BOB/src/net/i2p/BOB/TCPlistener.java

    r2a2d3c0 r384d655  
    2828import java.net.Socket;
    2929import java.net.SocketTimeoutException;
    30 import net.i2p.client.I2PSession;
    31 import net.i2p.client.I2PSessionException;
     30// import net.i2p.client.I2PSession;
     31// import net.i2p.client.I2PSessionException;
    3232import net.i2p.client.streaming.I2PServerSocket;
    3333import net.i2p.client.streaming.I2PSocketManager;
     
    188188                        }
    189189                }
     190                // Previous level does this cleanup now.
     191                //
    190192                // need to kill off the socket manager too.
    191                 I2PSession session = socketManager.getSession();
    192                 if (session != null) {
    193                         try {
    194                                 session.destroySession();
    195                         } catch (I2PSessionException ex) {
     193                // I2PSession session = socketManager.getSession();
     194                // if (session != null) {
     195                //      try {
     196                //              session.destroySession();
     197                //      } catch (I2PSessionException ex) {
    196198                                // nop
    197                         }
    198                 }
     199                //      }
     200                //}
    199201                //System.out.println("TCPlistener: Waiting for children");
    200                 while (Thread.activeCount() > tgwatch) { // wait for all threads in our threadgroup to finish
    201                         try {
    202                                 Thread.sleep(100); //sleep for 100 ms (One tenth second)
    203                         } catch (Exception e) {
    204                                 // nop
    205                         }
    206                 }
     202                //while (Thread.activeCount() > tgwatch) { // wait for all threads in our threadgroup to finish
     203                //      try {
     204                //              Thread.sleep(100); //sleep for 100 ms (One tenth second)
     205                //      } catch (Exception e) {
     206                //              // nop
     207                //      }
     208                //}
    207209        //System.out.println("TCPlistener: Done.");
    208210        }
  • apps/BOB/src/net/i2p/BOB/TCPtoI2P.java

    r2a2d3c0 r384d655  
    115115        public void run() {
    116116                String line, input;
    117 
    118                 try {
    119 
    120                         InputStream in = sock.getInputStream();
    121                         OutputStream out = sock.getOutputStream();
     117                InputStream Iin = null;
     118                OutputStream Iout = null;
     119                InputStream in = null;
     120                OutputStream out = null;
     121
     122                try {
     123
     124                        in = sock.getInputStream();
     125                        out = sock.getOutputStream();
    122126                        try {
    123127                                line = lnRead(in);
     
    137141                                        I2P.setReadTimeout(0); // temp bugfix, this *SHOULD* be the default
    138142                                        // make readers/writers
    139                                         InputStream Iin = I2P.getInputStream();
    140                                         OutputStream Iout = I2P.getOutputStream();
     143                                        Iin = I2P.getInputStream();
     144                                        Iout = I2P.getOutputStream();
    141145                                        // setup to cross the streams
    142146                                        TCPio conn_c = new TCPio(in, Iout /*, info, database */); // app -> I2P
     
    148152                                        q.start();
    149153                                        while(t.isAlive() && q.isAlive()) { // AND is used here to kill off the other thread
    150                                                 try {
     154//                                              try {
    151155                                                        Thread.sleep(10); //sleep for 10 ms
    152                                                 } catch(InterruptedException e) {
     156//                                              } catch(InterruptedException e) {
    153157                                                        // nop
    154                                                 }
     158//                                              }
    155159                                        }
    156160                                        // System.out.println("TCPtoI2P: Going away...");
     
    173177                }
    174178                try {
     179                        in.close();
     180                } catch(Exception e) {
     181                }
     182                try {
     183                        out.close();
     184                } catch(Exception e) {
     185                }
     186                try {
     187                        Iin.close();
     188                } catch(Exception e) {
     189                }
     190                try {
     191                        Iout.close();
     192                } catch(Exception e) {
     193                }
     194                try {
    175195                        // System.out.println("TCPtoI2P: Close I2P");
    176196                        I2P.close();
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelClientBase.java

    r2a2d3c0 r384d655  
    101101
    102102    /**
    103      * @param privKeyFile null to generate a transient key
     103     * @param pkf null to generate a transient key
    104104     *
    105105     * @throws IllegalArgumentException if the I2CP configuration is b0rked so
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/udpTunnel/I2PTunnelUDPClientBase.java

    r2a2d3c0 r384d655  
    3535import net.i2p.util.Log;
    3636
    37 public abstract class I2PTunnelUDPClientBase extends I2PTunnelTask implements Source, Sink {
     37    /**
     38     * Base client class that sets up an I2P Datagram client destination.
     39     * The UDP side is not implemented here, as there are at least
     40     * two possibilities:
     41     *
     42     * 1) UDP side is a "server"
     43     *    Example: Streamr Consumer
     44     *    - Configure a destination host and port
     45     *    - External application sends no data
     46     *    - Extending class must have a constructor with host and port arguments
     47     *
     48     * 2) UDP side is a client/server
     49     *    Example: SOCKS UDP (DNS requests?)
     50     *    - configure an inbound port and a destination host and port
     51     *    - External application sends and receives data
     52     *    - Extending class must have a constructor with host and 2 port arguments
     53     *
     54     * So the implementing class must create a UDPSource and/or UDPSink,
     55     * and must call setSink().
     56     *
     57     * @author zzz with portions from welterde's streamr
     58     */
     59 public abstract class I2PTunnelUDPClientBase extends I2PTunnelTask implements Source, Sink {
    3860
    3961    private static final Log _log = new Log(I2PTunnelUDPClientBase.class);
     
    7092    private Sink _i2pSink;
    7193    private Destination _otherDest;
    72 
    73     /**
    74      * Base client class that sets up an I2P Datagram client destination.
    75      * The UDP side is not implemented here, as there are at least
    76      * two possibilities:
    77      *
    78      * 1) UDP side is a "server"
    79      *    Example: Streamr Consumer
    80      *    - Configure a destination host and port
    81      *    - External application sends no data
    82      *    - Extending class must have a constructor with host and port arguments
    83      *
    84      * 2) UDP side is a client/server
    85      *    Example: SOCKS UDP (DNS requests?)
    86      *    - configure an inbound port and a destination host and port
    87      *    - External application sends and receives data
    88      *    - Extending class must have a constructor with host and 2 port arguments
    89      *
    90      * So the implementing class must create a UDPSource and/or UDPSink,
    91      * and must call setSink().
    92      *
     94    /**
    9395     * @throws IllegalArgumentException if the I2CP configuration is b0rked so
    9496     *                                  badly that we cant create a socketManager
    95      *
    96      * @author zzz with portions from welterde's streamr
    97      */
    98     public I2PTunnelUDPClientBase(String destination, Logging l, EventDispatcher notifyThis,
     97     */
     98   public I2PTunnelUDPClientBase(String destination, Logging l, EventDispatcher notifyThis,
    9999                                  I2PTunnel tunnel) throws IllegalArgumentException {
    100100        super("UDPServer", notifyThis, tunnel);
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/udpTunnel/I2PTunnelUDPServerBase.java

    r2a2d3c0 r384d655  
    3333import net.i2p.util.Log;
    3434
    35 public class I2PTunnelUDPServerBase extends I2PTunnelTask implements Source, Sink {
    36 
    37     private final static Log _log = new Log(I2PTunnelUDPServerBase.class);
    38 
    39     private Object lock = new Object();
    40     protected Object slock = new Object();
    41 
    42     private static volatile long __serverId = 0;
    43 
    44     protected Logging l;
    45 
    46     private static final long DEFAULT_READ_TIMEOUT = -1; // 3*60*1000;
    47     /** default timeout to 3 minutes - override if desired */
    48     protected long readTimeout = DEFAULT_READ_TIMEOUT;
    49 
    50     private I2PSession _session;
    51     private Source _i2pSource;
    52     private Sink _i2pSink;
    53 
    5435    /**
    5536     * Base client class that sets up an I2P Datagram server destination.
     
    7253     * and must call setSink().
    7354     *
     55     * @author zzz with portions from welterde's streamr
     56     */
     57
     58public class I2PTunnelUDPServerBase extends I2PTunnelTask implements Source, Sink {
     59
     60    private final static Log _log = new Log(I2PTunnelUDPServerBase.class);
     61
     62    private Object lock = new Object();
     63    protected Object slock = new Object();
     64
     65    private static volatile long __serverId = 0;
     66
     67    protected Logging l;
     68
     69    private static final long DEFAULT_READ_TIMEOUT = -1; // 3*60*1000;
     70    /** default timeout to 3 minutes - override if desired */
     71    protected long readTimeout = DEFAULT_READ_TIMEOUT;
     72
     73    private I2PSession _session;
     74    private Source _i2pSource;
     75    private Sink _i2pSink;
     76
     77    /**
     78     *
    7479     * @throws IllegalArgumentException if the I2CP configuration is b0rked so
    7580     *                                  badly that we cant create a socketManager
    7681     *
    77      * @author zzz with portions from welterde's streamr
    7882     */
    7983
  • apps/streaming/java/src/net/i2p/client/streaming/Connection.java

    r2a2d3c0 r384d655  
    188188                            _log.debug("Outbound window is full (" + _outboundPackets.size() + "/" + _options.getWindowSize() + "/"
    189189                                       + _activeResends + "), waiting " + timeLeft);
    190                         try { _outboundPackets.wait(Math.min(timeLeft,250l)); } catch (InterruptedException ie) {}
     190                        try { _outboundPackets.wait(Math.min(timeLeft,250l)); } catch (InterruptedException ie) { if (_log.shouldLog(Log.DEBUG)) _log.debug("InterruptedException while Outbound window is full (" + _outboundPackets.size() + "/" + _activeResends +")"); return false;}
    191191                    } else {
    192192                        if (_log.shouldLog(Log.DEBUG))
    193193                            _log.debug("Outbound window is full (" + _outboundPackets.size() + "/" + _activeResends
    194194                                       + "), waiting indefinitely");
    195                         try { _outboundPackets.wait(250); } catch (InterruptedException ie) {} //10*1000
     195                        try { _outboundPackets.wait(250); } catch (InterruptedException ie) {if (_log.shouldLog(Log.DEBUG)) _log.debug("InterruptedException while Outbound window is full (" + _outboundPackets.size() + "/" + _activeResends + ")"); return false;} //10*1000
    196196                    }
    197197                } else {
     
    811811                    _connectLock.wait(timeLeft);
    812812                }
    813             } catch (InterruptedException ie) {}
     813            } catch (InterruptedException ie) {
     814                if (_log.shouldLog(Log.DEBUG)) _log.debug("waitForConnect(): InterruptedException");
     815                _connectionError = "InterruptedException";
     816                return;
     817            }
    814818        }
    815819    }
  • apps/streaming/java/src/net/i2p/client/streaming/ConnectionHandler.java

    r2a2d3c0 r384d655  
    127127                    try {
    128128                       syn = _synQueue.take(); // waits forever
    129                     } catch (InterruptedException ie) {}
     129                    } catch (InterruptedException ie) { break;}
    130130                } else {
    131131                    long remaining = expiration - _context.clock().now();
     
    139139                    try {
    140140                        syn = _synQueue.poll(remaining, TimeUnit.MILLISECONDS); // waits the specified time max
    141                     } catch (InterruptedException ie) {}
     141                    } catch (InterruptedException ie) { }
    142142                    break;
    143143                }
  • apps/streaming/java/src/net/i2p/client/streaming/PacketLocal.java

    r2a2d3c0 r384d655  
    214214                    wait(timeRemaining);
    215215                }
    216             } catch (InterruptedException ie) {}
     216            } catch (InterruptedException ie) { break; }
    217217        }
    218218        if (!writeSuccessful())
  • core/java/src/net/i2p/client/I2PSessionMuxedImpl.java

    r2a2d3c0 r384d655  
    147147     *         I2PSession.PROTO_DATAGRAM
    148148     *         255 disallowed
    149      *  @param fromport 1-65535 or 0 for unset
    150      *  @param toport 1-65535 or 0 for unset
     149     *  @param fromPort 1-65535 or 0 for unset
     150     *  @param toPort 1-65535 or 0 for unset
    151151     */
    152152    public boolean sendMessage(Destination dest, byte[] payload, int offset, int size,
  • core/java/src/net/i2p/data/i2cp/I2CPMessageReader.java

    r2a2d3c0 r384d655  
    179179                    try {
    180180                        Thread.sleep(500);
    181                     } catch (InterruptedException ie) { // nop
     181                    } catch (InterruptedException ie) {
     182                        // we should break away here.
     183                        _log.warn("Breaking away stream", ie);
     184                        _listener.disconnected(I2CPMessageReader.this);
     185                        cancelRunner();
    182186                    }
    183187                }
  • core/java/src/net/i2p/util/ConvertToHash.java

    r2a2d3c0 r384d655  
    1717 *    example.i2p
    1818 *
    19  *  @return null on failure
    20  *
    2119 *  @author zzz
    2220 */
    2321public class ConvertToHash {
    2422   
     23    /**
     24     *  Convert any kind of destination String to a hash
     25     *
     26     *  @return null on failure
     27     */
    2528    public static Hash getHash(String peer) {
    2629        if (peer == null)
  • history.txt

    r2a2d3c0 r384d655  
     12009-04-10 sponge
     2    * More BOB threadgroup fixes, plus debug dump when things go wrong.
     3    * Fixes to streaminglib, I2CP, which are related to the TG problem.
     4    * JavaDocs fixups.
     5
    162009-04-08 sponge
    27    * More hopeful fixups to the infamous orpahned tunnel problem. *Sigh*
  • router/java/src/net/i2p/router/RouterVersion.java

    r2a2d3c0 r384d655  
    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 = 14;
     20    public final static long BUILD = 15;
    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.