Changeset cf0453c


Ignore:
Timestamp:
Apr 3, 2015 11:01:16 PM (6 years ago)
Author:
dev <dev@…>
Branches:
master
Children:
820b99e
Parents:
b7b5512
Message:

Initialize uniqueId lazily to avoid wasting entropy for messages where it isn't used

File:
1 edited

Legend:

Unmodified
Added
Removed
  • router/java/src/net/i2p/data/i2np/I2NPMessageImpl.java

    rb7b5512 rcf0453c  
    3232    protected final I2PAppContext _context;
    3333    protected long _expiration;
    34     protected long _uniqueId;
    35    
     34    protected long _uniqueId = -1;
     35
    3636    public final static long DEFAULT_EXPIRATION_MS = 1*60*1000; // 1 minute by default
    3737    public final static int CHECKSUM_LENGTH = 1; //Hash.HASH_LENGTH;
    38    
     38
    3939    /** 16 */
    4040    public static final int HEADER_LENGTH = 1 // type
     
    4747    // We are stuck with the short header, can't change it now.
    4848    //private static final boolean RAW_FULL_SIZE = false;
    49    
     49
    5050    /** unused */
    5151    private static final Map<Integer, Builder> _builders = new ConcurrentHashMap<Integer, Builder>(1);
     
    5959        public I2NPMessage build(I2PAppContext ctx);
    6060    }
    61    
     61
    6262    public I2NPMessageImpl(I2PAppContext context) {
    6363        _context = context;
    6464        _log = context.logManager().getLog(I2NPMessageImpl.class);
    6565        _expiration = _context.clock().now() + DEFAULT_EXPIRATION_MS;
    66         // FIXME/TODO set only for outbound, or only on write, or something, to not waste entropy
    67         _uniqueId = _context.random().nextLong(MAX_ID_VALUE);
    6866        //_context.statManager().createRateStat("i2np.writeTime", "How long it takes to write an I2NP message", "I2NP", new long[] { 10*60*1000, 60*60*1000 });
    6967        //_context.statManager().createRateStat("i2np.readTime", "How long it takes to read an I2NP message", "I2NP", new long[] { 10*60*1000, 60*60*1000 });
    7068    }
    71    
     69
    7270    /**
    7371     *  Read the whole message but only if it's exactly 1024 bytes.
     
    125123                buffer = new byte[size];
    126124            }
    127            
     125
    128126            int cur = 0;
    129127            while (cur < size) {
     
    134132                cur += numRead;
    135133            }
    136            
     134
    137135            byte[] calc = SimpleByteCache.acquire(Hash.HASH_LENGTH);
    138136            _context.sha().calculateHash(buffer, 0, size, calc, 0);
     
    234232        return cur - offset;
    235233    }
    236    
     234
    237235    /**
    238236     *  Don't do this if you need a byte array - use toByteArray()
     
    248246        out.write(buf, 0, read);
    249247    }
    250    
     248
    251249    /**
    252250     * Replay resistant message Id
    253251     */
    254     public long getUniqueId() { return _uniqueId; }
     252    public long getUniqueId() {
     253        // Lazy initialization of value
     254        if (_uniqueId < 0) {
     255            _uniqueId = _context.random().nextLong(MAX_ID_VALUE);
     256        }
     257        return _uniqueId;
     258    }
    255259
    256260    /**
     
    258262     */
    259263    public void setUniqueId(long id) { _uniqueId = id; }
    260    
     264
    261265    /**
    262266     * Date after which the message should be dropped (and the associated uniqueId forgotten)
     
    269273     */
    270274    public void setMessageExpiration(long exp) { _expiration = exp; }
    271    
    272     public synchronized int getMessageSize() { 
     275
     276    public synchronized int getMessageSize() {
    273277        return calculateWrittenLength() + (15 + CHECKSUM_LENGTH); // 16 bytes in the header
    274278    }
     
    278282     *  Used by SSU only!
    279283     */
    280     public synchronized int getRawMessageSize() { 
    281         //if (RAW_FULL_SIZE) 
     284    public synchronized int getRawMessageSize() {
     285        //if (RAW_FULL_SIZE)
    282286        //    return getMessageSize();
    283287        //else
    284288            return calculateWrittenLength()+5;
    285289    }
    286    
     290
    287291    @Override
    288292    public byte[] toByteArray() {
     
    296300        return data;
    297301    }
    298    
     302
    299303    public int toByteArray(byte buffer[]) {
    300304        try {
     
    307311            DataHelper.toLong(buffer, off, 1, getType());
    308312            off += 1;
     313
     314            // Lazy initialization of value
     315            if (_uniqueId < 0) {
     316                _uniqueId = _context.random().nextLong(MAX_ID_VALUE);
     317            }
    309318            DataHelper.toLong(buffer, off, 4, _uniqueId);
     319
    310320            off += 4;
    311321            DataHelper.toLong(buffer, off, DataHelper.DATE_LENGTH, _expiration);
     
    316326            SimpleByteCache.release(h);
    317327
    318             return writtenLen;                     
     328            return writtenLen;
    319329        } catch (I2NPMessageException ime) {
    320330            _context.logManager().getLog(getClass()).log(Log.CRIT, "Error writing", ime);
     
    322332        }
    323333    }
    324    
     334
    325335    /** calculate the message body's length (not including the header and footer */
    326336    protected abstract int calculateWrittenLength();
    327337
    328     /** 
     338    /**
    329339     * write the message body to the output array, starting at the given index.
    330340     * @return the index into the array after the last byte written
     
    339349            curIndex += prefix[i].length;
    340350        }
    341        
     351
    342352        curIndex = writeMessageBody(out, curIndex);
    343        
     353
    344354        for (int i = 0; i < suffix.length; i++) {
    345355            System.arraycopy(suffix[i], 0, out, curIndex, suffix[i].length);
    346356            curIndex += suffix[i].length;
    347357        }
    348        
     358
    349359        return curIndex;
    350360    }
    351361     */
    352362
    353    
     363
    354364    /**
    355365     *  Write the message with a short 5-byte header.
     
    384394    }
    385395
    386    
     396
    387397/*****
    388398    public static I2NPMessage fromRawByteArray(I2PAppContext ctx, byte buffer[], int offset, int len) throws I2NPMessageException {
     
    400410        offset++;
    401411        I2NPMessageImpl msg = (I2NPMessageImpl)createMessage(ctx, type);
    402         if (msg == null) 
     412        if (msg == null)
    403413            throw new I2NPMessageException("Unknown message type: " + type);
    404414        //if (RAW_FULL_SIZE) {
Note: See TracChangeset for help on using the changeset viewer.