Changeset cd351592


Ignore:
Timestamp:
Feb 17, 2018 4:04:09 PM (3 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
fb6eea2
Parents:
509e39b
Message:

i2ptunnel: Close sockets in finally{}

Location:
apps/i2ptunnel/java/src/net/i2p/i2ptunnel
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelClient.java

    r509e39b rcd351592  
    131131            if (_log.shouldLog(Log.INFO))
    132132                _log.info("Error connecting", ex);
    133             //l.log("Error connecting: " + ex.getMessage());
    134             closeSocket(s);
    135             if (i2ps != null) {
    136                 synchronized (sockLock) {
    137                     mySockets.remove(sockLock);
    138                 }
    139             }
    140133        } catch (I2PException ex) {
    141134            if (_log.shouldLog(Log.INFO))
    142135                _log.info("Error connecting", ex);
    143             //l.log("Error connecting: " + ex.getMessage());
     136        } finally {
     137            // only because we are running it inline
    144138            closeSocket(s);
    145139            if (i2ps != null) {
     140                try { i2ps.close(); } catch (IOException ioe) {}
    146141                synchronized (sockLock) {
    147                     mySockets.remove(sockLock);
     142                    mySockets.remove(i2ps);
    148143                }
    149144            }
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelConnectClient.java

    r509e39b rcd351592  
    155155        Outproxy outproxy = null;
    156156        long requestId = __requestId.incrementAndGet();
     157        I2PSocket i2ps = null;
    157158        try {
    158159            s.setSoTimeout(INITIAL_SO_TIMEOUT);
     
    229230                                    _log.warn(getPrefix(requestId) + "Host wants to be outproxied, but we dont have any!");
    230231                                writeErrorMessage(ERR_NO_OUTPROXY, out);
    231                                 s.close();
    232232                                return;
    233233                            }
     
    238238                    } else if (host.toLowerCase(Locale.US).equals("localhost")) {
    239239                        writeErrorMessage(ERR_LOCALHOST, out);
    240                         s.close();
    241240                        return;
    242241                    } else {  // full b64 address (hopefully)
     
    293292            if (method == null || !"CONNECT".equals(method.toUpperCase(Locale.US))) {
    294293                writeErrorMessage(ERR_BAD_PROTOCOL, out);
    295                 s.close();
    296294                return;
    297295            }
     
    310308            if (destination == null) {
    311309                writeErrorMessage(ERR_BAD_PROTOCOL, out);
    312                 s.close();
    313310                return;
    314311            }
     
    324321                }
    325322                out.write(DataHelper.getASCII(getAuthError(result == AuthResult.AUTH_STALE)));
    326                 s.close();
    327323                return;
    328324            }
     
    336332                    header = getErrorPage("dnfh", ERR_DESTINATION_UNKNOWN);
    337333                writeErrorMessage(header, out, targetRequest, usingWWWProxy, destination);
    338                 s.close();
    339334                return;
    340335            }
     
    343338            if (!usingWWWProxy && remotePort > 0)
    344339                sktOpts.setPort(remotePort);
    345             I2PSocket i2ps = createI2PSocket(clientDest, sktOpts);
     340            i2ps = createI2PSocket(clientDest, sktOpts);
    346341            byte[] data = null;
    347342            byte[] response = null;
     
    358353            _log.info(getPrefix(requestId) + "Error trying to connect", ex);
    359354            handleClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
    360             closeSocket(s);
    361355        } catch (I2PException ex) {
    362356            _log.info("getPrefix(requestId) + Error trying to connect", ex);
    363357            handleClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
    364             closeSocket(s);
    365358        } catch (OutOfMemoryError oom) {
    366359            IOException ex = new IOException("OOM");
    367360            _log.info("getPrefix(requestId) + Error trying to connect", ex);
    368361            handleClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
     362        } finally {
     363            // only because we are running it inline
    369364            closeSocket(s);
     365            try { i2ps.close(); } catch (IOException ioe) {}
    370366        }
    371367    }
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelHTTPClient.java

    r509e39b rcd351592  
    399399        long requestId = __requestId.incrementAndGet();
    400400        boolean shout = false;
    401 
     401        I2PSocket i2ps = null;
    402402        try {
    403403            s.setSoTimeout(INITIAL_SO_TIMEOUT);
     
    556556                        } catch (IOException ioe) {
    557557                            // ignore
    558                         } finally {
    559                             closeSocket(s);
    560558                        }
    561559                        return;
     
    695693                                                writeFooter(out);
    696694                                                reader.drain();
    697                                                 // XXX: should closeSocket(s) be in a finally block?
    698695                                            } catch (IOException ioe) {
    699696                                                // ignore
    700                                             } finally {
    701                                                 closeSocket(s);
    702697                                            }
    703698                                            return;
     
    815810                                } catch (IOException ioe) {
    816811                                    // ignore
    817                                 } finally {
    818                                     closeSocket(s);
    819812                                }
    820813                                return;
     
    853846                        } catch (IOException ioe) {
    854847                            // ignore
    855                         } finally {
    856                             closeSocket(s);
    857848                        }
    858849                        return;
     
    906897                                } catch (IOException ioe) {
    907898                                    // ignore
    908                                 } finally {
    909                                     closeSocket(s);
    910899                                }
    911900                                return;
     
    932921                        } catch (IOException ioe) {
    933922                            // ignore
    934                         } finally {
    935                             closeSocket(s);
    936923                        }
    937924                        return;
     
    11121099                } catch (IOException ioe) {
    11131100                    // ignore
    1114                 } finally {
    1115                     closeSocket(s);
    11161101                }
    11171102                return;
     
    11371122                } catch (IOException ioe) {
    11381123                    // ignore
    1139                 } finally {
    1140                     closeSocket(s);
    11411124                }
    11421125                return;
     
    11561139                } catch (IOException ioe) {
    11571140                    // ignore
    1158                 } finally {
    1159                     closeSocket(s);
    11601141                }
    11611142                return;
     
    12011182                    } catch (IOException ioe) {
    12021183                        // ignore
    1203                     } finally {
    1204                         closeSocket(s);
    12051184                    }
    12061185                    return;
     
    12581237                } catch (IOException ioe) {
    12591238                    // ignore
    1260                 } finally {
    1261                     closeSocket(s);
    12621239                }
    12631240                return;
     
    12711248                } catch (IOException ioe) {
    12721249                    // ignore
    1273                 } finally {
    1274                     closeSocket(s);
    12751250                }
    12761251                if (_log.shouldLog(Log.WARN))
     
    12891264                } catch (IOException ioe) {
    12901265                    // ignore
    1291                 } finally {
    1292                     closeSocket(s);
    12931266                }
    12941267                return;
     
    13121285                } catch (IOException ioe) {
    13131286                    // ignore
    1314                 } finally {
    1315                     closeSocket(s);
    13161287                }
    13171288                return;
     
    13261297            if (remotePort > 0)
    13271298                sktOpts.setPort(remotePort);
    1328             I2PSocket i2ps = createI2PSocket(clientDest, sktOpts);
     1299            i2ps = createI2PSocket(clientDest, sktOpts);
    13291300            OnTimeout onTimeout = new OnTimeout(s, s.getOutputStream(), targetRequest, usingWWWProxy, currentProxy, requestId);
    13301301            Thread t;
     
    13511322                _log.info(getPrefix(requestId) + "Error trying to connect", ex);
    13521323            }
    1353             //l.log("Error connecting: " + ex.getMessage());
    13541324            handleClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
    1355             closeSocket(s);
    13561325        } catch(I2PException ex) {
    13571326            if(_log.shouldLog(Log.INFO)) {
    13581327                _log.info("getPrefix(requestId) + Error trying to connect", ex);
    13591328            }
    1360             //l.log("Error connecting: " + ex.getMessage());
    13611329            handleClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
    1362             closeSocket(s);
    13631330        } catch(OutOfMemoryError oom) {
    13641331            IOException ex = new IOException("OOM");
    13651332            _log.error("getPrefix(requestId) + Error trying to connect", oom);
    1366             //l.log("Error connecting: " + ex.getMessage());
    13671333            handleClientException(ex, out, targetRequest, usingWWWProxy, currentProxy, requestId);
     1334        } finally {
     1335            // only because we are running it inline
    13681336            closeSocket(s);
     1337            try { i2ps.close(); } catch (IOException ioe) {}
    13691338        }
    13701339    }
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelHTTPClientRunner.java

    r509e39b rcd351592  
    5050    protected void close(OutputStream out, InputStream in, OutputStream i2pout, InputStream i2pin,
    5151                         Socket s, I2PSocket i2ps, Thread t1, Thread t2) throws InterruptedException {
    52         try {
     52        if (i2pin != null) { try {
    5353            i2pin.close();
    54         } catch (IOException ioe) {}
    55         try {
     54        } catch (IOException ioe) {} }
     55        if (i2pout != null) { try {
    5656            i2pout.close();
    57         } catch (IOException ioe) {}
    58         try {
     57        } catch (IOException ioe) {} }
     58        if (in != null) { try {
    5959            in.close();
    60         } catch (IOException ioe) {}
    61         try {
     60        } catch (IOException ioe) {} }
     61        if (out != null) { try {
    6262            out.close();
    63         } catch (IOException ioe) {}
     63        } catch (IOException ioe) {} }
    6464        try {
    6565            i2ps.close();
     
    6868            s.close();
    6969        } catch (IOException ioe) {}
    70         t1.join(30*1000);
     70        if (t1 != null)
     71            t1.join(30*1000);
    7172        // t2 = fromI2P now run inline
    7273        //t2.join(30*1000);
    7374    }
    74    
    7575}
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelIRCClient.java

    r509e39b rcd351592  
    156156                s.getOutputStream().write(DataHelper.getUTF8(msg));
    157157            } catch (IOException ioe) {}
    158             closeSocket(s);
    159             if (i2ps != null) {
    160                 synchronized (sockLock) {
    161                     mySockets.remove(sockLock);
    162                 }
    163             }
    164158        } catch (I2PException ex) {
    165159            if (_log.shouldLog(Log.WARN))
     
    173167                s.getOutputStream().write(DataHelper.getUTF8(msg));
    174168            } catch (IOException ioe) {}
     169        } finally {
     170            // only because we are running it inline
    175171            closeSocket(s);
    176172            if (i2ps != null) {
     173                try { i2ps.close(); } catch (IOException ioe) {}
    177174                synchronized (sockLock) {
    178                     mySockets.remove(sockLock);
     175                    mySockets.remove(i2ps);
    179176                }
    180177            }
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelIRCServer.java

    r509e39b rcd351592  
    232232     *
    233233     */
    234     String cloakDest(Destination d) {
     234    private String cloakDest(Destination d) {
    235235        String hf;
    236236        String hc;
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelRunner.java

    r509e39b rcd351592  
    236236    @Override
    237237    public void run() {
     238        boolean i2pReset = false;
     239        boolean sockReset = false;
     240        InputStream in = null;
     241        OutputStream out = null;
     242        InputStream i2pin = null;
     243        OutputStream i2pout = null;
     244        StreamForwarder toI2P = null;
     245        StreamForwarder fromI2P = null;
    238246        try {
    239             InputStream in = getSocketIn();
    240             OutputStream out = getSocketOut(); // = new BufferedOutputStream(s.getOutputStream(), NETWORK_BUFFER_SIZE);
     247            in = getSocketIn();
     248            out = getSocketOut(); // = new BufferedOutputStream(s.getOutputStream(), NETWORK_BUFFER_SIZE);
    241249            // unimplemented in streaming
    242250            //i2ps.setSocketErrorListener(this);
    243             InputStream i2pin = i2ps.getInputStream();
    244             OutputStream i2pout = i2ps.getOutputStream(); //new BufferedOutputStream(i2ps.getOutputStream(), MAX_PACKET_SIZE);
     251            i2pin = i2ps.getInputStream();
     252            i2pout = i2ps.getOutputStream(); //new BufferedOutputStream(i2ps.getOutputStream(), MAX_PACKET_SIZE);
    245253            if (initialI2PData != null) {
    246254                // why synchronize this? we could be in here a LONG time for large initial data
     
    275283            if (!(s instanceof InternalSocket))
    276284                in = new BufferedInputStream(in, 2*NETWORK_BUFFER_SIZE);
    277             StreamForwarder toI2P = new StreamForwarder(in, i2pout, true);
    278             StreamForwarder fromI2P = new StreamForwarder(i2pin, out, false);
     285            toI2P = new StreamForwarder(in, i2pout, true);
     286            fromI2P = new StreamForwarder(i2pin, out, false);
    279287            toI2P.start();
    280288            // We are already a thread, so run the second one inline
     
    289297                _log.debug("At least one forwarder completed, closing and joining");
    290298           
    291             boolean i2pReset = false;
    292             boolean sockReset = false;
    293299            // this task is useful for the httpclient
    294300            if ((onTimeout != null || _onFail != null) && totalReceived <= 0) {
     
    334340            }
    335341
    336             if (i2pReset) {
    337                 if (_log.shouldWarn())
    338                     _log.warn("Got I2P reset, resetting socket");
    339                 try {
    340                     s.setSoLinger(true, 0);
    341                 } catch (IOException ioe) {}
    342                 try {
    343                     s.close();
    344                 } catch (IOException ioe) {}
    345                 try {
    346                     i2ps.close();
    347                 } catch (IOException ioe) {}
    348             } else if (sockReset) {
    349                 if (_log.shouldWarn())
    350                     _log.warn("Got socket reset, resetting I2P socket");
    351                 try {
    352                     i2ps.reset();
    353                 } catch (IOException ioe) {}
    354                 try {
    355                     s.close();
    356                 } catch (IOException ioe) {}
    357             } else {
    358                 // now one connection is dead - kill the other as well, after making sure we flush
    359                 close(out, in, i2pout, i2pin, s, i2ps, toI2P, fromI2P);
    360             }
    361342        } catch (InterruptedException ex) {
    362343            if (_log.shouldLog(Log.ERROR))
     
    386367        } finally {
    387368            removeRef();
    388             try {
    389                 if (s != null)
     369            if (i2pReset) {
     370                if (_log.shouldWarn())
     371                    _log.warn("Got I2P reset, resetting socket");
     372                try {
     373                    s.setSoLinger(true, 0);
     374                } catch (IOException ioe) {}
     375                try {
    390376                    s.close();
    391             } catch (IOException ex) {
    392                 if (_log.shouldLog(Log.WARN))
    393                     _log.warn("Could not close java socket", ex);
    394             }
    395             if (i2ps != null) {
     377                } catch (IOException ioe) {}
     378                try {
     379                    i2ps.close();
     380                } catch (IOException ioe) {}
     381            } else if (sockReset) {
     382                if (_log.shouldWarn())
     383                    _log.warn("Got socket reset, resetting I2P socket");
     384                try {
     385                    i2ps.reset();
     386                } catch (IOException ioe) {}
     387                try {
     388                    s.close();
     389                } catch (IOException ioe) {}
     390            } else {
     391                // now one connection is dead - kill the other as well, after making sure we flush
    396392                try {
    397                     i2ps.close();
    398                 } catch (IOException ex) {
    399                     if (_log.shouldLog(Log.WARN))
    400                         _log.warn("Could not close I2PSocket", ex);
    401                 }
    402                 // unimplemented in streaming
    403                 //i2ps.setSocketErrorListener(null);
     393                    close(out, in, i2pout, i2pin, s, i2ps, toI2P, fromI2P);
     394                } catch (InterruptedException ie) {}
    404395            }
    405396        }
    406397    }
    407398   
     399    /**
     400     *  @param out may be null
     401     *  @param in may be null
     402     *  @param i2pout may be null
     403     *  @param i2pin may be null
     404     *  @param t1 may be null
     405     *  @param t2 may be null
     406     */
    408407    protected void close(OutputStream out, InputStream in, OutputStream i2pout, InputStream i2pin,
    409408                         Socket s, I2PSocket i2ps, Thread t1, Thread t2) throws InterruptedException {
    410         try {
     409        if (out != null) { try {
    411410            out.flush();
    412         } catch (IOException ioe) {}
    413         try {
     411        } catch (IOException ioe) {} }
     412        if (i2pout != null) { try {
    414413            i2pout.flush();
    415         } catch (IOException ioe) {}
    416         try {
     414        } catch (IOException ioe) {} }
     415        if (in != null) { try {
    417416            in.close();
    418         } catch (IOException ioe) {}
    419         try {
     417        } catch (IOException ioe) {} }
     418        if (i2pin != null) { try {
    420419            i2pin.close();
    421         } catch (IOException ioe) {}
     420        } catch (IOException ioe) {} }
    422421        // ok, yeah, there's a race here in theory, if data comes in after flushing and before
    423422        // closing, but its better than before...
     
    428427            i2ps.close();
    429428        } catch (IOException ioe) {}
    430         t1.join(30*1000);
     429        if (t1 != null)
     430            t1.join(30*1000);
    431431        // t2 = fromI2P now run inline
    432432        //t2.join(30*1000);
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/irc/I2PTunnelDCCClient.java

    r509e39b rcd351592  
    8484        } catch (IOException ex) {
    8585            _log.error("Could not make DCC connection to " + _dest + ':' + _remotePort, ex);
     86            notifyEvent(CONNECT_STOP_EVENT, Integer.valueOf(getLocalPort()));
     87        } catch (I2PException ex) {
     88            _log.error("Could not make DCC connection to " + _dest + ':' + _remotePort, ex);
     89            notifyEvent(CONNECT_STOP_EVENT, Integer.valueOf(getLocalPort()));
     90        } finally {
     91            // only because we are running it inline
    8692            closeSocket(s);
    8793            if (i2ps != null) {
    8894                try { i2ps.close(); } catch (IOException ioe) {}
    8995            }
    90             notifyEvent(CONNECT_STOP_EVENT, Integer.valueOf(getLocalPort()));
    91         } catch (I2PException ex) {
    92             _log.error("Could not make DCC connection to " + _dest + ':' + _remotePort, ex);
    93             closeSocket(s);
    94             if (i2ps != null) {
    95                 try { i2ps.close(); } catch (IOException ioe) {}
    96             }
    97             notifyEvent(CONNECT_STOP_EVENT, Integer.valueOf(getLocalPort()));
    9896        }
    9997        stop();
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/socks/I2PSOCKSIRCTunnel.java

    r509e39b rcd351592  
    77package net.i2p.i2ptunnel.socks;
    88
     9import java.io.IOException;
    910import java.net.Socket;
    1011import java.net.SocketException;
     
    4849    @Override
    4950    protected void clientConnectionRun(Socket s) {
     51        I2PSocket destSock = null;
    5052        try {
    5153            //_log.error("SOCKS IRC Tunnel Start");
     
    5860                s.setSoTimeout(0);
    5961            } catch (SocketException ioe) {}
    60             I2PSocket destSock = serv.getDestinationI2PSocket(this);
     62            destSock = serv.getDestinationI2PSocket(this);
    6163            StringBuffer expectedPong = new StringBuffer();
    6264            int id = __clientId.incrementAndGet();
     
    7375            if (_log.shouldLog(Log.WARN))
    7476                _log.warn("Error from SOCKS connection", e);
     77        } finally {
     78            // only because we are running it inline
    7579            closeSocket(s);
     80            if (destSock != null) try { destSock.close(); } catch (IOException ioe) {}
    7681        }
    7782    }
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/socks/I2PSOCKSTunnel.java

    r509e39b rcd351592  
    77package net.i2p.i2ptunnel.socks;
    88
     9import java.io.IOException;
    910import java.net.Socket;
    1011import java.net.SocketException;
     
    5859
    5960    protected void clientConnectionRun(Socket s) {
     61        I2PSocket destSock = null;
    6062        try {
    6163            try {
     
    6769                s.setSoTimeout(0);
    6870            } catch (SocketException ioe) {}
    69             I2PSocket destSock = serv.getDestinationI2PSocket(this);
     71            destSock = serv.getDestinationI2PSocket(this);
    7072            Thread t = new I2PTunnelRunner(clientSock, destSock, sockLock, null, null, mySockets,
    7173                                           (I2PTunnelRunner.FailCallback) null);
     
    7678            if (_log.shouldLog(Log.WARN))
    7779                _log.warn("Error from SOCKS connection", e);
     80        } finally {
     81            // only because we are running it inline
    7882            closeSocket(s);
     83            if (destSock != null) try { destSock.close(); } catch (IOException ioe) {}
    7984        }
    8085    }
Note: See TracChangeset for help on using the changeset viewer.