Changeset 51d4827


Ignore:
Timestamp:
Aug 22, 2017 12:34:38 PM (4 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
2071cf8
Parents:
3d38522
Message:

i2psnark: finals for Message class
recognize BiglyBT
cleanups

Location:
apps/i2psnark/java/src/org/klomp/snark
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • apps/i2psnark/java/src/org/klomp/snark/Message.java

    r3d38522 r51d4827  
    5353  // Not all fields are used for every message.
    5454  // KEEP_ALIVE doesn't have a real wire representation
    55   byte type;
     55  final byte type;
    5656
    5757  // Used for HAVE, REQUEST, PIECE and CANCEL messages.
     
    5959  // low byte used for EXTENSION message
    6060  // low two bytes used for PORT message
    61   int piece;
     61  final int piece;
    6262
    6363  // Used for REQUEST, PIECE and CANCEL messages.
    6464  // Also REJECT
    65   int begin;
    66   int length;
     65  final int begin;
     66  final int length;
    6767
    6868  // Used for PIECE and BITFIELD and EXTENSION messages
    6969  byte[] data;
    70   int off;
    71   int len;
     70  final int off;
     71  final int len;
    7272
    7373  // Used to do deferred fetch of data
    74   DataLoader dataLoader;
     74  private final DataLoader dataLoader;
    7575
    7676  // now unused
     
    7979  private static final int BUFSIZE = PeerState.PARTSIZE;
    8080  private static final ByteCache _cache = ByteCache.getInstance(16, BUFSIZE);
     81
     82  /**
     83   * For types KEEP_ALIVE, CHOKE, UNCHOKE, INTERESTED, UNINTERESTED, HAVE_ALL, HAVE_NONE
     84   * @since 0.9.32
     85   */
     86  Message(byte type) {
     87      this(type, 0, 0, 0, null, 0, 0, null);
     88  }
     89
     90  /**
     91   * For types HAVE, PORT, SUGGEST, ALLOWED_FAST
     92   * @since 0.9.32
     93   */
     94  Message(byte type, int piece) {
     95      this(type, piece, 0, 0, null, 0, 0, null);
     96  }
     97
     98  /**
     99   * For types REQUEST, REJECT, CANCEL
     100   * @since 0.9.32
     101   */
     102  Message(byte type, int piece, int begin, int length) {
     103      this(type, piece, begin, length, null, 0, 0, null);
     104  }
     105
     106  /**
     107   * For type BITFIELD
     108   * @since 0.9.32
     109   */
     110  Message(byte[] data) {
     111      this(BITFIELD, 0, 0, 0, data, 0, data.length, null);
     112  }
     113
     114  /**
     115   * For type EXTENSION
     116   * @since 0.9.32
     117   */
     118  Message(int id, byte[] data) {
     119      this(EXTENSION, id, 0, 0, data, 0, data.length, null);
     120  }
     121
     122  /**
     123   * For type PIECE with deferred data
     124   * @since 0.9.32
     125   */
     126  Message(int piece, int begin, int length, DataLoader loader) {
     127      this(PIECE, piece, begin, length, null, 0, length, loader);
     128  }
     129
     130  /**
     131   * For type PIECE with data
     132   * We don't use this anymore.
     133   * @since 0.9.32
     134   */
     135/****
     136  Message(int piece, int begin, int length, byte[] data) {
     137      this(PIECE, piece, begin, length, data, 0, length, null);
     138  }
     139****/
     140
     141  /**
     142   * @since 0.9.32
     143   */
     144  private Message(byte type, int piece, int begin, int length, byte[] data, int off, int len, DataLoader loader) {
     145      this.type = type;
     146      this.piece = piece;
     147      this.begin = begin;
     148      this.length = length;
     149      this.data = data;
     150      this.off = off;
     151      this.len = len;
     152      dataLoader = loader;
     153  }
    81154
    82155  /** Utility method for sending a message through a DataStream. */
     
    122195
    123196    // msg type is 1 byte
    124     if (type == EXTENSION)
     197    else if (type == EXTENSION)
    125198      datalen += 1;
    126199
    127     if (type == PORT)
     200    else if (type == PORT)
    128201      datalen += 2;
    129202
     
    151224        dos.writeInt(length);
    152225
    153     if (type == EXTENSION)
     226    else if (type == EXTENSION)
    154227        dos.writeByte((byte) piece & 0xff);
    155228
    156     if (type == PORT)
     229    else if (type == PORT)
    157230        dos.writeShort(piece & 0xffff);
    158231
  • apps/i2psnark/java/src/org/klomp/snark/PeerConnectionIn.java

    r3d38522 r51d4827  
    5050    this.din = din;
    5151    lastRcvd = System.currentTimeMillis();
    52     quit = false;
    5352  }
    5453
    5554  void disconnect()
    5655  {
    57     if (quit == true)
     56    if (quit)
    5857      return;
    5958
  • apps/i2psnark/java/src/org/klomp/snark/PeerConnectionOut.java

    r3d38522 r51d4827  
    127127                              //SimpleTimer.getInstance().removeEvent(nm.expireEvent);
    128128                              if (peer.supportsFast()) {
    129                                   Message r = new Message();
    130                                   r.type = Message.REJECT;
    131                                   r.piece = nm.piece;
    132                                   r.begin = nm.begin;
    133                                   r.length = nm.length;
     129                                  Message r = new Message(Message.REJECT, nm.piece, nm.begin, nm.length);
    134130                                  if (_log.shouldLog(Log.DEBUG))
    135131                                      _log.debug("Send " + peer + ": " + r);
     
    295291                removed = true;
    296292                if (type == Message.PIECE && peer.supportsFast()) {
    297                     Message r = new Message();
    298                     r.type = Message.REJECT;
    299                     r.piece = m.piece;
    300                     r.begin = m.begin;
    301                     r.length = m.length;
     293                    Message r = new Message(Message.REJECT, m.piece, m.begin, m.length);
    302294                    if (_log.shouldLog(Log.DEBUG))
    303295                        _log.debug("Send " + peer + ": " + r);
     
    315307  void sendAlive()
    316308  {
    317     Message m = new Message();
    318     m.type = Message.KEEP_ALIVE;
    319 //  addMessage(m);
    320     synchronized(sendQueue)
    321       {
    322         if(sendQueue.isEmpty())
     309    synchronized(sendQueue)
     310      {
     311        if(sendQueue.isEmpty()) {
     312          Message m = new Message(Message.KEEP_ALIVE);
    323313          sendQueue.offer(m);
     314        }
    324315        sendQueue.notifyAll();
    325316      }
     
    336327        if (!removeMessage(inverseType))
    337328          {
    338             Message m = new Message();
    339             if (choke)
    340               m.type = Message.CHOKE;
    341             else
    342               m.type = Message.UNCHOKE;
     329            Message m = new Message(choke ? Message.CHOKE : Message.UNCHOKE);
    343330            addMessage(m);
    344331          }
     
    354341        if (!removeMessage(inverseType))
    355342          {
    356             Message m = new Message();
    357             if (interest)
    358               m.type = Message.INTERESTED;
    359             else
    360               m.type = Message.UNINTERESTED;
     343            Message m = new Message(interest ? Message.INTERESTED : Message.UNINTERESTED);
    361344            addMessage(m);
    362345          }
     
    366349  void sendHave(int piece)
    367350  {
    368     Message m = new Message();
    369     m.type = Message.HAVE;
    370     m.piece = piece;
     351    Message m = new Message(Message.HAVE, piece);
    371352    addMessage(m);
    372353  }
     
    380361        sendHaveNone();
    381362    } else {
    382        Message m = new Message();
    383        m.type = Message.BITFIELD;
    384        m.data = bitfield.getFieldBytes();
    385        m.off = 0;
    386        m.len = m.data.length;
     363       Message m = new Message(bitfield.getFieldBytes());
    387364       addMessage(m);
    388365    }
     
    435412          }
    436413      }
    437     Message m = new Message();
    438     m.type = Message.REQUEST;
    439     m.piece = req.getPiece();
    440     m.begin = req.off;
    441     m.length = req.len;
     414    Message m = new Message(Message.REQUEST, req.getPiece(), req.off, req.len);
    442415    addMessage(m);
    443416    req.sendTime = System.currentTimeMillis();
     
    483456      // queue a fake message... set everything up,
    484457      // except save the PeerState instead of the bytes.
    485       Message m = new Message();
    486       m.type = Message.PIECE;
    487       m.piece = piece;
    488       m.begin = begin;
    489       m.length = length;
    490       m.dataLoader = loader;
    491       m.off = 0;
    492       m.len = length;
     458      Message m = new Message(piece, begin, length, loader);
    493459      addMessage(m);
    494460  }
     
    499465   *  We don't use this anymore.
    500466   */
     467/****
    501468  void sendPiece(int piece, int begin, int length, byte[] bytes)
    502469  {
    503     Message m = new Message();
    504     m.type = Message.PIECE;
    505     m.piece = piece;
    506     m.begin = begin;
    507     m.length = length;
    508     m.data = bytes;
    509     m.off = 0;
    510     m.len = length;
     470    Message m = new Message(piece, begin, length, bytes);
    511471    // since we have the data already loaded, queue a timeout to remove it
    512472    // no longer prefetched
    513473    addMessage(m);
    514474  }
    515 
     475****/
     476
     477  /** send cancel */
    516478  void sendCancel(Request req)
    517479  {
     
    532494
    533495    // Always send, just to be sure it it is really canceled.
    534     Message m = new Message();
    535     m.type = Message.CANCEL;
    536     m.piece = req.getPiece();
    537     m.begin = req.off;
    538     m.length = req.len;
     496    Message m = new Message(Message.CANCEL, req.getPiece(), req.off, req.len);
    539497    addMessage(m);
    540498  }
     
    579537  /** @since 0.8.2 */
    580538  void sendExtension(int id, byte[] bytes) {
    581     Message m = new Message();
    582     m.type = Message.EXTENSION;
    583     m.piece = id;
    584     m.data = bytes;
    585     m.off = 0;
    586     m.len = bytes.length;
     539    Message m = new Message(id, bytes);
    587540    addMessage(m);
    588541  }
     
    590543  /** @since 0.8.4 */
    591544  void sendPort(int port) {
    592     Message m = new Message();
    593     m.type = Message.PORT;
    594     m.piece = port;
     545    Message m = new Message(Message.PORT, port);
    595546    addMessage(m);
    596547  }
     
    600551   *  @since 0.9.21
    601552   */
     553/****
    602554  void sendSuggest(int piece) {
    603     Message m = new Message();
    604     m.type = Message.SUGGEST;
    605     m.piece = piece;
    606     addMessage(m);
    607   }
     555    Message m = new Message(Message.SUGGEST, piece);
     556    addMessage(m);
     557  }
     558****/
    608559
    609560  /** @since 0.9.21 */
    610561  private void sendHaveAll() {
    611     Message m = new Message();
    612     m.type = Message.HAVE_ALL;
     562    Message m = new Message(Message.HAVE_ALL);
    613563    addMessage(m);
    614564  }
     
    616566  /** @since 0.9.21 */
    617567  private void sendHaveNone() {
    618     Message m = new Message();
    619     m.type = Message.HAVE_NONE;
     568    Message m = new Message(Message.HAVE_NONE);
    620569    addMessage(m);
    621570  }
     
    623572  /** @since 0.9.21 */
    624573  void sendReject(int piece, int begin, int length) {
    625     Message m = new Message();
    626     m.type = Message.REJECT;
    627     m.piece = piece;
    628     m.begin = begin;
    629     m.length = length;
     574    Message m = new Message(Message.REJECT, piece, begin, length);
    630575    addMessage(m);
    631576  }
     
    635580   *  @since 0.9.21
    636581   */
     582/****
    637583  void sendAllowedFast(int piece) {
    638     Message m = new Message();
    639     m.type = Message.ALLOWED_FAST;
    640     m.piece = piece;
    641     addMessage(m);
    642   }
     584    Message m = new Message(Message.ALLOWED_FAST, piece);
     585    addMessage(m);
     586  }
     587****/
    643588}
  • apps/i2psnark/java/src/org/klomp/snark/dht/KRPC.java

    r3d38522 r51d4827  
    14251425        for (BEValue bev : peers) {
    14261426            byte[] b = bev.getBytes();
     1427            if (b.length != Hash.HASH_LENGTH) {
     1428                if (_log.shouldWarn())
     1429                    _log.info("Bad peers entry from: " + nInfo);
     1430                continue;
     1431            }
    14271432            //Hash h = new Hash(b);
    14281433            Hash h = Hash.create(b);
  • apps/i2psnark/java/src/org/klomp/snark/web/I2PSnarkServlet.java

    r3d38522 r51d4827  
    18651865                if ("AwMD".equals(ch))
    18661866                    client = _t("I2PSnark");
    1867                 else if ("BFJT".equals(ch))
    1868                     client = "I2PRufus";
    1869                 else if ("TTMt".equals(ch))
    1870                     client = "I2P-BT";
    18711867                else if ("LUFa".equals(ch))
    18721868                    client = "Vuze" + getAzVersion(pid.getID());
    1873                 else if ("CwsL".equals(ch))
    1874                     client = "I2PSnarkXL";
     1869                else if ("LUJJ".equals(ch))
     1870                    client = "BiglyBT" + getAzVersion(pid.getID());
    18751871                else if ("LVhE".equals(ch))
    18761872                    client = "XD" + getAzVersion(pid.getID());
     
    18811877                else if ("LUtU".equals(ch))
    18821878                    client = "KTorrent" + getAzVersion(pid.getID());
     1879                else if ("CwsL".equals(ch))
     1880                    client = "I2PSnarkXL";
     1881                else if ("BFJT".equals(ch))
     1882                    client = "I2PRufus";
     1883                else if ("TTMt".equals(ch))
     1884                    client = "I2P-BT";
    18831885                else
    18841886                    client = _t("Unknown") + " (" + ch + ')';
     
    19821984        if (id[7] != '-')
    19831985            return "";
    1984         StringBuilder buf = new StringBuilder(16);
     1986        StringBuilder buf = new StringBuilder(8);
    19851987        buf.append(' ');
    19861988        for (int i = 3; i <= 6; i++) {
Note: See TracChangeset for help on using the changeset viewer.