Changeset 50268de8 for router


Ignore:
Timestamp:
Mar 11, 2018 5:27:05 PM (2 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
63a8b46
Parents:
96d7c73
Message:

Router: More peer selection fixes for hidden mode
Fix excludes after calling SANFP
Pick connected OBEP when hidden and paired tunnel is zero-hop

Location:
router/java/src/net/i2p/router
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • router/java/src/net/i2p/router/RouterVersion.java

    r96d7c73 r50268de8  
    1919    public final static String ID = "Monotone";
    2020    public final static String VERSION = CoreVersion.VERSION;
    21     public final static long BUILD = 14;
     21    public final static long BUILD = 15;
    2222
    2323    /** for example "-test" */
  • router/java/src/net/i2p/router/TunnelManagerFacade.java

    r96d7c73 r50268de8  
    183183    public TunnelPool getOutboundExploratoryPool();
    184184
     185    /**
     186     *  @return pool or null
     187     *  @since 0.9.34
     188     */
     189    public TunnelPool getInboundPool(Hash client);
     190
     191    /**
     192     *  @return pool or null
     193     *  @since 0.9.34
     194     */
     195    public TunnelPool getOutboundPool(Hash client);
     196
    185197    /** @since 0.8.13 */
    186198    public void fail(Hash peer);
  • router/java/src/net/i2p/router/dummy/DummyTunnelManagerFacade.java

    r96d7c73 r50268de8  
    7676    public TunnelPool getOutboundExploratoryPool() { return null; }
    7777    public void fail(Hash peer) {}
     78
     79    public TunnelPool getInboundPool(Hash client) {
     80        return null;
     81    }
     82
     83    public TunnelPool getOutboundPool(Hash client) {
     84        return null;
     85    }
    7886}
  • router/java/src/net/i2p/router/peermanager/ProfileOrganizer.java

    r96d7c73 r50268de8  
    572572     * be used when there is a good number of connected peers.
    573573     *
    574      * @param exclude non-null
     574     * @param exclude non-null, WARNING - side effect, all not-connected peers are added
    575575     * No mask parameter, to be fixed
    576576     */
  • router/java/src/net/i2p/router/tunnel/pool/ClientPeerSelector.java

    r96d7c73 r50268de8  
    99import net.i2p.data.Hash;
    1010import net.i2p.router.RouterContext;
     11import net.i2p.router.TunnelInfo;
     12import net.i2p.router.TunnelManagerFacade;
    1113import net.i2p.router.TunnelPoolSettings;
    1214import static net.i2p.router.peermanager.ProfileOrganizer.Slice.*;
     
    5355                             ctx.router().getRouterInfo().getAddressCount() <= 0;
    5456            boolean hiddenInbound = hidden && isInbound;
     57            boolean hiddenOutbound = hidden && !isInbound;
    5558
    5659            if (shouldSelectExplicit(settings))
     
    6669                        exclude.addAll(moreExclude);
    6770                }
    68                 if (hiddenInbound)
    69                     ctx.profileOrganizer().selectActiveNotFailingPeers(1, exclude, matches);
     71                if (hiddenInbound) {
     72                    // SANFP adds all not-connected to exclude, so make a copy
     73                    Set<Hash> SANFPExclude = new HashSet<Hash>(exclude);
     74                    ctx.profileOrganizer().selectActiveNotFailingPeers(1, SANFPExclude, matches);
     75                }
    7076                if (matches.isEmpty()) {
    7177                    // ANFP does not fall back to non-connected
     
    7985                // For a longer tunnels, the first hop comes from subtier 0, the middle from subtiers 2-3, and the last from subtier 1.
    8086                rv = new ArrayList<Hash>(length + 1);
     87                Hash randomKey = settings.getRandomKey();
    8188                // OBEP or IB last hop
    8289                // group 0 or 1 if two hops, otherwise group 0
    83                 Set<Hash> firstHopExclude;
     90                Set<Hash> lastHopExclude;
    8491                if (isInbound) {
    8592                    // exclude existing OBEPs to get some diversity ?
     
    8996                        if (moreExclude != null) {
    9097                            moreExclude.addAll(exclude);
    91                             firstHopExclude = moreExclude;
     98                            lastHopExclude = moreExclude;
    9299                        } else {
    93                             firstHopExclude = exclude;
     100                            lastHopExclude = exclude;
    94101                        }
    95102                    } else {
    96                          firstHopExclude = exclude;
     103                         lastHopExclude = exclude;
    97104                    }
    98105                } else {
    99                     firstHopExclude = exclude;
     106                    lastHopExclude = exclude;
    100107                }
    101108                if (hiddenInbound) {
    102                     ctx.profileOrganizer().selectActiveNotFailingPeers(1, exclude, matches);
     109                    // IB closest hop
     110                    if (log.shouldInfo())
     111                        log.info("CPS SANFP closest IB exclude " + lastHopExclude.size());
     112                    // SANFP adds all not-connected to exclude, so make a copy
     113                    Set<Hash> SANFPExclude = new HashSet<Hash>(lastHopExclude);
     114                    ctx.profileOrganizer().selectActiveNotFailingPeers(1, SANFPExclude, matches);
    103115                    if (matches.isEmpty()) {
     116                        if (log.shouldInfo())
     117                            log.info("CPS SFP closest IB exclude " + lastHopExclude.size());
    104118                        // ANFP does not fall back to non-connected
    105                         ctx.profileOrganizer().selectFastPeers(1, firstHopExclude, matches, settings.getRandomKey(), length == 2 ? SLICE_0_1 : SLICE_0);
     119                        ctx.profileOrganizer().selectFastPeers(1, lastHopExclude, matches, randomKey, length == 2 ? SLICE_0_1 : SLICE_0);
     120                    }
     121                } else if (hiddenOutbound) {
     122                    // OBEP
     123                    // check for hidden and outbound, and the paired (inbound) tunnel is zero-hop
     124                    // if so, we need the OBEP to be connected to us, so we get the build reply back
     125                    // This should be rare except at startup
     126                    TunnelManagerFacade tmf = ctx.tunnelManager();
     127                    TunnelPool tp = tmf.getInboundPool(settings.getDestination());
     128                    boolean pickFurthest;
     129                    if (tp != null) {
     130                        pickFurthest = true;
     131                        TunnelPoolSettings tps = tp.getSettings();
     132                        int len = tps.getLength();
     133                        if (len <= 0 ||
     134                            tps.getLengthOverride() == 0 ||
     135                            len + tps.getLengthVariance() <= 0) {
     136                            // leave it true
     137                        } else {
     138                            List<TunnelInfo> tunnels = tp.listTunnels();
     139                            if (!tunnels.isEmpty()) {
     140                                for (TunnelInfo ti : tp.listTunnels()) {
     141                                    if (ti.getLength() > 1) {
     142                                        pickFurthest = false;
     143                                        break;
     144                                    }
     145                                }
     146                            } else {
     147                                // no tunnels in the paired tunnel pool
     148                                // BuildRequester will be using exploratory
     149                                tp = tmf.getInboundExploratoryPool();
     150                                tps = tp.getSettings();
     151                                len = tps.getLength();
     152                                if (len <= 0 ||
     153                                    tps.getLengthOverride() == 0 ||
     154                                    len + tps.getLengthVariance() <= 0) {
     155                                    // leave it true
     156                                } else {
     157                                    tunnels = tp.listTunnels();
     158                                    if (!tunnels.isEmpty()) {
     159                                        for (TunnelInfo ti : tp.listTunnels()) {
     160                                            if (ti.getLength() > 1) {
     161                                                pickFurthest = false;
     162                                                break;
     163                                            }
     164                                        }
     165                                    }
     166                                }
     167                            }
     168                        }
     169                    } else {
     170                        // shouldn't happen
     171                        pickFurthest = false;
     172                    }
     173                    if (pickFurthest) {
     174                        if (log.shouldInfo())
     175                            log.info("CPS SANFP OBEP exclude " + lastHopExclude.size());
     176                        // SANFP adds all not-connected to exclude, so make a copy
     177                        Set<Hash> SANFPExclude = new HashSet<Hash>(lastHopExclude);
     178                        ctx.profileOrganizer().selectActiveNotFailingPeers(1, SANFPExclude, matches);
     179                        if (matches.isEmpty()) {
     180                            // ANFP does not fall back to non-connected
     181                            if (log.shouldInfo())
     182                                log.info("CPS SFP OBEP exclude " + lastHopExclude.size());
     183                            ctx.profileOrganizer().selectFastPeers(1, lastHopExclude, matches, randomKey, length == 2 ? SLICE_0_1 : SLICE_0);
     184                        }
     185                    } else {
     186                        ctx.profileOrganizer().selectFastPeers(1, lastHopExclude, matches, randomKey, length == 2 ? SLICE_0_1 : SLICE_0);
    106187                    }
    107188                } else {
    108189                    // TODO exclude IPv6-only at OBEP? Caught in checkTunnel() below
    109                     ctx.profileOrganizer().selectFastPeers(1, firstHopExclude, matches, settings.getRandomKey(), length == 2 ? SLICE_0_1 : SLICE_0);
    110                 }
     190                    ctx.profileOrganizer().selectFastPeers(1, lastHopExclude, matches, randomKey, length == 2 ? SLICE_0_1 : SLICE_0);
     191                }
     192
    111193                matches.remove(ctx.routerHash());
    112194                exclude.addAll(matches);
     
    116198                    // middle hop(s)
    117199                    // group 2 or 3
    118                     ctx.profileOrganizer().selectFastPeers(length - 2, exclude, matches, settings.getRandomKey(), SLICE_2_3);
     200                    ctx.profileOrganizer().selectFastPeers(length - 2, exclude, matches, randomKey, SLICE_2_3);
    119201                    matches.remove(ctx.routerHash());
    120202                    if (matches.size() > 1) {
    121203                        // order the middle peers for tunnels >= 4 hops
    122204                        List<Hash> ordered = new ArrayList<Hash>(matches);
    123                         orderPeers(ordered, settings.getRandomKey());
     205                        orderPeers(ordered, randomKey);
    124206                        rv.addAll(ordered);
    125207                    } else {
     
    129211                    matches.clear();
    130212                }
     213
    131214                // IBGW or OB first hop
    132215                // group 2 or 3 if two hops, otherwise group 1
     
    141224                }
    142225                // TODO exclude IPv6-only at IBGW? Caught in checkTunnel() below
    143                 ctx.profileOrganizer().selectFastPeers(1, exclude, matches, settings.getRandomKey(), length == 2 ? SLICE_2_3 : SLICE_1);
     226                ctx.profileOrganizer().selectFastPeers(1, exclude, matches, randomKey, length == 2 ? SLICE_2_3 : SLICE_1);
    144227                matches.remove(ctx.routerHash());
    145228                rv.addAll(matches);
  • router/java/src/net/i2p/router/tunnel/pool/ExploratoryPeerSelector.java

    r96d7c73 r50268de8  
    99import net.i2p.data.Hash;
    1010import net.i2p.router.RouterContext;
     11import net.i2p.router.TunnelInfo;
     12import net.i2p.router.TunnelManagerFacade;
    1113import net.i2p.router.TunnelPoolSettings;
    1214import net.i2p.stat.Rate;
     
    6668                                     ctx.router().getRouterInfo().getAddressCount() <= 0);
    6769        boolean hiddenInbound = hidden && isInbound;
     70        boolean hiddenOutbound = hidden && !isInbound;
    6871        boolean lowOutbound = nonzero && !isInbound && !ctx.commSystem().haveHighOutboundCapacity();
    6972
     
    9497                if (log.shouldLog(Log.INFO))
    9598                    log.info("EPS SANFP closest " + (isInbound ? "IB" : "OB") + " exclude " + closestExclude.size());
    96                 ctx.profileOrganizer().selectActiveNotFailingPeers(1, closestExclude, closest);
     99                // SANFP adds all not-connected to exclude, so make a copy
     100                Set<Hash> SANFPExclude = new HashSet<Hash>(closestExclude);
     101                ctx.profileOrganizer().selectActiveNotFailingPeers(1, SANFPExclude, closest);
    97102                if (closest.isEmpty()) {
    98103                    // ANFP does not fall back to non-connected
     
    116121            }
    117122        }
     123
     124        // furthest-hop restrictions
     125        // Since we're applying orderPeers() later, we don't know
     126        // which will be the furthest hop, so select the furthest one here if necessary.
     127
     128        Hash furthestHop = null;
     129        if (hiddenOutbound && length > 0) {
     130            // OBEP
     131            // check for hidden and outbound, and the paired (inbound) tunnel is zero-hop
     132            // if so, we need the OBEP to be connected to us, so we get the build reply back
     133            // This should be rare except at startup
     134            TunnelManagerFacade tmf = ctx.tunnelManager();
     135            TunnelPool tp = tmf.getInboundExploratoryPool();
     136            TunnelPoolSettings tps = tp.getSettings();
     137            int len = tps.getLength();
     138            boolean pickFurthest = true;
     139            if (len <= 0 ||
     140                tps.getLengthOverride() == 0 ||
     141                len + tps.getLengthVariance() <= 0) {
     142                // leave it true
     143            } else {
     144                for (TunnelInfo ti : tp.listTunnels()) {
     145                    if (ti.getLength() > 1) {
     146                        pickFurthest = false;
     147                        break;
     148                    }
     149                }
     150            }
     151            if (pickFurthest) {
     152                Set<Hash> furthest = new HashSet<Hash>(1);
     153                if (log.shouldLog(Log.INFO))
     154                    log.info("EPS SANFP furthest OB exclude " + exclude.size());
     155                // ANFP adds all not-connected to exclude, so make a copy
     156                Set<Hash> SANFPExclude = new HashSet<Hash>(exclude);
     157                ctx.profileOrganizer().selectActiveNotFailingPeers(1, SANFPExclude, furthest);
     158                if (furthest.isEmpty()) {
     159                    // ANFP does not fall back to non-connected
     160                    if (log.shouldLog(Log.INFO))
     161                        log.info("EPS SFP furthest OB exclude " + exclude.size());
     162                    ctx.profileOrganizer().selectFastPeers(1, exclude, furthest);
     163                }
     164                if (!furthest.isEmpty()) {
     165                    furthestHop = furthest.iterator().next();
     166                    exclude.add(furthestHop);
     167                    length--;
     168                }
     169            }
     170        }
     171
    118172
    119173        // Don't use ff peers for exploratory tunnels to lessen exposure to netDb searches and stores
     
    153207            else
    154208                rv.add(closestHop);
     209            length++;
     210        }
     211        if (furthestHop != null) {
     212            // always OBEP for now, nothing special for IBGW
     213            if (isInbound)
     214                rv.add(furthestHop);
     215            else
     216                rv.add(0, furthestHop);
    155217            length++;
    156218        }
  • router/java/src/net/i2p/router/tunnel/pool/TunnelPoolManager.java

    r96d7c73 r50268de8  
    731731
    732732    /**
     733     *  @return pool or null
     734     *  @since 0.9.34
     735     */
     736    public TunnelPool getInboundPool(Hash client) {
     737        return _clientInboundPools.get(client);
     738    }
     739
     740    /**
     741     *  @return pool or null
     742     *  @since 0.9.34
     743     */
     744    public TunnelPool getOutboundPool(Hash client) {
     745        return _clientOutboundPools.get(client);
     746    }
     747
     748    /**
    733749     *  Fail all outbound tunnels with this peer as first hop,
    734750     *  and all inbound tunnels with this peer as the last hop,
Note: See TracChangeset for help on using the changeset viewer.