Changeset 97f402b


Ignore:
Timestamp:
Mar 8, 2012 5:48:19 PM (8 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
e4257f2
Parents:
1e978ea
Message:
  • SessionKeyManager?:
    • Don't use unacked tagsets after consecutive ack failures and revert to full ElGamal? if necessary (ticket #574)
    • Synchronize creation of new sessions to prevent dups
    • Don't remove an unacked session until it's really out of tags
    • Failsafe removal of old unacked tagsets
    • Cleanups, final, comments, log tweaks, debug.jsp tweaks, synchronization tweaks
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • core/java/src/net/i2p/crypto/SessionKeyManager.java

    r1e978ea r97f402b  
    3939     * or null if a new session key should be generated.
    4040     *
     41     * Warning - don't generate a new session if this returns null, it's racy, use getCurrentOrNewKey()
    4142     */
    4243    public SessionKey getCurrentKey(PublicKey target) {
     44        return null;
     45    }
     46
     47    /**
     48     * Retrieve the session key currently associated with encryption to the target.
     49     * Generates a new session and session key if not previously exising.
     50     *
     51     * @return non-null
     52     * @since 0.9
     53     */
     54    public SessionKey getCurrentOrNewKey(PublicKey target) {
    4355        return null;
    4456    }
     
    4860     * when to expire that key begin with this call.
    4961     *
     62     * @deprecated racy
    5063     */
    5164    public void createSession(PublicKey target, SessionKey key) { // nop
     
    5568     * Generate a new session key and associate it with the specified target. 
    5669     *
     70     * @deprecated racy
    5771     */
    5872    public SessionKey createSession(PublicKey target) {
  • core/java/src/net/i2p/crypto/TransientSessionKeyManager.java

    r1e978ea r97f402b  
    2323import java.util.Set;
    2424import java.util.TreeSet;
     25import java.util.concurrent.atomic.AtomicInteger;
    2526
    2627import net.i2p.I2PAppContext;
     
    7576 */
    7677public class TransientSessionKeyManager extends SessionKeyManager {
    77     private Log _log;
     78    private final Log _log;
    7879    /** Map allowing us to go from the targeted PublicKey to the OutboundSession used */
    7980    private final Map<PublicKey, OutboundSession> _outboundSessions;
    8081    /** Map allowing us to go from a SessionTag to the containing TagSet */
    8182    private final Map<SessionTag, TagSet> _inboundTagSets;
    82     protected I2PAppContext _context;
     83    protected final I2PAppContext _context;
    8384    private volatile boolean _alive;
     85    /** for debugging */
     86    private final AtomicInteger _rcvTagSetID = new AtomicInteger();
     87    private final AtomicInteger _sentTagSetID = new AtomicInteger();
    8488
    8589    /**
     
    120124        SimpleScheduler.getInstance().addEvent(new CleanupEvent(), 60*1000);
    121125    }
    122     private TransientSessionKeyManager() { this(null); }
    123126   
    124127    @Override
     
    193196     * or null if a new session key should be generated.
    194197     *
     198     * Warning - don't generate a new session if this returns null, it's racy, use getCurrentOrNewKey()
    195199     */
    196200    @Override
     
    205209                          + " but not used for "
    206210                          + (now-sess.getLastUsedDate())
    207                           + "ms with target " + target);
     211                          + "ms with target " + toString(target));
    208212            return null;
    209213        }
    210214        return sess.getCurrentKey();
     215    }
     216
     217    /**
     218     * Retrieve the session key currently associated with encryption to the target.
     219     * Generates a new session and session key if not previously exising.
     220     *
     221     * @return non-null
     222     * @since 0.9
     223     */
     224    @Override
     225    public SessionKey getCurrentOrNewKey(PublicKey target) {
     226        synchronized (_outboundSessions) {
     227            OutboundSession sess = _outboundSessions.get(target);
     228            if (sess != null) {
     229                long now = _context.clock().now();
     230                if (sess.getLastUsedDate() < now - SESSION_LIFETIME_MAX_MS)
     231                    sess = null;
     232            }
     233            if (sess == null) {
     234                SessionKey key = _context.keyGenerator().generateSessionKey();
     235                sess = createAndReturnSession(target, key);
     236                return key;
     237            }
     238            return sess.getCurrentKey();
     239        }
    211240    }
    212241
     
    215244     * when to expire that key begin with this call.
    216245     *
     246     * @deprecated racy
    217247     */
    218248    @Override
     
    227257     */
    228258    private OutboundSession createAndReturnSession(PublicKey target, SessionKey key) {
    229         OutboundSession sess = new OutboundSession(target);
     259        if (_log.shouldLog(Log.INFO))
     260            _log.info("New OB session, sesskey: " + key + " target: " + toString(target));
     261        OutboundSession sess = new OutboundSession(_context, _log, target);
    230262        sess.setCurrentKey(key);
    231263        addSession(sess);
     
    244276        OutboundSession sess = getSession(target);
    245277        if (sess == null) {
    246             if (_log.shouldLog(Log.DEBUG))
    247                 _log.debug("No session for " + target);
     278            if (_log.shouldLog(Log.WARN))
     279                _log.warn("No session for " + toString(target));
    248280            return null;
    249281        }
    250282        if (sess.getCurrentKey().equals(key)) {
    251283            SessionTag nxt = sess.consumeNext();
    252             if (_log.shouldLog(Log.DEBUG))
    253                 _log.debug("OB Tag consumed: " + nxt + " with: " + key);
     284            // logged in OutboundSession
     285            //if (nxt != null && _log.shouldLog(Log.DEBUG))
     286            //    _log.debug("OB Tag consumed: " + nxt + " with: " + key);
    254287            return nxt;
    255288        }
    256         if (_log.shouldLog(Log.DEBUG))
    257             _log.debug("Key does not match existing key, no tag");
     289        if (_log.shouldLog(Log.WARN))
     290            _log.warn("Key does not match existing key, no tag");
    258291        return null;
    259292    }
     
    306339    @Override
    307340    public TagSetHandle tagsDelivered(PublicKey target, SessionKey key, Set<SessionTag> sessionTags) {
    308         if (_log.shouldLog(Log.DEBUG)) {
    309             //_log.debug("Tags delivered to set " + set + " on session " + sess);
    310             if (!sessionTags.isEmpty())
    311                 _log.debug("Tags delivered: " + sessionTags.size() + " for key: " + key + ": " + sessionTags);
    312         }
     341        // if this is ever null, this is racy and needs synch
    313342        OutboundSession sess = getSession(target);
    314         if (sess == null)
     343        if (sess == null) {
     344            if (_log.shouldLog(Log.WARN))
     345                _log.warn("No session for delivered TagSet to target: " + toString(target));
    315346            sess = createAndReturnSession(target, key);
    316         else
     347        } else {
    317348            sess.setCurrentKey(key);
    318         TagSet set = new TagSet(sessionTags, key, _context.clock().now());
     349        }
     350        TagSet set = new TagSet(sessionTags, key, _context.clock().now(), _sentTagSetID.incrementAndGet());
    319351        sess.addTags(set);
     352        if (_log.shouldLog(Log.DEBUG))
     353            _log.debug("Tags delivered: " + set +
     354                       " target: " + toString(target) /** + ": " + sessionTags */ );
    320355        return set;
    321356    }
     
    340375    public void failTags(PublicKey target, SessionKey key, TagSetHandle ts) {
    341376        OutboundSession sess = getSession(target);
    342         if (sess == null)
     377        if (sess == null) {
     378            if (_log.shouldLog(Log.WARN))
     379                _log.warn("No session for failed TagSet: " + ts);
    343380            return;
    344         if(!key.equals(sess.getCurrentKey()))
     381        }
     382        if(!key.equals(sess.getCurrentKey())) {
     383            if (_log.shouldLog(Log.WARN))
     384                _log.warn("Wrong session key (wanted " + sess.getCurrentKey() + ") for failed TagSet: " + ts);
    345385            return;
     386        }
     387        if (_log.shouldLog(Log.WARN))
     388            _log.warn("TagSet failed: " + ts);
    346389        sess.failTags((TagSet)ts);
    347         if (_log.shouldLog(Log.DEBUG))
    348             _log.debug("TagSet failed: " + ts);
    349390    }
    350391
     
    355396    public void tagsAcked(PublicKey target, SessionKey key, TagSetHandle ts) {
    356397        OutboundSession sess = getSession(target);
    357         if (sess == null)
     398        if (sess == null) {
     399            if (_log.shouldLog(Log.WARN))
     400                _log.warn("No session for acked TagSet: " + ts);
    358401            return;
    359         if(!key.equals(sess.getCurrentKey()))
     402        }
     403        if(!key.equals(sess.getCurrentKey())) {
     404            if (_log.shouldLog(Log.WARN))
     405                _log.warn("Wrong session key (wanted " + sess.getCurrentKey() + ") for acked TagSet: " + ts);
    360406            return;
    361         sess.ackTags((TagSet)ts);
     407        }
    362408        if (_log.shouldLog(Log.DEBUG))
    363409            _log.debug("TagSet acked: " + ts);
     410        sess.ackTags((TagSet)ts);
    364411    }
    365412
     
    371418    public void tagsReceived(SessionKey key, Set<SessionTag> sessionTags) {
    372419        int overage = 0;
    373         TagSet tagSet = new TagSet(sessionTags, key, _context.clock().now());
     420        TagSet tagSet = new TagSet(sessionTags, key, _context.clock().now(), _rcvTagSetID.incrementAndGet());
     421        if (_log.shouldLog(Log.INFO))
     422            _log.info("Received " + tagSet);
    374423        TagSet old = null;
    375424        SessionTag dupTag = null;
     
    377426            SessionTag tag = iter.next();
    378427            if (_log.shouldLog(Log.DEBUG))
    379                 _log.debug("Receiving tag " + tag + " for key " + key + ": tagSet: " + tagSet);
     428                _log.debug("Receiving tag " + tag + " in tagSet: " + tagSet);
    380429            synchronized (_inboundTagSets) {
    381430                old = _inboundTagSets.put(tag, tagSet);
     
    416465            clearExcess(overage);
    417466
    418         if ( (sessionTags.isEmpty()) && (_log.shouldLog(Log.DEBUG)) )
    419             _log.debug("Received 0 tags for key " + key);
     467        //if ( (sessionTags.isEmpty()) && (_log.shouldLog(Log.DEBUG)) )
     468        //    _log.debug("Received 0 tags for key " + key);
    420469        //if (false) aggressiveExpire();
    421470    }
     
    495544            SessionKey key = tagSet.getAssociatedKey();
    496545            if (_log.shouldLog(Log.DEBUG))
    497                 _log.debug("Consuming IB " + tag + " for " + key + " on: " + tagSet);
     546                _log.debug("IB Tag consumed: " + tag + " from: " + tagSet);
    498547            return key;
    499548        }
     
    608657                int size = ts.getTags().size();
    609658                total += size;
    610                 buf.append("<li><b>Received:</b> ").append(DataHelper.formatDuration(now - ts.getDate())).append(" ago with ");
     659                buf.append("<li><b>ID: ").append(ts.getID())
     660                   .append(" Received:</b> ").append(DataHelper.formatDuration2(now - ts.getDate())).append(" ago with ");
    611661                buf.append(size).append(" tags remaining</li>");
    612662            }
     
    616666        }
    617667        buf.append("<tr><th colspan=\"2\">Total tags: ").append(total).append(" (");
    618         buf.append(DataHelper.formatSize(32*total)).append("B)</th></tr>\n" +
     668        buf.append(DataHelper.formatSize2(32*total)).append("B)</th></tr>\n" +
    619669                   "</table>" +
    620670                   "<h2><b>Outbound sessions</b></h2>" +
     
    626676            Set<TagSet> sets = new TreeSet(new TagSetComparator());
    627677            sets.addAll(sess.getTagSets());
    628             buf.append("<tr><td><b>Target public key:</b> ").append(sess.getTarget().toBase64().substring(0, 20)).append("...<br>" +
    629                        "<b>Established:</b> ").append(DataHelper.formatDuration(now - sess.getEstablishedDate())).append(" ago<br>" +
    630                        "<b>Last Used:</b> ").append(DataHelper.formatDuration(now - sess.getLastUsedDate())).append(" ago<br>" +
     678            buf.append("<tr><td><b>Target public key:</b> ").append(toString(sess.getTarget())).append("<br>" +
     679                       "<b>Established:</b> ").append(DataHelper.formatDuration2(now - sess.getEstablishedDate())).append(" ago<br>" +
     680                       "<b>Ack Received?</b> ").append(sess.getAckReceived()).append("<br>" +
     681                       "<b>Last Used:</b> ").append(DataHelper.formatDuration2(now - sess.getLastUsedDate())).append(" ago<br>" +
    631682                       "<b>Session key:</b> ").append(sess.getCurrentKey().toBase64()).append("</td>" +
    632683                       "<td><b># Sets:</b> ").append(sess.getTagSets().size()).append("</td></tr>" +
     
    636687                int size = ts.getTags().size();
    637688                total += size;
    638                 buf.append("<li><b>Sent:</b> ").append(DataHelper.formatDuration(now - ts.getDate())).append(" ago with ");
     689                buf.append("<li><b>ID: ").append(ts.getID())
     690                   .append(" Sent:</b> ").append(DataHelper.formatDuration2(now - ts.getDate())).append(" ago with ");
    639691                buf.append(size).append(" tags remaining; acked? ").append(ts.getAcked()).append("</li>");
    640692            }
     
    644696        }
    645697        buf.append("<tr><th colspan=\"2\">Total tags: ").append(total).append(" (");
    646         buf.append(DataHelper.formatSize(32*total)).append("B)</th></tr>\n" +
     698        buf.append(DataHelper.formatSize2(32*total)).append("B)</th></tr>\n" +
    647699                   "</table>");
    648700
    649701        out.write(buf.toString());
     702    }
     703
     704    /**
     705     *  For debugging
     706     *  @since 0.9
     707     */
     708    private static String toString(PublicKey target) {
     709        if (target == null)
     710            return "null";
     711        return target.toBase64().substring(0, 20) + "...";
    650712    }
    651713
     
    660722    }
    661723
    662     /** fixme pass in context and change to static */
    663     private class OutboundSession {
    664         private PublicKey _target;
     724    /**
     725     *  The state for a crypto session to a single public key
     726     */
     727    private static class OutboundSession {
     728        private final I2PAppContext _context;
     729        private final Log _log;
     730        private final PublicKey _target;
    665731        private SessionKey _currentKey;
    666         private long _established;
     732        private final long _established;
    667733        private long _lastUsed;
    668         /** before the first ack, all tagsets go here. These are never expired, we rely
    669             on the callers to call failTags() or ackTags() to remove them from this list. */
    670         private /* FIXME final FIXME */ List<TagSet> _unackedTagSets;
     734        /**
     735         *  Before the first ack, all tagsets go here. These are never expired, we rely
     736         *  on the callers to call failTags() or ackTags() to remove them from this list.
     737         *  Actually we now do a failsafe expire.
     738         *  Synch on _tagSets to access this.
     739         */
     740        private final List<TagSet> _unackedTagSets;
    671741        /**
    672742         *  As tagsets are acked, they go here.
    673743         *  After the first ack, new tagsets go here (i.e. presumed acked)
    674744         */
    675         private /* FIXME final FIXME */ List<TagSet> _tagSets;
    676         /** set to true after first tagset is acked */
    677         private boolean _acked;
    678 
    679         public OutboundSession(PublicKey target) {
    680             this(target, null, _context.clock().now(), _context.clock().now(), new ArrayList());
    681         }
    682 
    683         OutboundSession(PublicKey target, SessionKey curKey, long established, long lastUsed, List<TagSet> tagSets) {
     745        private final List<TagSet> _tagSets;
     746        /**
     747         *  Set to true after first tagset is acked.
     748         *  Upon repeated failures, we may revert back to false.
     749         *  This prevents us getting "stuck" forever, using tags that weren't acked
     750         *  to deliver the next set of tags.
     751         */
     752        private volatile boolean _acked;
     753        /**
     754         *  Fail count
     755         *  Synch on _tagSets to access this.
     756         */
     757        private int _consecutiveFailures;
     758
     759        private static final int MAX_FAILS = 2;
     760
     761        public OutboundSession(I2PAppContext ctx, Log log, PublicKey target) {
     762            this(ctx, log, target, null, ctx.clock().now(), ctx.clock().now(), new ArrayList());
     763        }
     764
     765        OutboundSession(I2PAppContext ctx, Log log, PublicKey target, SessionKey curKey,
     766                        long established, long lastUsed, List<TagSet> tagSets) {
     767            _context = ctx;
     768            _log = log;
    684769            _target = target;
    685770            _currentKey = curKey;
     
    712797            synchronized (_tagSets) {
    713798                if (_unackedTagSets.remove(set)) {
     799                    // we could perhaps use it even if not previuosly in unacked,
     800                    // i.e. it was expired already, but _tagSets is a list not a set...
    714801                    _tagSets.add(set);
    715                     _acked = true;
    716                 }
     802                } else if (_log.shouldLog(Log.WARN)) {
     803                    if(!_tagSets.contains(set))
     804                       _log.warn("Ack of unknown tagset: " + set);
     805                    else if (set.getAcked())
     806                       _log.warn("Dup ack of tagset: " + set);
     807                }
     808                _acked = true;
     809                _consecutiveFailures = 0;
    717810            }
    718811            set.setAcked();
     
    723816            synchronized (_tagSets) {
    724817                _unackedTagSets.remove(set);
    725                 _tagSets.remove(set);
     818                if (_tagSets.remove(set)) {
     819                    if (++_consecutiveFailures >= MAX_FAILS) {
     820                        // revert back to non-speculative ack mode,
     821                        // and force full ElG next time by reclassifying all tagsets that weren't really acked
     822                        _acked = false;
     823                        int acked = 0;
     824                        int unacked = 0;
     825                        for (Iterator<TagSet> iter = _tagSets.iterator(); iter.hasNext(); ) {
     826                            TagSet ts = iter.next();
     827                            if (!ts.getAcked()) {
     828                                iter.remove();
     829                                _unackedTagSets.add(ts);
     830                                unacked++;
     831                            } else {
     832                                acked++;
     833                            }
     834                        }
     835                        if (_log.shouldLog(Log.WARN))
     836                            _log.warn(_consecutiveFailures + " consecutive failed tagset deliveries to " + _currentKey
     837                                      + ": reverting to full ElG and un-acking " + unacked + " unacked tag sets, with "
     838                                      + acked + " remaining acked tag sets");
     839                    }
     840                }
    726841            }
    727842        }
     
    739854            if (_currentKey != null) {
    740855                if (!_currentKey.equals(key)) {
    741                     int dropped = 0;
    742                     List<TagSet> sets = _tagSets;
    743                     _tagSets = new ArrayList();
    744                     for (int i = 0; i < sets.size(); i++) {
    745                         TagSet set = (TagSet) sets.get(i);
    746                         dropped += set.getTags().size();
     856                    synchronized (_tagSets) {
     857                        if (_log.shouldLog(Log.WARN)) {
     858                            int dropped = 0;
     859                            for (TagSet set : _tagSets) {
     860                                dropped += set.getTags().size();
     861                            }
     862                            _log.warn("Rekeyed from " + _currentKey + " to " + key
     863                                      + ": dropping " + dropped + " session tags", new Exception());
     864                        }
     865                        _acked = false;
     866                        _tagSets.clear();
    747867                    }
    748                     if (_log.shouldLog(Log.INFO))
    749                         _log.info("Rekeyed from " + _currentKey + " to " + key
    750                                   + ": dropping " + dropped + " session tags");
    751868                }
    752869            }
     
    770887            int removed = 0;
    771888            synchronized (_tagSets) {
    772                 for (int i = 0; i < _tagSets.size(); i++) {
    773                     TagSet set = _tagSets.get(i);
     889                for (Iterator<TagSet> iter = _tagSets.iterator(); iter.hasNext(); ) {
     890                    TagSet set = iter.next();
    774891                    if (set.getDate() + SESSION_TAG_DURATION_MS <= now) {
    775                         _tagSets.remove(i);
    776                         i--;
     892                        iter.remove();
    777893                        removed++;
     894                    }
     895                }
     896                // failsafe, sometimes these are sticking around, not sure why, so clean them periodically
     897                if ((now & 0x0f) == 0) {
     898                    for (Iterator<TagSet> iter = _unackedTagSets.iterator(); iter.hasNext(); ) {
     899                        TagSet set = iter.next();
     900                        if (set.getDate() + SESSION_TAG_DURATION_MS <= now) {
     901                            iter.remove();
     902                            removed++;
     903                        }
    778904                    }
    779905                }
     
    790916                    if (set.getDate() + SESSION_TAG_DURATION_MS > now) {
    791917                        SessionTag tag = set.consumeNext();
    792                         if (tag != null) return tag;
     918                        if (tag != null) {
     919                            if (_log.shouldLog(Log.DEBUG))
     920                                _log.debug("OB Tag consumed: " + tag + " from: " + set);
     921                            return tag;
     922                        } else if (_log.shouldLog(Log.INFO)) {
     923                            _log.info("Removing empty " + set);
     924                        }
    793925                    } else {
    794926                        if (_log.shouldLog(Log.INFO))
    795                             _log.info("TagSet from " + new Date(set.getDate()) + " expired");
     927                            _log.info("Expired " + set);
    796928                    }
    797929                    _tagSets.remove(0);
     
    813945                        // 30, 17, and 4.
    814946                        if (!set.getAcked())
    815                             sz /= 3;
     947                            // round up so we don't report 0 when we have 1 or 2 remaining and get the session removed
     948                            sz = (sz + 2) / 3;
    816949                        tags += sz;
    817950                    }
     
    847980        public void addTags(TagSet set) {
    848981            _lastUsed = _context.clock().now();
    849             if (_acked) {
    850                 synchronized (_tagSets) {
     982            synchronized (_tagSets) {
     983                if (_acked)
    851984                    _tagSets.add(set);
    852                 }
    853             } else {
    854                 synchronized (_unackedTagSets) {
     985                else
    855986                    _unackedTagSets.add(set);
    856                 }
    857             }
     987            }
     988        }
     989
     990        /** @since 0.9 for debugging */
     991        public boolean getAckReceived() {
     992            return _acked;
    858993        }
    859994    }
    860995
    861996    private static class TagSet implements TagSetHandle {
    862         private Set<SessionTag> _sessionTags;
    863         private SessionKey _key;
    864         private long _date;
     997        private final Set<SessionTag> _sessionTags;
     998        private final SessionKey _key;
     999        private final long _date;
     1000        private final int _id;
    8651001        //private Exception _createdBy;
    866         /** did we get an ack for this tagset? */
     1002        /** did we get an ack for this tagset? Only for outbound tagsets */
    8671003        private boolean _acked;
    8681004
    869         public TagSet(Set<SessionTag> tags, SessionKey key, long date) {
     1005        public TagSet(Set<SessionTag> tags, SessionKey key, long date, int id) {
    8701006            if (key == null) throw new IllegalArgumentException("Missing key");
    8711007            if (tags == null) throw new IllegalArgumentException("Missing tags");
     
    8731009            _key = key;
    8741010            _date = date;
     1011            _id = id;
    8751012            //if (true) {
    8761013            //    long now = I2PAppContext.getGlobalContext().clock().now();
     
    8861023        }
    8871024
    888         void setDate(long when) {
    889             _date = when;
    890         }
     1025        //void setDate(long when) {
     1026        //    _date = when;
     1027        //}
    8911028
    8921029        /** tags still available */
     
    8991036        }
    9001037
     1038        /**
     1039         *  Caller must synch.
     1040         */
    9011041        public boolean contains(SessionTag tag) {
    9021042            return _sessionTags.contains(tag);
    9031043        }
    9041044
     1045        /**
     1046         *  Caller must synch.
     1047         */
    9051048        public void consume(SessionTag tag) {
    9061049            _sessionTags.remove(tag);
    9071050        }
    9081051
    909         /** let's do this without counting the elements first */
     1052        /**
     1053         *  Let's do this without counting the elements first.
     1054         *  Caller must synch.
     1055         */
    9101056        public SessionTag consumeNext() {
    9111057            SessionTag first;
     
    9441090******/
    9451091
     1092        /** @since 0.9 for debugging */
     1093        public int getID() {
     1094            return _id;
     1095        }
     1096
    9461097        @Override
    9471098        public String toString() {
    9481099            StringBuilder buf = new StringBuilder(256);
    949             buf.append("TagSet established: ").append(new Date(_date));
    950             buf.append(" Session key: ").append(_key.toBase64());
     1100            buf.append("TagSet #").append(_id).append(" created: ").append(new Date(_date));
     1101            buf.append(" Session key: ").append(_key);
    9511102            buf.append(" Size: ").append(_sessionTags.size());
    9521103            buf.append(" Acked? ").append(_acked);
  • history.txt

    r1e978ea r97f402b  
     12012-03-09 zzz
     2  * GarlicConfig: Remove unused reply block methods
     3  * SessionKeyManager:
     4    - Don't use unacked tagsets after consecutive ack failures
     5      and revert to full ElGamal if necessary (ticket #574)
     6    - Synchronize creation of new sessions to prevent dups
     7    - Don't remove an unacked session until it's really out of tags
     8    - Failsafe removal of old unacked tagsets
     9    - Cleanups, final, comments, log tweaks, debug.jsp tweaks, synchronization tweaks
     10
    1112012-03-06 kytv
    212 * German and Spanish translation updates from Transifex
  • router/java/src/net/i2p/router/RouterVersion.java

    r1e978ea r97f402b  
    1919    public final static String ID = "Monotone";
    2020    public final static String VERSION = CoreVersion.VERSION;
    21     public final static long BUILD = 6;
     21    public final static long BUILD = 7;
    2222
    2323    /** for example "-test" */
  • router/java/src/net/i2p/router/message/GarlicMessageBuilder.java

    r1e978ea r97f402b  
    166166            log.info("Encrypted with public key " + key + " to expire on " + new Date(config.getExpiration()));
    167167       
    168         SessionKey curKey = skm.getCurrentKey(key);
     168        SessionKey curKey = skm.getCurrentOrNewKey(key);
    169169        SessionTag curTag = null;
    170         if (curKey == null)
    171             curKey = skm.createSession(key);
    172170        if (!forceElGamal) {
    173171            curTag = skm.consumeNextAvailableTag(key, curKey);
Note: See TracChangeset for help on using the changeset viewer.