Changeset 9367aca


Ignore:
Timestamp:
Nov 26, 2015 4:40:45 PM (5 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
626f541
Parents:
e5f186f6
Message:

Notes on STREAM STATUS messages when SILENT=true
Fix one message for STREAM CONNECT that wasn't honoring SILENT setting
PING failure sends a SESSION STATUS message
Implement ping/pong in client
Delay at end of client send so data gets through in v3 mode
log tweaks
Exception catch tweaks

Location:
apps/sam/java/src/net/i2p/sam
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • apps/sam/java/src/net/i2p/sam/SAMHandler.java

    re5f186f6 r9367aca  
    159159     */
    160160    public void stopHandling() {
     161        if (_log.shouldInfo())
     162            _log.info("Stopping: " + this, new Exception("I did it"));
    161163        synchronized (stopLock) {
    162164            stopHandler = true;
  • apps/sam/java/src/net/i2p/sam/SAMHandlerFactory.java

    re5f186f6 r9367aca  
    5757        } catch (IOException e) {
    5858            throw new SAMException("Error reading from socket", e);
    59         } catch (Exception e) {
     59        } catch (RuntimeException e) {
    6060            throw new SAMException("Unexpected error", e);
    6161        }
  • apps/sam/java/src/net/i2p/sam/SAMv1Handler.java

    re5f186f6 r9367aca  
    188188            if (_log.shouldLog(Log.DEBUG))
    189189                _log.debug("Caught IOException for message [" + msg + "]", e);
    190         } catch (Exception e) {
     190        } catch (SAMException e) {
     191            _log.error("Unexpected exception for message [" + msg + "]", e);
     192        } catch (RuntimeException e) {
    191193            _log.error("Unexpected exception for message [" + msg + "]", e);
    192194        } finally {
  • apps/sam/java/src/net/i2p/sam/SAMv3Handler.java

    re5f186f6 r9367aca  
    295295                                                                        if (_log.shouldWarn())
    296296                                                                                _log.warn("Failed to respond to PING");
    297                                                                         writeString("PING STATUS RESULT=I2P_ERROR MESSAGE=\"PONG timeout\"\n");
     297                                                                        writeString("SESSION STATUS RESULT=I2P_ERROR MESSAGE=\"PONG timeout\"\n");
    298298                                                                        break;
    299299                                                                }
     
    310310                                                                        if (_log.shouldWarn())
    311311                                                                                _log.warn("Failed to respond to PING");
    312                                                                         writeString("PING STATUS RESULT=I2P_ERROR MESSAGE=\"PONG timeout\"\n");
     312                                                                        writeString("SESSION STATUS RESULT=I2P_ERROR MESSAGE=\"PONG timeout\"\n");
    313313                                                                        break;
    314314                                                                }
     
    421421                } catch (IOException e) {
    422422                        if (_log.shouldLog(Log.DEBUG))
    423                                 _log.debug("Caught IOException for message [" + msg + "]", e);
    424                 } catch (Exception e) {
    425                         _log.error("Unexpected exception for message [" + msg + "]", e);
     423                                _log.debug("Caught IOException in handler", e);
     424                } catch (SAMException e) {
     425                        _log.error("Unexpected exception for message [" + msg + ']', e);
     426                } catch (RuntimeException e) {
     427                        _log.error("Unexpected exception for message [" + msg + ']', e);
    426428                } finally {
    427429                        if (_log.shouldLog(Log.DEBUG))
     
    465467        @Override
    466468        public void stopHandling() {
     469            if (_log.shouldInfo())
     470                _log.info("Stopping (stolen? " + stolenSocket + "): " + this, new Exception("I did it"));
    467471            synchronized (stopLock) {
    468472                stopHandler = true;
     
    729733        @Override
    730734        protected boolean execStreamConnect( Properties props) {
     735                // Messages are NOT sent if SILENT=true,
     736                // The specs said that they were.
     737                boolean verbose = !Boolean.parseBoolean(props.getProperty("SILENT"));
    731738                try {
    732739                        if (props.isEmpty()) {
    733                                 notifyStreamResult(true,"I2P_ERROR","No parameters specified in STREAM CONNECT message");
     740                                notifyStreamResult(verbose, "I2P_ERROR","No parameters specified in STREAM CONNECT message");
    734741                                if (_log.shouldLog(Log.DEBUG))
    735742                                        _log.debug("No parameters specified in STREAM CONNECT message");
    736743                                return false;
    737744                        }
    738                         boolean verbose = !Boolean.parseBoolean(props.getProperty("SILENT"));
    739745               
    740746                        String dest = props.getProperty("DESTINATION");
     
    777783
    778784        private boolean execStreamForwardIncoming( Properties props ) {
     785                // Messages ARE sent if SILENT=true,
     786                // which is different from CONNECT and ACCEPT.
     787                // But this matched the specs.
    779788                try {
    780789                        try {
     
    795804        private boolean execStreamAccept( Properties props )
    796805        {
     806                // Messages are NOT sent if SILENT=true,
     807                // The specs said that they were.
    797808                boolean verbose = !Boolean.parseBoolean(props.getProperty("SILENT"));
    798809                try {
  • apps/sam/java/src/net/i2p/sam/client/SAMClientEventListenerImpl.java

    re5f186f6 r9367aca  
    1515    public void streamDataReceived(String id, byte[] data, int offset, int length) {}
    1616    public void streamStatusReceived(String result, String id, String message) {}
     17    public void pingReceived(String data) {}
     18    public void pongReceived(String data) {}
    1719    public void unknownMessageReceived(String major, String minor, Properties params) {}
    1820}
  • apps/sam/java/src/net/i2p/sam/client/SAMReader.java

    re5f186f6 r9367aca  
    8181        public void namingReplyReceived(String name, String result, String value, String message);
    8282        public void destReplyReceived(String publicKey, String privateKey);
     83        public void pingReceived(String data);
     84        public void pongReceived(String data);
    8385       
    8486        public void unknownMessageReceived(String major, String minor, Properties params);
     
    119121                StringTokenizer tok = new StringTokenizer(line);
    120122               
    121                 if (tok.countTokens() < 2) {
     123                if (tok.countTokens() <= 0) {
    122124                    _log.error("Invalid SAM line: [" + line + "]");
    123125                    break;
     
    125127               
    126128                String major = tok.nextToken();
    127                 String minor = tok.nextToken();
     129                String minor = tok.hasMoreTokens() ? tok.nextToken() : "";
    128130               
    129131                params.clear();
     
    248250                _listener.unknownMessageReceived(major, minor, params);
    249251            }
     252        } else if ("PING".equals(major)) {
     253            // this omits anything after a space
     254            _listener.pingReceived(minor);
     255        } else if ("PONG".equals(major)) {
     256            // this omits anything after a space
     257            _listener.pongReceived(minor);
    250258        } else {
    251259            _listener.unknownMessageReceived(major, minor, params);
  • apps/sam/java/src/net/i2p/sam/client/SAMStreamSend.java

    re5f186f6 r9367aca  
    175175                }
    176176                return destination;
    177             } catch (Exception e) {
     177            } catch (IOException e) {
    178178                _log.error("Error handshaking", e);
    179179                return null;
     
    328328            // stop the reader, since we're only doing this once for testing
    329329            // you wouldn't do this in a real application
     330            if (_isV3) {
     331                // closing the master socket too fast will kill the data socket flushing through
     332                try {
     333                    Thread.sleep(10000);
     334                } catch (InterruptedException ie) {}
     335            }
    330336            _reader.stopReading();
    331337        }
  • apps/sam/java/src/net/i2p/sam/client/SAMStreamSink.java

    re5f186f6 r9367aca  
    6767        try {
    6868            Socket sock = connect();
    69             SAMEventHandler eventHandler = new SinkEventHandler(_context);
     69            OutputStream out = sock.getOutputStream();
     70            SAMEventHandler eventHandler = new SinkEventHandler(_context, out);
    7071            _reader = new SAMReader(_context, sock.getInputStream(), eventHandler);
    7172            _reader.startReading();
    7273            if (_log.shouldLog(Log.DEBUG))
    7374                _log.debug("Reader created");
    74             OutputStream out = sock.getOutputStream();
    7575            String ourDest = handshake(out, version, true, eventHandler);
    7676            if (ourDest == null)
     
    8080            if (_isV3) {
    8181                Socket sock2 = connect();
    82                 eventHandler = new SinkEventHandler2(_context, sock2.getInputStream());
     82                out = sock2.getOutputStream();
     83                eventHandler = new SinkEventHandler2(_context, sock2.getInputStream(), out);
    8384                _reader2 = new SAMReader(_context, sock2.getInputStream(), eventHandler);
    8485                _reader2.startReading();
    8586                if (_log.shouldLog(Log.DEBUG))
    8687                    _log.debug("Reader2 created");
    87                 out = sock2.getOutputStream();
    8888                String ok = handshake(out, version, false, eventHandler);
    8989                if (ok == null)
     
    100100    private class SinkEventHandler extends SAMEventHandler {
    101101
    102         public SinkEventHandler(I2PAppContext ctx) { super(ctx); }
     102        protected final OutputStream _out;
     103
     104        public SinkEventHandler(I2PAppContext ctx, OutputStream out) {
     105            super(ctx);
     106            _out = out;
     107        }
    103108
    104109        @Override
     
    144149            }
    145150        }
     151
     152        @Override
     153        public void pingReceived(String data) {
     154            if (_log.shouldInfo())
     155                _log.info("Got PING " + data + ", sending PONG " + data);
     156            synchronized (_out) {
     157                try {
     158                    _out.write(("PONG " + data + '\n').getBytes());
     159                    _out.flush();
     160                } catch (IOException ioe) {
     161                    _log.error("PONG fail", ioe);
     162                }
     163            }
     164        }
    146165    }
    147166
     
    150169        private final InputStream _in;
    151170
    152         public SinkEventHandler2(I2PAppContext ctx, InputStream in) {
    153             super(ctx);
     171        public SinkEventHandler2(I2PAppContext ctx, InputStream in, OutputStream out) {
     172            super(ctx, out);
    154173            _in = in;
    155174        }
     
    160179                _log.debug("got STREAM STATUS, result=" + result);
    161180            super.streamStatusReceived(result, id, message);
    162             // with SILENT=true, there's nothing else coming, so fire up the Sink
    163181            Sink sink = null;
    164182            try {
    165                 String dest = "TODO if not silent";
     183                String dest = "TODO_if_not_silent";
    166184                sink = new Sink(_v3ID, dest);
    167185                synchronized (_remotePeers) {
     
    316334                }
    317335                return destination;
    318             } catch (Exception e) {
     336            } catch (IOException e) {
    319337                _log.error("Error handshaking", e);
    320338                return null;
     
    338356            if (_log.shouldLog(Log.DEBUG))
    339357                _log.debug("My destination written to " + _destFile);
    340         } catch (Exception e) {
     358        } catch (IOException e) {
    341359            _log.error("Error writing to " + _destFile, e);
    342360            return false;
Note: See TracChangeset for help on using the changeset viewer.