Changeset 5b78b53f for router


Ignore:
Timestamp:
Feb 8, 2019 1:24:42 PM (17 months ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
51b27bb
Parents:
3ba0fcf
Message:

SSU: EstablishmentManager? fixes (ticket #2397)

Location:
router/java/src/net/i2p/router/transport/udp
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • router/java/src/net/i2p/router/transport/udp/EstablishmentManager.java

    r3ba0fcf r5b78b53f  
    478478                state = new InboundEstablishState(_context, fromIP, from.getPort(),
    479479                                                  _transport.getExternalPort(fromIP.length == 16),
    480                                                   _transport.getDHBuilder());
    481                 state.receiveSessionRequest(reader.getSessionRequestReader());
     480                                                  _transport.getDHBuilder(),
     481                                                  reader.getSessionRequestReader());
    482482
    483483                if (_replayFilter.add(state.getReceivedX(), 0, 8)) {
     
    653653                continue;
    654654            }
    655             RemoteHostId to = entry.getKey();
    656655            List<OutNetMessage> allQueued = entry.getValue();
    657656            List<OutNetMessage> queued = new ArrayList<OutNetMessage>();
     
    11351134     * Drive through the inbound establishment states, adjusting one of them
    11361135     * as necessary. Called from Establisher thread only.
    1137      * @return next requested time or -1
     1136     * @return next requested time or Long.MAX_VALUE
    11381137     */
    11391138    private long handleInbound() {
    11401139        long now = _context.clock().now();
    1141         long nextSendTime = -1;
     1140        long nextSendTime = Long.MAX_VALUE;
    11421141        InboundEstablishState inboundState = null;
    11431142        boolean expired = false;
     
    11651164                    //_context.statManager().addRateData("udp.inboundEstablishFailedState", cur.getState(), cur.getLifetime());
    11661165                } else {
    1167                     if (cur.getNextSendTime() <= now) {
     1166                    // this will always be > 0
     1167                    long next = cur.getNextSendTime();
     1168                    if (next <= now) {
    11681169                        // our turn...
    11691170                        inboundState = cur;
     
    11751176                        // stuff, so lets move on to the next one being
    11761177                        // established
    1177                         long when = -1;
    1178                         if (cur.getNextSendTime() <= 0) {
    1179                             when = cur.getEstablishBeginTime() + MAX_IB_ESTABLISH_TIME;
    1180                         } else {
    1181                             when = cur.getNextSendTime();
    1182                         }
    1183                         if (when < nextSendTime)
    1184                             nextSendTime = when;
     1178                        if (next < nextSendTime)
     1179                            nextSendTime = next;
    11851180                    }
    11861181                }
     
    12521247     * Drive through the outbound establishment states, adjusting one of them
    12531248     * as necessary. Called from Establisher thread only.
    1254      * @return next requested time or -1
     1249     * @return next requested time or Long.MAX_VALUE
    12551250     */
    12561251    private long handleOutbound() {
    12571252        long now = _context.clock().now();
    1258         long nextSendTime = -1;
     1253        long nextSendTime = Long.MAX_VALUE;
    12591254        OutboundEstablishState outboundState = null;
    12601255        //int admitted = 0;
     
    12791274                    break;
    12801275                } else {
    1281                     if (cur.getNextSendTime() <= now) {
     1276                    // this will be 0 for a new OES that needs sending, > 0 for others
     1277                    long next = cur.getNextSendTime();
     1278                    if (next <= now) {
    12821279                        // our turn...
    12831280                        outboundState = cur;
     
    12891286                        // stuff, so lets move on to the next one being
    12901287                        // established
    1291                         long when = -1;
    1292                         if (cur.getNextSendTime() <= 0) {
    1293                             when = cur.getEstablishBeginTime() + MAX_OB_ESTABLISH_TIME;
    1294                         } else {
    1295                             when = cur.getNextSendTime();
    1296                         }
    1297                         if ( (nextSendTime <= 0) || (when < nextSendTime) )
    1298                             nextSendTime = when;
     1288                        if (next < nextSendTime)
     1289                            nextSendTime = next;
    12991290                        // if (_log.shouldLog(Log.DEBUG))
    13001291                        //     _log.debug("Outbound doesn't want activity: " + cur + " (next=" + (when-now) + ")");
     
    14621453   
    14631454        private void doPass() {
    1464             if (_log.shouldLog(Log.DEBUG) && _lastPrinted + PRINT_INTERVAL < _context.clock().now()) {
    1465                 _lastPrinted = _context.clock().now();
     1455            long now = _context.clock().now();
     1456            if (_log.shouldLog(Log.DEBUG) && _lastPrinted + PRINT_INTERVAL < now) {
     1457                _lastPrinted = now;
    14661458                int iactive = _inboundStates.size();
    14671459                int oactive = _outboundStates.size();
     
    14771469            }
    14781470            _activity = 0;
    1479             long now = _context.clock().now();
    1480             if (_lastFailsafe + FAILSAFE_INTERVAL < _context.clock().now()) {
    1481                 _lastFailsafe = _context.clock().now();
     1471            if (_lastFailsafe + FAILSAFE_INTERVAL < now) {
     1472                _lastFailsafe = now;
    14821473                doFailsafe();
    14831474            }
    1484             long nextSendTime = -1;
    1485             long nextSendInbound = handleInbound();
    1486             long nextSendOutbound = handleOutbound();
    1487             if (nextSendInbound > 0)
    1488                 nextSendTime = nextSendInbound;
    1489             if ( (nextSendTime < 0) || (nextSendOutbound < nextSendTime) )
    1490                 nextSendTime = nextSendOutbound;
    1491 
     1475
     1476            long nextSendTime = Math.min(handleInbound(), handleOutbound());
    14921477            long delay = nextSendTime - now;
    1493             if ( (nextSendTime == -1) || (delay > 0) ) {
     1478            if (delay > 0) {
    14941479                if (delay > 1000)
    14951480                    delay = 1000;
     
    14981483                        if (_activity > 0)
    14991484                            return;
    1500                         if (nextSendTime == -1)
    1501                            _activityLock.wait(1000);
    1502                         else
    1503                             _activityLock.wait(delay);
     1485                        _activityLock.wait(delay);
    15041486                    }
    15051487                } catch (InterruptedException ie) {
  • router/java/src/net/i2p/router/transport/udp/InboundEstablishState.java

    r3ba0fcf r5b78b53f  
    9898     */
    9999    public InboundEstablishState(RouterContext ctx, byte remoteIP[], int remotePort, int localPort,
    100                                  DHSessionKeyBuilder dh) {
     100                                 DHSessionKeyBuilder dh, UDPPacketReader.SessionRequestReader req) {
    101101        _context = ctx;
    102102        _log = ctx.logManager().getLog(InboundEstablishState.class);
     
    109109        _keyBuilder = dh;
    110110        _queuedMessages = new LinkedBlockingQueue<OutNetMessage>();
     111        receiveSessionRequest(req);
    111112    }
    112113   
     
    289290    public long getLifetime() { return _context.clock().now() - _establishBegin; }
    290291    public long getEstablishBeginTime() { return _establishBegin; }
     292
     293    /**
     294     *  @return rcv time after receiving a packet (including after constructor),
     295     *          send time + delay after sending a packet
     296     */
    291297    public synchronized long getNextSendTime() { return _nextSend; }
    292298
     
    479485    }
    480486   
     487    /**
     488     *  Call from synchronized method only
     489     */
    481490    private void packetReceived() {
    482491        _nextSend = _context.clock().now();
  • router/java/src/net/i2p/router/transport/udp/OutboundEstablishState.java

    r3ba0fcf r5b78b53f  
    654654    public long getLifetime() { return _context.clock().now() - _establishBegin; }
    655655    public long getEstablishBeginTime() { return _establishBegin; }
     656
     657    /**
     658     *  @return 0 at initialization (to force sending session request),
     659     *          rcv time after receiving a packet,
     660     *          send time + delay after sending a packet (including session request)
     661     */
    656662    public synchronized long getNextSendTime() { return _nextSend; }
    657663
     
    679685    }
    680686   
     687    /**
     688     *  Call from synchronized method only
     689     */
    681690    private void packetReceived() {
    682691        _nextSend = _context.clock().now();
    683         if (_log.shouldLog(Log.DEBUG))
    684             _log.debug("Got a packet, nextSend == now");
     692        //if (_log.shouldLog(Log.DEBUG))
     693        //    _log.debug("Got a packet, nextSend == now");
    685694    }
    686695
Note: See TracChangeset for help on using the changeset viewer.