Changeset fa8c390


Ignore:
Timestamp:
Jun 8, 2015 4:14:08 PM (6 years ago)
Author:
dg2-new <dg2-new@…>
Branches:
master
Children:
8098d70
Parents:
e8f4e19
Message:

Language fixups.

Files:
39 edited

Legend:

Unmodified
Added
Removed
  • core/java/src/net/i2p/util/ResettableGZIPInputStream.java

    re8f4e19 rfa8c390  
    111111            if (inf.finished()) {
    112112                verifyFooter();
    113                 inf.reset(); // so it doesn't bitch about missing data...
     113                inf.reset(); // so it doesn't complain about missing data...
    114114                _complete = true;
    115115            }
  • history.txt

    re8f4e19 rfa8c390  
     12015-06-08 dg
     2 * Language fixes
     3
    142015-06-06 str4d
    25 * newsxml: Don't use XXX for parsing dates on Android
     
    43484351      to eliminate races with ReadConfigJob
    43494352  * Tunnels:
    4350     - When a peer is shitlisted, fail all our tunnels where
     4353    - When a peer is banlisted, fail all our tunnels where
    43514354      that peer is the adjacent hop. In particular this
    43524355      will remove outbound tunnels when we can't contact
     
    486748702011-09-30 zzz
    48684871  * logs.jsp: Add wrapper version
    4869   * Shitlist: Shorten time
     4872  * Banlist: Shorten time
    48704873  * Wrapper: Update armv7 to 3.5.12
    48714874
     
    49584961
    495949622011-09-08 zzz
    4960   * Blocklist: Include IP in shitlist reason
     4963  * Blocklist: Include IP in banlist reason
    49614964  * Ministreaming: Drop old classes replaced by streaming
    49624965    years ago.
     
    71307133      - Store and report UDP clock skews even for large values, so
    71317134        a badly skewed local clock will be reported to the console
    7132       - Don't shitlist for NTCP clock skew if we don't know what time it is
     7135      - Don't banlist for NTCP clock skew if we don't know what time it is
    71337136      - If NTP hasn't worked yet, have NTCP or SSU update the clock one time
    71347137      - Include failed clock skew in NTCP skew vector if there aren't many connections
     
    74927495    * build: Take two test scripts out of the installer
    74937496    * i2psnark: Bye TPB
    7494     * Shitlist: Fix bug from two checkins ago, all were forever
     7497    * Banlist: Fix bug from two checkins ago, all were forever
    74957498
    749674992009-11-14 zzz
     
    75077510    * Console: Some colon cleansing
    75087511    * FloodfillPeerSelector: Adjustments
    7509     * Shitlist: Move HTML renderer to router console,
     7512    * Banlist: Move HTML renderer to router console,
    75107513      add cause parameter for ease of translation,
    75117514      tag all causes
     
    78557858    * Ministreaming: Cleanups, deprecation, move demos out of the lib
    78567859    * netdb.jsp: Flags for leases
    7857     * NTCP: Clean up clock skew shitlist message
     7860    * NTCP: Clean up clock skew banlist message
    78587861    * profiles.jsp:
    78597862      - Rename the Failing column
     
    78617864    * readme*html: localhost -> 127.0.0.1
    78627865    * Router: Don't do some things when we are shutting down
    7863     * Shitlist: Clean up expire message
     7866    * Banlist: Clean up expire message
    78647867    * Stats:
    78657868      - Fix BufferedStatsLog so it works at all
     
    79277930        2) It randomly dies after a while
    79287931    * Console:
    7929       - Rename the shitlist and the blocklist
     7932      - Rename the banlist and the blocklist
    79307933      - Try to reduce servlet problems on iframe
    79317934      - Select server or client icon for local dests
     
    86628665        Existing installs can get files with 'ant updaterWIthGeoIP'
    86638666        or in the console docs bundle 'ant consoleDocs'
    8664       - Use flags for shitlist and peers.jsp too
     8667      - Use flags for banlist and peers.jsp too
    86658668      - Tweak tunnels.jsp to show class letters
    86668669      - Hide in-progress details on tunnels.jsp
     
    91439146
    914491472009-02-07 zzz
    9145     * ClientConnectionRunner, Shitlist, TunnelDispatcher:
     9148    * ClientConnectionRunner, Banlist, TunnelDispatcher:
    91469149      Update using concurrent
    91479150    * Streaming ConnectionHandler: Bound SYN queue and
     
    92919294        FloodfillPeerSelector sorts more keys, so that
    92929295        exploration works well
    9293     * Shitlist: Reduce max time to 30m (was 60m)
     9296    * Banlist: Reduce max time to 30m (was 60m)
    92949297    * Streaming:
    92959298      - Reduce default initial window size from 12 to 6,
     
    92979300         and try to limit initial packet loss
    92989301      - Reduce fast retransmit threshold from 3 to 2
    9299     * Transport: Don't shitlist a peer if we are at our
     9302    * Transport: Don't banlist a peer if we are at our
    93009303      connection limit
    93019304
     
    942194242008-11-21 zzz
    94229425    * Cache DNS and negative DNS for 5m (was 1m and forever)
    9423     * Delay shitlist cleaner at startup
     9426    * Delay banlist cleaner at startup
    94249427    * Strip wrapper properties from client config
    94259428    * Define multiple cert type
     
    96299632    * help.jsp: Add link to German FAQ
    96309633    * tunnels.jsp: Fix inactive participating count
    9631     * SearchReplyJob: Don't look up references to shitlisted peers
     9634    * SearchReplyJob: Don't look up references to banlisted peers
    96329635    * TunnelPeerSelector: Avoid a peer for 20s after a reject or timeout
    96339636
     
    96929695    * EepGet command line: Fix byte counts after a failed resume
    96939696    * NTCP: Mark unreachable on outbound connection timeout
    9694     * Shitlist: Fix partial shitlisting (still unused though)
     9697    * Banlist: Fix partial banlisting (still unused though)
    96959698    * Summary Bar: Warn if firewalled and floodfill
    96969699    * Throttle: Combine current and last bw measurement,
     
    97369739    * Floodfill Peer Selector:
    97379740      - Avoid peers whose netdb is old, or have a recent failed store,
    9738         or are forever-shitlisted
     9741        or are forever-banlisted
    97399742
    974097432008-07-30 zzz
    97419744    * Blocklists:
    97429745      - New, disabled by default, except for blocking of
    9743         forever-shitlisted peers. See source for instructions
     9746        forever-banlisted peers. See source for instructions
    97449747        and file format.
    97459748    * Transport - Reject peers from inbound connections:
    97469749      - Check IP against blocklist
    9747       - Check router hash against forever-shitlist, then block IP
     9750      - Check router hash against forever-banlist, then block IP
    97489751
    974997522008-07-16 zzz
     
    97779780      - Clean up toString()
    97789781    * SSU:
    9779       - Try to pick better introducers by checking shitlist,
     9782      - Try to pick better introducers by checking banlist,
    97809783        wasUnreachable list, failing list, and idle times
    97819784      - To keep introducer connections up and valid,
     
    986498672008-06-07 zzz
    98659868    * NetDb: Tweak some logging on lease problems
    9866     * Shitlist:
    9867       - Add shitlistForever() and isShitlistedForever(), unused for now
     9869    * Banlist:
     9870      - Add banlistForever() and isBanlistedForever(), unused for now
    98689871      - Sort the HTML output by router hash
    98699872    * netdb.jsp:
     
    99079910    * Logging: Move common WARN output to DEBUG so we can ask users to
    99089911        set the default log level to WARN without massive spewage
    9909     * ProfileOrganizer: Restrict !isSelectable() (i.e. shitlisted) peers from the High Capacity tier,
     9912    * ProfileOrganizer: Restrict !isSelectable() (i.e. banlisted) peers from the High Capacity tier,
    99109913      not just the Fast tier, since we don't use them for tunnels anyway
    99119914    * SAM: Add some compiler flexibility to two obscure makefiles
     
    1007010073    * Reachability:
    1007110074      - Track unreachable peers persistently
    10072         (i.e. separately from shitlist, and not cleared when they contact us)
     10075        (i.e. separately from banlist, and not cleared when they contact us)
    1007310076      - Exclude detected unreachable peers from inbound tunnels
    1007410077      - Exclude detected unreachable peers from selected leases
     
    10078100812008-04-16 zzz
    1007910082    * SSU/Reachability:
    10080       - Extend shitlist time from 4-8m to 40-60m
    10081       - Add some shitlist logging
    10082       - Don't shitlist twice when unreachable on all transports
     10083      - Extend banlist time from 4-8m to 40-60m
     10084      - Add some banlist logging
     10085      - Don't banlist twice when unreachable on all transports
    1008310086      - Exclude netDb-listed unreachable peers from inbound tunnels;
    1008410087        this won't help much since there are very few of these now
     
    1008610089        0.6.1.10 transition
    1008710090      - Track and display UDP connection direction on peers.jsp
    10088       - Show shitlist status in-line on profiles.jsp
     10091      - Show banlist status in-line on profiles.jsp
    1008910092
    10090100932008-04-15 zzz
     
    10184101872008-03-14 zzz
    1018510188    * Floodfill Search:
    10186        - Prefer heard-from, unfailing, unshitlisted floodfill peers
     10189       - Prefer heard-from, unfailing, unbanlisted floodfill peers
    1018710190
    10188101912008-03-14 zzz
     
    1096910972      debugging purposes, publish the count of how many identities the
    1097010973      router has cycled through, though not the identities itself.
    10971     * Cleaned up the way the multitransport shitlisting worked, and
    10972       added per-transport shitlists
     10974    * Cleaned up the way the multitransport banlisting worked, and
     10975      added per-transport banlists
    1097310976    * When dropping a router reference locally, first fire a netDb
    1097410977      lookup for the entry
     
    1100011003
    11001110042006-07-14  jrandom
    11002     * Improve the multitransport shitlisting (thanks Complication!)
     11005    * Improve the multitransport banlisting (thanks Complication!)
    1100311006    * Allow routers with a capacity of 16-32KBps to be used in tunnels under
    1100411007      the default configuration (thanks for the stats Complication!)
     
    1102211025    * Adjust the Fortuna PRNG's pooling system to reduce contention on
    1102311026      refill with a background thread to refill the output buffer
    11024     * Add per-transport support for the shitlist
     11027    * Add per-transport support for the banlist
    1102511028    * Add a new async pumped tunnel gateway to reduce tunnel dispatcher
    1102611029      contention
     
    1109211095
    11093110962006-05-16  jrandom
    11094     * Further shitlist randomizations
     11097    * Further banlist randomizations
    1109511098    * Adjust the stats monitored for detecting cpu overload when dropping new
    1109611099      tunnel requests
     
    1130511308    * Cut down on subsequent streaming lib reset packets transmitted
    1130611309    * Use a larger MTU more often
    11307     * Allow netDb searches to query shitlisted peers, as the queries are
     11310    * Allow netDb searches to query banlisted peers, as the queries are
    1130811311      indirect.
    1130911312    * Add an option to disable non-floodfill netDb searches (non-floodfill
     
    1136711370    * Fix to the SSU IP detection code so we won't use introducers when we
    1136811371      don't need them (thanks Complication!)
    11369     * Add a brief shitlist to i2psnark so it doesn't keep on trying to reach
     11372    * Add a brief banlist to i2psnark so it doesn't keep on trying to reach
    1137011373      peers given to it
    1137111374    * Don't let netDb searches wander across too many peers
     
    1192611929
    11927119302005-12-14  jrandom
    11928     * Fix to drop peer references when we shitlist people again (thanks zzz!)
     11931    * Fix to drop peer references when we banlist people again (thanks zzz!)
    1192911932    * Further I2PSnark fixes to deal with arbitrary torrent info attributes
    1193011933      (thanks Complication!)
     
    1202512028
    12026120292005-11-30  jrandom
    12027     * Don't let the TCP transport alone shitlist a peer, since other
     12030    * Don't let the TCP transport alone banlist a peer, since other
    1202812031      transports may be working.  Also display whether TCP connections are
    1202912032      inbound or outbound on the peers page.
     
    1209312096      protection against trivial attackers, but should provide functional
    1209412097      improvement for people who have periodic IP changes, since their new
    12095       router address would not be shitlisted while their old one would be.
     12098      router address would not be banlisted while their old one would be.
    1209612099    * Added further infrastructure for restricted route operation, but its use
    1209712100      is not recommended.
     
    1224112244      low bandwidth peers.
    1224212245    * Improved failure handling in SSU with proactive reestablishment of
    12243       failing idle peers, and rather than shitlisting a peer who failed too
     12246      failing idle peers, and rather than banlisting a peer who failed too
    1224412247      much, drop the SSU session and allow a new attempt (which, if it fails,
    12245       will cause a shitlisting)
    12246     * Clarify the cause of the shitlist on the profiles page, and include
     12248      will cause a banlisting)
     12249    * Clarify the cause of the banlist on the profiles page, and include
    1224712250      bandwidth limiter info at the bottom of the peers page.
    1224812251
     
    1225712260    * Defer netDb searches for newly referenced peers until we actually want
    1225812261      them
    12259     * Ignore netDb references to peers on our shitlist
     12262    * Ignore netDb references to peers on our banlist
    1226012263    * Set the timeout for end to end client messages to the max delay after
    1226112264      finding the leaseSet, so we don't have as many expired messages floating
     
    1247212475      Thanks Complication (and anon)!
    1247312476    * Fixed the installer version string (thanks Frontier!)
    12474     * Added cleaner rejection of invalid IP addresses, shitlist those who send
     12477    * Added cleaner rejection of invalid IP addresses, banlist those who send
    1247512478      us invalid IP addresses, verify again that we are not sending invalid IP
    1247612479      addresses, and log an error if it happens. (Thanks Complication, ptm,
     
    1250012503    * Limit the number of inbound SSU sessions being built at once (using
    1250112504      half of the i2np.udp.maxConcurrentEstablish config prop)
    12502     * Don't shitlist on a message send failure alone (unless there aren't any
     12505    * Don't banlist on a message send failure alone (unless there aren't any
    1250312506      common transports).
    1250412507    * More careful bandwidth bursting
     
    1263712640    * More careful error handling with introductions (thanks dust!)
    1263812641    * Fix the forceIntroducers checkbox on config.jsp (thanks Complication!)
    12639     * Hide the shitlist on the summary so it doesn't confuse new users.
     12642    * Hide the banlist on the summary so it doesn't confuse new users.
    1264012643
    12641126442005-09-12  comwiz
     
    1274412747    * Catch errors with corrupt tunnel messages more gracefully (no need to
    1274512748      kill the thread and cause an OOM...)
    12746     * Don't skip shitlisted peers for netDb store messages, as they aren't
    12747       necessarily shitlisted by other people (though they probably are).
     12749    * Don't skip banlisted peers for netDb store messages, as they aren't
     12750      necessarily banlisted by other people (though they probably are).
    1274812751    * Adjust the netDb store per-peer timeout based on each particular peer's
    1274912752      profile (timeout = 4x their average netDb store response time)
     
    1278812791    * Don't overwrite the status with 'unknown' unless we haven't had a valid
    1278912792      status in a while.
    12790     * Make sure to avoid shitlisted peers for peer testing.
     12793    * Make sure to avoid banlisted peers for peer testing.
    1279112794    * When we get an unknown result to a peer test, try again soon afterwards.
    1279212795    * When a peer tells us that our address is different from what we expect,
     
    1279512798      result was not OK, accept their suggestion, but queue up a peer test for
    1279612799      later.
    12797     * Don't try to do a netDb store to a shitlisted peer, and adjust the way
     12800    * Don't try to do a netDb store to a banlisted peer, and adjust the way
    1279812801      we monitor netDb store progress (to clear up the high netDb.storePeers
    1279912802      stat)
     
    1342713430      2 means +/- 2, not +/- 1 (thanks dm!)
    1342813431    * Avoid an NPE on client disconnect
    13429     * Never select a shitlisted peer to participate in a tunnel
     13432    * Never select a banlisted peer to participate in a tunnel
    1343013433    * Have netDb store messages timeout after 10s, not the full 60s (duh)
    1343113434    * Keep session tags around for a little longer, just in case (grr)
     
    1427714280
    14278142812004-10-04  jrandom
    14279     * Update the shitlist to reject a peer for an exponentially increasing
     14282    * Update the banlist to reject a peer for an exponentially increasing
    1428014283      period of time (with an upper bounds of an hour).
    1428114284    * Various minor stat and debugging fixes
     
    1429114294
    14292142952004-10-02  jrandom
    14293     * Assure that we quickly fail messages bound for shitlisted peers.
     14296    * Assure that we quickly fail messages bound for banlisted peers.
    1429414297    * Address a race on startup where the first peer contacted could hang the
    1429514298      router (thanks Romster!)
  • router/java/src/net/i2p/data/i2np/DataMessage.java

    re8f4e19 rfa8c390  
    5050        curIndex += 4;
    5151        if (size > MAX_SIZE)
    52             throw new I2NPMessageException("wtf, size=" + size);
     52            throw new I2NPMessageException("too large msg, size=" + size);
    5353        _data = new byte[(int)size];
    5454        System.arraycopy(data, curIndex, _data, 0, (int)size);
  • router/java/src/net/i2p/data/i2np/DeliveryInstructions.java

    re8f4e19 rfa8c390  
    358358        offset += getAdditionalInfo(rv, offset);
    359359        if (offset != additionalSize)
    360             //_log.log(Log.CRIT, "wtf, additionalSize = " + additionalSize + ", offset = " + offset);
    361             throw new IllegalStateException("wtf, additionalSize = " + additionalSize + ", offset = " + offset);
     360            //_log.log(Log.CRIT, "size mismatch, additionalSize = " + additionalSize + ", offset = " + offset);
     361            throw new IllegalStateException("size mismatch, additionalSize = " + additionalSize + ", offset = " + offset);
    362362        return rv;
    363363    }
  • router/java/src/net/i2p/data/i2np/I2NPMessageReader.java

    re8f4e19 rfa8c390  
    165165                        cancelRunner();
    166166                    } catch (Exception e) {
    167                         _log.log(Log.CRIT, "wtf, error reading", e);
     167                        _log.log(Log.CRIT, "error reading msg!", e);
    168168                        _listener.readError(I2NPMessageReader.this, e);
    169169                        _listener.disconnected(I2NPMessageReader.this);
  • router/java/src/net/i2p/data/i2np/TunnelGatewayMessage.java

    re8f4e19 rfa8c390  
    6363            throw new IllegalStateException();
    6464        if (msg == null)
    65             throw new IllegalArgumentException("wtf, dont set me to null");
     65            throw new IllegalArgumentException("dont set me to null!");
    6666        _msg = msg;
    6767    }
     
    138138        //_msg = handler.lastRead();
    139139        //if (_msg == null)
    140         //    throw new I2NPMessageException("wtf, message read has no payload?");
     140        //    throw new I2NPMessageException("impossible? message read has no payload?!");
    141141
    142142        // NEW WAY save lots of effort at the IBGW by reading as an UnknownI2NPMessage instead
  • router/java/src/net/i2p/data/i2np/UnknownI2NPMessage.java

    re8f4e19 rfa8c390  
    4949        if (type != _type) throw new I2NPMessageException("Message type is incorrect for this message");
    5050        if (dataSize > MAX_SIZE)
    51             throw new I2NPMessageException("wtf, size=" + dataSize);
     51            throw new I2NPMessageException("size mismatch, too big, size=" + dataSize);
    5252        _data = new byte[dataSize];
    5353        System.arraycopy(data, offset, _data, 0, dataSize);
  • router/java/src/net/i2p/data/router/RouterInfo.java

    re8f4e19 rfa8c390  
    309309    protected byte[] getBytes() throws DataFormatException {
    310310        if (_byteified != null) return _byteified;
    311         if (_identity == null) throw new DataFormatException("Router identity isn't set? wtf!");
     311        if (_identity == null) throw new DataFormatException("Router identity isn't set?!");
    312312
    313313        //long before = Clock.getInstance().now();
  • router/java/src/net/i2p/router/Banlist.java

    re8f4e19 rfa8c390  
    163163    public boolean banlistRouter(Hash peer, String reason, String reasonCode, String transport, long expireOn) {
    164164        if (peer == null) {
    165             _log.error("wtf, why did we try to banlist null?", new Exception("banfaced"));
     165            _log.error("why did we try to banlist null?", new Exception("banfaced"));
    166166            return false;
    167167        }
    168168        if (peer.equals(_context.routerHash())) {
    169             _log.error("wtf, why did we try to banlist ourselves?", new Exception("banfaced"));
     169            _log.error("why did we try to banlist ourselves?", new Exception("banfaced"));
    170170            return false;
    171171        }
  • router/java/src/net/i2p/router/JobQueue.java

    re8f4e19 rfa8c390  
    592592                _context.clock().removeUpdateListener(this);
    593593                if (_log.shouldLog(Log.ERROR))
    594                     _log.error("wtf, pumper killed", t);
     594                    _log.error("pumper killed?!", t);
    595595            }
    596596        }
  • router/java/src/net/i2p/router/JobQueueRunner.java

    re8f4e19 rfa8c390  
    118118                //    System.gc();
    119119            } catch (Throwable t) {
    120                 _log.log(Log.CRIT, "WTF, error running?", t);
     120                _log.log(Log.CRIT, "error running?", t);
    121121            }
    122122        }
  • router/java/src/net/i2p/router/Router.java

    re8f4e19 rfa8c390  
    853853            SigningPrivateKey key = _context.keyManager().getSigningPrivateKey();
    854854            if (key == null) {
    855                 _log.log(Log.CRIT, "Internal error - signing private key not known?  wtf");
     855                _log.log(Log.CRIT, "Internal error - signing private key not known? Impossible?");
    856856                return;
    857857            }
  • router/java/src/net/i2p/router/dummy/VMCommSystem.java

    re8f4e19 rfa8c390  
    123123                _ctx.inNetMessagePool().add(msg, null, _from);
    124124            } catch (Exception e) {
    125                 _log.error("wtf, error reading/formatting a VM message?", e);
     125                _log.error("Error reading/formatting a VM message? Something is not right...", e);
    126126            }
    127127        }
  • router/java/src/net/i2p/router/message/SendMessageDirectJob.java

    re8f4e19 rfa8c390  
    5959        if (timeoutMs < 10*1000) {
    6060            if (_log.shouldLog(Log.WARN))
    61                 _log.warn("Very little time given [" + timeoutMs + "], resetting to 5s", new Exception("stingy bastard"));
     61                _log.warn("Very little time given [" + timeoutMs + "], resetting to 5s", new Exception("stingy caller!"));
    6262            _expiration = ctx.clock().now() + 10*1000;
    6363        } else {
  • router/java/src/net/i2p/router/networkdb/kademlia/FloodfillNetworkDatabaseFacade.java

    re8f4e19 rfa8c390  
    130130    @Override
    131131    public void publish(RouterInfo localRouterInfo) throws IllegalArgumentException {
    132         if (localRouterInfo == null) throw new IllegalArgumentException("wtf, null localRouterInfo?");
     132        if (localRouterInfo == null) throw new IllegalArgumentException("impossible: null localRouterInfo?");
    133133        // should this be after super? why not publish locally?
    134134        if (_context.router().isHidden()) return; // DE-nied!
  • router/java/src/net/i2p/router/networkdb/kademlia/IterativeLookupJob.java

    re8f4e19 rfa8c390  
    5959                    }
    6060                    if (peer.equals(from)) {
    61                         // wtf
     61                        // unusual
    6262                        invalidPeers++;
    6363                        continue;
  • router/java/src/net/i2p/router/networkdb/kademlia/KademliaNetworkDatabaseFacade.java

    re8f4e19 rfa8c390  
    647647            store(h, localLeaseSet);
    648648        } catch (IllegalArgumentException iae) {
    649             _log.error("wtf, locally published leaseSet is not valid?", iae);
     649            _log.error("locally published leaseSet is not valid?", iae);
    650650            throw iae;
    651651        }
  • router/java/src/net/i2p/router/networkdb/kademlia/PersistentDataStore.java

    re8f4e19 rfa8c390  
    485485                return fileDate > _knownDate + (60*60*1000);
    486486            } else {
    487                 // wtf - prevent injection from reseeding
     487                // safety measure - prevent injection from reseeding
    488488                _log.error("Prevented LS overwrite by RI " + _key + " from " + _routerFile);
    489489                return false;
  • router/java/src/net/i2p/router/networkdb/kademlia/SearchJob.java

    re8f4e19 rfa8c390  
    9595        super(context);
    9696        if ( (key == null) || (key.getData() == null) )
    97             throw new IllegalArgumentException("Search for null key?  wtf");
     97            throw new IllegalArgumentException("Search for null key?");
    9898        _log = getContext().logManager().getLog(getClass());
    9999        _facade = facade;
     
    426426        TunnelInfo inTunnel = getContext().tunnelManager().selectInboundExploratoryTunnel(to);
    427427        if (inTunnel == null) {
    428             _log.warn("No tunnels to get search replies through!  wtf!");
     428            _log.warn("No tunnels to get search replies through!");
    429429            getContext().jobQueue().addJob(new FailedJob(getContext(), router));
    430430            return;
     
    437437        //RouterInfo inGateway = getContext().netDb().lookupRouterInfoLocally(inTunnel.getPeer(0));
    438438        //if (inGateway == null) {
    439         //    _log.error("We can't find the gateway to our inbound tunnel?! wtf");
     439        //    _log.error("We can't find the gateway to our inbound tunnel?!");
    440440        //    getContext().jobQueue().addJob(new FailedJob(getContext(), router));
    441441        //    return;
     
    449449        TunnelInfo outTunnel = getContext().tunnelManager().selectOutboundExploratoryTunnel(to);
    450450        if (outTunnel == null) {
    451             _log.warn("No tunnels to send search out through!  wtf!");
     451            _log.warn("No tunnels to send search out through! Impossible?");
    452452            getContext().jobQueue().addJob(new FailedJob(getContext(), router));
    453453            return;
  • router/java/src/net/i2p/router/networkdb/kademlia/SearchUpdateReplyFoundJob.java

    re8f4e19 rfa8c390  
    102102        } else {
    103103            if (_log.shouldLog(Log.ERROR))
    104                 _log.error(getJobId() + ": WTF, reply job matched a strange message: " + message);
     104                _log.error(getJobId() + ": What?! Reply job matched a strange message: " + message);
    105105            return;
    106106        }
  • router/java/src/net/i2p/router/networkdb/kademlia/SingleLookupJob.java

    re8f4e19 rfa8c390  
    4343            if (peer.equals(getContext().routerHash())) // us
    4444                continue;
    45             if (peer.equals(from)) // wtf
     45            if (peer.equals(from)) // unusual?
    4646                continue;
    4747            RouterInfo ri = getContext().netDb().lookupRouterInfoLocally(peer);
  • router/java/src/net/i2p/router/peermanager/CapacityCalculator.java

    re8f4e19 rfa8c390  
    174174            case 60*60*1000: return .2;
    175175            case 24*60*60*1000: return .1;
    176             default: throw new IllegalArgumentException("wtf, period [" + period + "]???");
     176            default: throw new IllegalArgumentException("undefined period passed, period [" + period + "]???");
    177177        }
    178178    }
  • router/java/src/net/i2p/router/peermanager/PeerTestJob.java

    re8f4e19 rfa8c390  
    116116        TunnelInfo inTunnel = getInboundTunnelId();
    117117        if (inTunnel == null) {
    118             _log.warn("No tunnels to get peer test replies through!  wtf!");
     118            _log.warn("No tunnels to get peer test replies through!");
    119119            return;
    120120        }
     
    124124        if (inGateway == null) {
    125125            if (_log.shouldLog(Log.WARN))
    126                 _log.warn("We can't find the gateway to our inbound tunnel?! wtf");
     126                _log.warn("We can't find the gateway to our inbound tunnel?! Impossible?");
    127127            return;
    128128        }
     
    136136        TunnelInfo outTunnel = getOutboundTunnelId();
    137137        if (outTunnel == null) {
    138             _log.warn("No tunnels to send search out through!  wtf!");
     138            _log.warn("No tunnels to send search out through! Something is wrong...");
    139139            return;
    140140        }
  • router/java/src/net/i2p/router/startup/LoadRouterInfoJob.java

    re8f4e19 rfa8c390  
    8484            // if we have a routerinfo but no keys, things go bad in a hurry:
    8585            // CRIT   ...rkdb.PublishLocalRouterInfoJob: Internal error - signing private key not known?  rescheduling publish for 30s
    86             // CRIT      net.i2p.router.Router         : Internal error - signing private key not known?  wtf
     86            // CRIT      net.i2p.router.Router         : Internal error - signing private key not known? Impossible?
    8787            // CRIT   ...sport.udp.EstablishmentManager: Error in the establisher java.lang.NullPointerException
    8888            // at net.i2p.router.transport.udp.PacketBuilder.buildSessionConfirmedPacket(PacketBuilder.java:574)
  • router/java/src/net/i2p/router/transport/GetBidsJob.java

    re8f4e19 rfa8c390  
    5959        if (to.equals(us)) {
    6060            if (log.shouldLog(Log.ERROR))
    61                 log.error("wtf, send a message to ourselves?  nuh uh. msg = " + msg);
     61                log.error("send a message to ourselves?  nuh uh. msg = " + msg);
    6262            context.statManager().addRateData("transport.bidFailSelf", msg.getLifetime());
    6363            fail(context, msg);
  • router/java/src/net/i2p/router/transport/OutboundMessageRegistry.java

    re8f4e19 rfa8c390  
    196196    private void registerPending(OutNetMessage msg, boolean allowEmpty) {
    197197        if ( (!allowEmpty) && (msg.getMessage() == null) )
    198                 throw new IllegalArgumentException("OutNetMessage doesn't contain an I2NPMessage? wtf");
     198                throw new IllegalArgumentException("OutNetMessage doesn't contain an I2NPMessage? Impossible?");
    199199        MessageSelector sel = msg.getReplySelector();
    200         if (sel == null) throw new IllegalArgumentException("No reply selector?  wtf");
     200        if (sel == null) throw new IllegalArgumentException("No reply selector? Impossible?");
    201201
    202202        if (!_activeMessages.add(msg))
  • router/java/src/net/i2p/router/transport/TransportImpl.java

    re8f4e19 rfa8c390  
    374374                          + msg.getFailedTransports() + " and succeeding on " + getStyle());
    375375            if ( (allTime > 60*1000) && (sendSuccessful) ) {
    376                 // WTF!!@#
     376                // VERY slow
    377377                if (_log.shouldLog(Log.WARN))
    378                     _log.warn("WTF, more than a minute slow? " + msg.getMessageType()
     378                    _log.warn("Severe latency? More than a minute slow? " + msg.getMessageType()
    379379                              + " of id " + msg.getMessageId() + " (send begin on "
    380380                              + new Date(msg.getSendBegin()) + " / created on "
     
    498498        } else {
    499499            if (_log.shouldLog(Log.ERROR))
    500                 _log.error("WTF! Null listener! this = " + toString(), new Exception("Null listener"));
     500                _log.error("Null listener! this = " + toString(), new Exception("Null listener"));
    501501        }
    502502    }
  • router/java/src/net/i2p/router/transport/TransportManager.java

    re8f4e19 rfa8c390  
    531531            throw new IllegalArgumentException("Null message?  no bidding on a null outNetMessage!");
    532532        if (_context.router().getRouterInfo().equals(msg.getTarget()))
    533             throw new IllegalArgumentException("WTF, bids for a message bound to ourselves?");
     533            throw new IllegalArgumentException("Bids for a message bound to ourselves?");
    534534
    535535        List<TransportBid> rv = new ArrayList<TransportBid>(_transports.size());
  • router/java/src/net/i2p/router/transport/ntcp/NTCPSendFinisher.java

    re8f4e19 rfa8c390  
    101101                //_context.statManager().addRateData("ntcp.sendFinishTime", _context.clock().now() - _queued, 0);
    102102            } catch (Throwable t) {
    103                 _log.log(Log.CRIT, " wtf, afterSend borked", t);
     103                _log.log(Log.CRIT, " afterSend broken?", t);
    104104            }
    105105        }
  • router/java/src/net/i2p/router/transport/udp/ACKSender.java

    re8f4e19 rfa8c390  
    169169                if (wanted < 0) {
    170170                    if (_log.shouldLog(Log.WARN))
    171                         _log.warn("wtf, why are we acking something they dont want?  remaining=" + remaining + ", peer=" + peer + ", bitfields=" + ackBitfields);
     171                        _log.warn("why are we acking something they dont want?  remaining=" + remaining + ", peer=" + peer + ", bitfields=" + ackBitfields);
    172172                    continue;
    173173                }
  • router/java/src/net/i2p/router/transport/udp/OutboundMessageFragments.java

    re8f4e19 rfa8c390  
    179179        PeerState peer = state.getPeer();
    180180        if (peer == null)
    181             throw new RuntimeException("wtf, null peer for " + state);
     181            throw new RuntimeException("null peer for " + state);
    182182        peer.add(state);
    183183        add(peer);
  • router/java/src/net/i2p/router/tunnel/BatchedPreprocessor.java

    re8f4e19 rfa8c390  
    371371        if (offset <= 0) {
    372372            StringBuilder buf = new StringBuilder(128);
    373             buf.append("wtf, written offset is ").append(offset);
     373            buf.append("uh? written offset is ").append(offset);
    374374            buf.append(" for ").append(startAt).append(" through ").append(sendThrough);
    375375            for (int i = startAt; i <= sendThrough; i++) {
  • router/java/src/net/i2p/router/tunnel/FragmentHandler.java

    re8f4e19 rfa8c390  
    165165                _log.error("Corrupt fragment received: offset = " + offset, e);
    166166            _context.statManager().addRateData("tunnel.corruptMessage", 1, 1);
    167             // java.lang.IllegalStateException: wtf, don't get the completed size when we're not complete - null fragment i=0 of 1
     167            // java.lang.IllegalStateException: don't get the completed size when we're not complete - null fragment i=0 of 1
    168168            // at net.i2p.router.tunnel.FragmentedMessage.getCompleteSize(FragmentedMessage.java:194)
    169169            // at net.i2p.router.tunnel.FragmentedMessage.toByteArray(FragmentedMessage.java:223)
  • router/java/src/net/i2p/router/tunnel/FragmentedMessage.java

    re8f4e19 rfa8c390  
    165165    public int getCompleteSize() {
    166166        if (!_lastReceived)
    167             throw new IllegalStateException("wtf, don't get the completed size when we're not complete");
     167            throw new IllegalStateException("don't get the completed size when we're not complete!");
    168168        if (_releasedAfter > 0) {
    169169             RuntimeException e = new RuntimeException("use after free in FragmentedMessage");
     
    176176            // NPE seen here, root cause unknown
    177177            if (ba == null)
    178                 throw new IllegalStateException("wtf, don't get the completed size when we're not complete - null fragment i=" + i + " of " + _highFragmentNum);
     178                throw new IllegalStateException("don't get the completed size when we're not complete! - null fragment i=" + i + " of " + _highFragmentNum);
    179179            size += ba.getValid();
    180180        }
  • router/java/src/net/i2p/router/tunnel/InboundGatewayProcessor.java

    re8f4e19 rfa8c390  
    2121        boolean ok = super.process(orig, offset, length, null);
    2222        if (!ok)
    23             throw new RuntimeException("wtf, we are the gateway, how did it fail?");
     23            throw new RuntimeException("we are the gateway, how did it fail?");
    2424    }
    2525}
  • router/java/src/net/i2p/router/tunnel/InboundMessageDistributor.java

    re8f4e19 rfa8c390  
    189189            if (outId == null) {
    190190                if (_log.shouldLog(Log.ERROR))
    191                     _log.error("wtf, outbound tunnel has no outboundId? " + out
     191                    _log.error("strange? outbound tunnel has no outboundId? " + out
    192192                               + " failing to distribute " + msg);
    193193                return;
  • router/java/src/net/i2p/router/tunnel/TunnelDispatcher.java

    re8f4e19 rfa8c390  
    631631     */
    632632    public void dispatchOutbound(I2NPMessage msg, TunnelId outboundTunnel, TunnelId targetTunnel, Hash targetPeer) {
    633         if (outboundTunnel == null) throw new IllegalArgumentException("wtf, null outbound tunnel?");
     633        if (outboundTunnel == null) throw new IllegalArgumentException("null outbound tunnel?");
    634634        long before = _context.clock().now();
    635635        TunnelGateway gw = _outboundGateways.get(outboundTunnel);
     
    678678        //if (dispatchTime > 1000) {
    679679        //    if (_log.shouldLog(Log.WARN))
    680         //        _log.warn("wtf, took " + dispatchTime + " to dispatch " + msg + " out " + outboundTunnel + " in " + gw);
     680        //        _log.warn("slow? took " + dispatchTime + " to dispatch " + msg + " out " + outboundTunnel + " in " + gw);
    681681        //}
    682682        //if (gw instanceof TunnelGatewayZeroHop)
  • router/java/src/net/i2p/router/tunnel/pool/BuildHandler.java

    re8f4e19 rfa8c390  
    353353                            _context.statManager().addRateData("tunnel.receiveRejectionCritical", 1);
    354354                    }
    355                     // penalize peer based on their bitchiness level
     355                    // penalize peer based on their reported error level
    356356                    _context.profileManager().tunnelRejected(peer, rtt, howBad);
    357357                    _context.messageHistory().tunnelParticipantRejected(peer, "peer rejected after " + rtt + " with " + howBad + ": " + cfg.toString());
  • router/java/src/net/i2p/router/tunnel/pool/TunnelPool.java

    re8f4e19 rfa8c390  
    750750            Hash gw = tunnel.getPeer(0);
    751751            if ( (inId == null) || (gw == null) ) {
    752                 _log.error(toString() + ": wtf, tunnel has no inbound gateway/tunnelId? " + tunnel);
     752                _log.error(toString() + ": broken? tunnel has no inbound gateway/tunnelId? " + tunnel);
    753753                continue;
    754754            }
Note: See TracChangeset for help on using the changeset viewer.