Ignore:
Timestamp:
Apr 19, 2004 9:45:04 PM (18 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
d945eb6
Parents:
3658cca
git-author:
human <human> (04/19/04 21:45:04)
git-committer:
zzz <zzz@…> (04/19/04 21:45:04)
Message:
  • Made I2PSocketManager.connect() throw several kinds of exceptions, for better error reporting;
  • Added an I2PSocketManager.destroySocketManager() method, that closes all the managed sockets and destroys the associated I2PSession.

(human)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • apps/ministreaming/java/src/net/i2p/client/streaming/I2PSocketManager.java

    r3658cca rfb170e3c  
    1010import java.io.InterruptedIOException;
    1111import java.io.UnsupportedEncodingException;
     12import java.net.ConnectException;
     13import java.net.NoRouteToHostException;
    1214import java.util.HashMap;
    1315import java.util.HashSet;
     16import java.util.Iterator;
    1417import java.util.Set;
    1518
    1619import net.i2p.I2PException;
    1720import net.i2p.client.I2PSession;
     21import net.i2p.client.I2PSessionException;
    1822import net.i2p.client.I2PSessionListener;
    1923import net.i2p.data.Base64;
     
    3842    private I2PSocketOptions _defaultOptions;
    3943
    40     public static final int PUBKEY_LENGTH = 387;
    41 
    4244    public I2PSocketManager() {
    4345        _session = null;
     
    136138                    // SYN incoming
    137139                    _log.debug("*Syn!");
    138                     if (payload.length == PUBKEY_LENGTH) {
    139                         String newLocalID = makeID(_inSockets);
    140                         Destination d = new Destination();
    141                         d.readBytes(new ByteArrayInputStream(payload));
    142 
    143                         if (_serverSocket == null) {
    144                             // The app did not instantiate an I2PServerSocket
    145                             byte[] packet = makePacket((byte) 0x52, id, newLocalID.getBytes("ISO-8859-1"));
    146                             boolean replySentOk = false;
    147                             synchronized (_session) {
    148                                 replySentOk = _session.sendMessage(d, packet);
    149                             }
    150                             if (!replySentOk) {
    151                                 _log.error("Error sending close to " + d.calculateHash().toBase64()
    152                                            + " in response to a new con message", new Exception("Failed creation"));
    153                             }
    154                             return;
    155                         }
    156 
    157                         s = new I2PSocketImpl(d, this, false, newLocalID);
    158                         s.setRemoteID(id);
    159                         if (_serverSocket.getNewSocket(s)) {
    160                             _inSockets.put(newLocalID, s);
    161                             byte[] packet = makePacket((byte) 0x51, id, newLocalID.getBytes("ISO-8859-1"));
    162                             boolean replySentOk = false;
    163                             synchronized (_session) {
    164                                 replySentOk = _session.sendMessage(d, packet);
    165                             }
    166                             if (!replySentOk) {
    167                                 _log.error("Error sending reply to " + d.calculateHash().toBase64()
    168                                            + " in response to a new con message", new Exception("Failed creation"));
    169                                 s.internalClose();
    170                             }
    171                         } else {
    172                             byte[] packet = (" " + id).getBytes("ISO-8859-1");
    173                             packet[0] = 0x52;
    174                             boolean nackSent = session.sendMessage(d, packet);
    175                             if (!nackSent) {
    176                                 _log.error("Error sending NACK for session creation");
    177                             }
     140                    String newLocalID = makeID(_inSockets);
     141                    Destination d = new Destination();
     142                    d.readBytes(new ByteArrayInputStream(payload));
     143                   
     144                    if (_serverSocket == null) {
     145                        // The app did not instantiate an I2PServerSocket
     146                        byte[] packet = makePacket((byte) 0x52, id, newLocalID.getBytes("ISO-8859-1"));
     147                        boolean replySentOk = false;
     148                        synchronized (_session) {
     149                            replySentOk = _session.sendMessage(d, packet);
     150                        }
     151                        if (!replySentOk) {
     152                            _log.error("Error sending close to " + d.calculateHash().toBase64()
     153                                       + " in response to a new con message", new Exception("Failed creation"));
     154                        }
     155                        return;
     156                    }
     157                   
     158                    s = new I2PSocketImpl(d, this, false, newLocalID);
     159                    s.setRemoteID(id);
     160                    if (_serverSocket.getNewSocket(s)) {
     161                        _inSockets.put(newLocalID, s);
     162                        byte[] packet = makePacket((byte) 0x51, id, newLocalID.getBytes("ISO-8859-1"));
     163                        boolean replySentOk = false;
     164                        synchronized (_session) {
     165                            replySentOk = _session.sendMessage(d, packet);
     166                        }
     167                        if (!replySentOk) {
     168                            _log.error("Error sending reply to " + d.calculateHash().toBase64()
     169                                       + " in response to a new con message", new Exception("Failed creation"));
    178170                            s.internalClose();
    179171                        }
    180                         return;
    181172                    } else {
    182                         _log.error("Syn packet that has a payload not equal to the pubkey length (" + payload.length
    183                                    + " != " + PUBKEY_LENGTH + ")");
    184                         return;
    185                     }
     173                        byte[] packet = (" " + id).getBytes("ISO-8859-1");
     174                        packet[0] = 0x52;
     175                        boolean nackSent = session.sendMessage(d, packet);
     176                        if (!nackSent) {
     177                            _log.error("Error sending NACK for session creation");
     178                        }
     179                        s.internalClose();
     180                    }
     181                    return;
    186182                case 0xA2:
    187183                    // disconnect incoming
     
    255251     * Create a new connected socket (block until the socket is created)
    256252     *
    257      * @throws I2PException if there is a problem connecting
    258      */
    259     public I2PSocket connect(Destination peer, I2PSocketOptions options) throws I2PException {
     253     * @param peer Destination to connect to
     254     * @param options I2P socket options to be used for connecting
     255     *
     256     * @throws ConnectException if the peer refuses the connection
     257     * @throws NoRouteToHostException if the peer is not found or not reachable
     258     * @throws InterruptedException if the connection timeouts
     259     * @throws I2PException if there is some other I2P-related problem
     260     */
     261    public I2PSocket connect(Destination peer, I2PSocketOptions options) throws I2PException, ConnectException, NoRouteToHostException, InterruptedException {
    260262
    261263        String localID, lcID;
     
    281283                    _outSockets.remove(s.getLocalID());
    282284                }
    283                 throw new I2PException("Unable to reach peer");
     285                throw new I2PException("Error sending through I2P network");
    284286            }
    285287            remoteID = s.getRemoteID(true, options.getConnectTimeout());
    286             if (remoteID == null) { throw new I2PException("Peer refused connection"); }
    287             if ("".equals(remoteID)) { throw new I2PException("Unable to reach peer"); }
     288            if (remoteID == null) { throw new ConnectException("Connection refused by peer"); }
     289            if ("".equals(remoteID)) { throw new NoRouteToHostException("Unable to reach peer"); }
    288290            _log.debug("TIMING: s given out for remoteID " + getReadableForm(remoteID));
    289291            return s;
     
    293295                _outSockets.remove(s.getLocalID());
    294296            }
    295             throw new I2PException("Timeout waiting for ack");
     297            throw new InterruptedException("Timeout waiting for ack");
     298        } catch (ConnectException ex) {
     299            throw ex;
     300        } catch (NoRouteToHostException ex) {
     301            throw ex;
    296302        } catch (IOException ex) {
    297303            _log.error("Error sending syn on id " + getReadableForm(lcID), ex);
     
    299305                _outSockets.remove(s.getLocalID());
    300306            }
    301             throw new I2PException("IOException occurred");
     307            throw new I2PException("Unhandled IOException occurred");
    302308        } catch (I2PException ex) {
    303309            _log.info("Error sending syn on id " + getReadableForm(lcID), ex);
     
    309315    }
    310316
    311     public I2PSocket connect(Destination peer) throws I2PException {
     317    /**
     318     * Create a new connected socket (block until the socket is created)
     319     *
     320     * @param peer Destination to connect to
     321     *
     322     * @throws ConnectException if the peer refuses the connection
     323     * @throws NoRouteToHostException if the peer is not found or not reachable
     324     * @throws InterruptedException if the connection timeouts
     325     * @throws I2PException if there is some other I2P-related problem
     326     */
     327    public I2PSocket connect(Destination peer) throws I2PException, ConnectException, NoRouteToHostException, InterruptedException {
    312328        return connect(peer, null);
     329    }
     330
     331    /**
     332     * Destroy the socket manager, freeing all the associated resources.  This
     333     * method will block untill all the managed sockets are closed.
     334     *
     335     */
     336    public void destroySocketManager() {
     337
     338        try {
     339            if (_serverSocket != null) {
     340                _serverSocket.close();
     341                _serverSocket = null;
     342            }
     343        } catch (I2PException ex) {
     344            _log.error("Error closing I2PServerSocket", ex);
     345        }
     346
     347        synchronized (lock) {
     348            Iterator iter;
     349            String id = null;
     350            I2PSocketImpl sock;
     351
     352            iter = _inSockets.keySet().iterator();
     353            while (iter.hasNext()) {
     354                id = (String)iter.next();
     355                sock = (I2PSocketImpl)_inSockets.get(id);
     356                _log.debug("Closing inSocket \""
     357                           + getReadableForm(sock.getLocalID()) + "\"");
     358                sock.internalClose();
     359            }
     360           
     361            iter = _outSockets.keySet().iterator();
     362            while (iter.hasNext()) {
     363                id = (String)iter.next();
     364                sock = (I2PSocketImpl)_outSockets.get(id);
     365                _log.debug("Closing outSocket \""
     366                           + getReadableForm(sock.getLocalID()) + "\"");
     367                sock.internalClose();
     368            }           
     369        }
     370
     371        _log.debug("Waiting for all open sockets to really close...");
     372        synchronized (lock) {
     373            while ((_inSockets.size() != 0) || (_outSockets.size() != 0)) {
     374                try {
     375                    lock.wait();
     376                } catch (InterruptedException e) {}
     377            }
     378        }
     379
     380        try {
     381            _log.debug("Destroying I2P session...");
     382            _session.destroySession();
     383            _log.debug("I2P session destroyed");
     384        } catch (I2PSessionException e) {
     385            _log.error("Error destroying I2P session", e);
     386        }
    313387    }
    314388
     
    342416    public void removeSocket(I2PSocketImpl sock) {
    343417        synchronized (lock) {
     418            _log.debug("Removing socket \""
     419                       + getReadableForm(sock.getLocalID()) + "\"");
    344420            _inSockets.remove(sock.getLocalID());
    345421            _outSockets.remove(sock.getLocalID());
     422            lock.notify();
    346423        }
    347424    }
Note: See TracChangeset for help on using the changeset viewer.