public NavigableMap<Number640, Data> removeReturnData(
Number640 from, Number640 to, PublicKey publicKey) {
RangeLock<Number640>.Range lock = rangeLock.lock(from, to);
try {
Map<Number640, Data> tmp = backend.subMap(from, to);
NavigableMap<Number640, Data> result = new TreeMap<Number640, Data>();
for (Number640 key : tmp.keySet()) {
// fail fast, as soon as we want to remove 1 domain that we
// cannot, abort
if (!canClaimDomain(key.locationAndDomainKey(), publicKey)) {
result.put(key, null);
} else if (!canClaimEntry(key.locationAndDomainAndContentKey(), publicKey)) {
result.put(key, null);
} else {
Data toRemove = backend.get(key);
if (toRemove != null
&& (toRemove.publicKey() == null || toRemove.publicKey().equals(publicKey))) {
backend.removeTimeout(key);
Data removed = backend.remove(key, true);
result.put(key, removed);
}
}
}
return result;
} finally {
lock.unlock();
}
}
public static void inheritPublicKey(Message message, Data data) {
if (message.isSign()
&& message.publicKey(0) != null
&& data.hasPublicKey()
&& (data.publicKey() == null || data.publicKey() == PeerBuilder.EMPTY_PUBLIC_KEY)) {
data.publicKey(message.publicKey(0));
}
}
public Enum<?> putConfirm(PublicKey publicKey, Number640 key, Data newData) {
RangeLock<Number640>.Range lock = lock(key);
try {
if (!securityEntryCheck(
key.locationAndDomainAndContentKey(),
publicKey,
newData.publicKey(),
newData.isProtectedEntry())) {
return PutStatus.FAILED_SECURITY;
}
final Data data = backend.get(key);
if (data != null) {
// remove prepare flag
data.prepareFlag(false);
data.validFromMillis(newData.validFromMillis());
data.ttlSeconds(newData.ttlSeconds());
long expiration = data.expirationMillis();
// handle timeout
backend.addTimeout(key, expiration);
backend.put(key, data);
// don't release data as we just update
return PutStatus.OK;
} else {
return PutStatus.NOT_FOUND;
}
} finally {
newData.release();
lock.unlock();
}
// TODO: check for FORKS!
}
public Enum<?> updateMeta(PublicKey publicKey, Number640 key, Data newData) {
RangeLock<Number640>.Range lock = lock(key);
try {
if (!securityEntryCheck(
key.locationAndDomainAndContentKey(),
publicKey,
newData.publicKey(),
newData.isProtectedEntry())) {
return PutStatus.FAILED_SECURITY;
}
final Data data = backend.get(key);
boolean changed = false;
if (data != null && newData.publicKey() != null) {
data.publicKey(newData.publicKey());
changed = true;
}
if (data != null && newData.isSigned()) {
data.signature(newData.signature());
changed = true;
}
if (data != null) {
data.validFromMillis(newData.validFromMillis());
data.ttlSeconds(newData.ttlSeconds());
changed = true;
}
if (changed) {
long expiration = data.expirationMillis();
// handle timeout
backend.addTimeout(key, expiration);
// no release of old data, as we just update it
backend.put(key, data);
return PutStatus.OK;
} else {
return PutStatus.NOT_FOUND;
}
} finally {
newData.release();
lock.unlock();
}
}
public boolean decodePayload(final ByteBuf buf)
throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException {
LOG.debug(
"About to pass message {} to {}. Buffer to read: {}.",
message,
message.senderSocket(),
buf.readableBytes());
if (!message.hasContent()) {
return true;
}
// payload comes here
int size;
PublicKey receivedPublicKey;
while (contentTypes.size() > 0) {
Content content = contentTypes.peek();
LOG.debug("Parse content: {} in message {}", content, message);
switch (content) {
case INTEGER:
if (buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) {
return false;
}
message.intValue(buf.readInt());
lastContent = contentTypes.poll();
break;
case LONG:
if (buf.readableBytes() < Utils.LONG_BYTE_SIZE) {
return false;
}
message.longValue(buf.readLong());
lastContent = contentTypes.poll();
break;
case KEY:
if (buf.readableBytes() < Number160.BYTE_ARRAY_SIZE) {
return false;
}
byte[] me = new byte[Number160.BYTE_ARRAY_SIZE];
buf.readBytes(me);
message.key(new Number160(me));
lastContent = contentTypes.poll();
break;
case BLOOM_FILTER:
if (buf.readableBytes() < Utils.SHORT_BYTE_SIZE) {
return false;
}
size = buf.getUnsignedShort(buf.readerIndex());
if (buf.readableBytes() < size) {
return false;
}
message.bloomFilter(new SimpleBloomFilter<Number160>(buf));
lastContent = contentTypes.poll();
break;
case SET_NEIGHBORS:
if (neighborSize == -1 && buf.readableBytes() < Utils.BYTE_BYTE_SIZE) {
return false;
}
if (neighborSize == -1) {
neighborSize = buf.readUnsignedByte();
}
if (neighborSet == null) {
neighborSet = new NeighborSet(-1, new ArrayList<PeerAddress>(neighborSize));
}
for (int i = neighborSet.size(); i < neighborSize; i++) {
if (buf.readableBytes() < Utils.SHORT_BYTE_SIZE) {
return false;
}
int header = buf.getUnsignedShort(buf.readerIndex());
size = PeerAddress.size(header);
if (buf.readableBytes() < size) {
return false;
}
PeerAddress pa = new PeerAddress(buf);
neighborSet.add(pa);
}
message.neighborsSet(neighborSet);
lastContent = contentTypes.poll();
neighborSize = -1;
neighborSet = null;
break;
case SET_PEER_SOCKET:
if (peerSocketAddressSize == -1 && buf.readableBytes() < Utils.BYTE_BYTE_SIZE) {
return false;
}
if (peerSocketAddressSize == -1) {
peerSocketAddressSize = buf.readUnsignedByte();
}
if (peerSocketAddresses == null) {
peerSocketAddresses = new ArrayList<PeerSocketAddress>(peerSocketAddressSize);
}
for (int i = peerSocketAddresses.size(); i < peerSocketAddressSize; i++) {
if (buf.readableBytes() < Utils.BYTE_BYTE_SIZE) {
return false;
}
int header = buf.getUnsignedByte(buf.readerIndex());
boolean isIPv4 = header == 0;
size = PeerSocketAddress.size(isIPv4);
if (buf.readableBytes() < size + Utils.BYTE_BYTE_SIZE) {
return false;
}
// skip the ipv4/ipv6 header
buf.skipBytes(1);
peerSocketAddresses.add(PeerSocketAddress.create(buf, isIPv4));
}
message.peerSocketAddresses(peerSocketAddresses);
lastContent = contentTypes.poll();
peerSocketAddressSize = -1;
peerSocketAddresses = null;
break;
case SET_KEY640:
if (keyCollectionSize == -1 && buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) {
return false;
}
if (keyCollectionSize == -1) {
keyCollectionSize = buf.readInt();
}
if (keyCollection == null) {
keyCollection = new KeyCollection(new ArrayList<Number640>(keyCollectionSize));
}
for (int i = keyCollection.size(); i < keyCollectionSize; i++) {
if (buf.readableBytes()
< Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE) {
return false;
}
byte[] me2 = new byte[Number160.BYTE_ARRAY_SIZE];
buf.readBytes(me2);
Number160 locationKey = new Number160(me2);
buf.readBytes(me2);
Number160 domainKey = new Number160(me2);
buf.readBytes(me2);
Number160 contentKey = new Number160(me2);
buf.readBytes(me2);
Number160 versionKey = new Number160(me2);
keyCollection.add(new Number640(locationKey, domainKey, contentKey, versionKey));
}
message.keyCollection(keyCollection);
lastContent = contentTypes.poll();
keyCollectionSize = -1;
keyCollection = null;
break;
case MAP_KEY640_DATA:
if (mapSize == -1 && buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) {
return false;
}
if (mapSize == -1) {
mapSize = buf.readInt();
}
if (dataMap == null) {
dataMap = new DataMap(new TreeMap<Number640, Data>());
}
if (data != null) {
if (!data.decodeBuffer(buf)) {
return false;
}
if (!data.decodeDone(buf, message.publicKey(0), signatureFactory)) {
return false;
}
data = null;
key = null;
}
for (int i = dataMap.size(); i < mapSize; i++) {
if (key == null) {
if (buf.readableBytes()
< Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE) {
return false;
}
byte[] me3 = new byte[Number160.BYTE_ARRAY_SIZE];
buf.readBytes(me3);
Number160 locationKey = new Number160(me3);
buf.readBytes(me3);
Number160 domainKey = new Number160(me3);
buf.readBytes(me3);
Number160 contentKey = new Number160(me3);
buf.readBytes(me3);
Number160 versionKey = new Number160(me3);
key = new Number640(locationKey, domainKey, contentKey, versionKey);
}
LOG.debug("Key decoded in message {}, remaining {}", message, buf.readableBytes());
data = Data.decodeHeader(buf, signatureFactory);
if (data == null) {
return false;
}
LOG.debug("Header decoded in message {}, remaining {}", message, buf.readableBytes());
dataMap.dataMap().put(key, data);
if (!data.decodeBuffer(buf)) {
return false;
}
LOG.debug("Buffer decoded in message {}", message);
if (!data.decodeDone(buf, message.publicKey(0), signatureFactory)) {
return false;
}
LOG.debug("Done decoded in message {}", message);
// if we have signed the message, set the public key anyway, but only if we indicated so
inheritPublicKey(message, data);
data = null;
key = null;
}
message.setDataMap(dataMap);
lastContent = contentTypes.poll();
mapSize = -1;
dataMap = null;
break;
case MAP_KEY640_KEYS:
if (keyMap640KeysSize == -1 && buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) {
return false;
}
if (keyMap640KeysSize == -1) {
keyMap640KeysSize = buf.readInt();
}
if (keyMap640Keys == null) {
keyMap640Keys = new KeyMap640Keys(new TreeMap<Number640, Collection<Number160>>());
}
final int meta =
Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE;
for (int i = keyMap640Keys.size(); i < keyMap640KeysSize; i++) {
if (buf.readableBytes() < meta + Utils.BYTE_BYTE_SIZE) {
return false;
}
size = buf.getUnsignedByte(buf.readerIndex() + meta);
if (buf.readableBytes()
< meta + Utils.BYTE_BYTE_SIZE + (size * Number160.BYTE_ARRAY_SIZE)) {
return false;
}
byte[] me3 = new byte[Number160.BYTE_ARRAY_SIZE];
buf.readBytes(me3);
Number160 locationKey = new Number160(me3);
buf.readBytes(me3);
Number160 domainKey = new Number160(me3);
buf.readBytes(me3);
Number160 contentKey = new Number160(me3);
buf.readBytes(me3);
Number160 versionKey = new Number160(me3);
int numBasedOn = buf.readByte();
Set<Number160> value = new HashSet<Number160>(numBasedOn);
for (int j = 0; j < numBasedOn; j++) {
buf.readBytes(me3);
Number160 basedOnKey = new Number160(me3);
value.add(basedOnKey);
}
keyMap640Keys.put(new Number640(locationKey, domainKey, contentKey, versionKey), value);
}
message.keyMap640Keys(keyMap640Keys);
lastContent = contentTypes.poll();
keyMap640KeysSize = -1;
keyMap640Keys = null;
break;
case MAP_KEY640_BYTE:
if (keyMapByteSize == -1 && buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) {
return false;
}
if (keyMapByteSize == -1) {
keyMapByteSize = buf.readInt();
}
if (keyMapByte == null) {
keyMapByte = new KeyMapByte(new HashMap<Number640, Byte>(2 * keyMapByteSize));
}
for (int i = keyMapByte.size(); i < keyMapByteSize; i++) {
if (buf.readableBytes()
< Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE
+ Number160.BYTE_ARRAY_SIZE
+ 1) {
return false;
}
byte[] me3 = new byte[Number160.BYTE_ARRAY_SIZE];
buf.readBytes(me3);
Number160 locationKey = new Number160(me3);
buf.readBytes(me3);
Number160 domainKey = new Number160(me3);
buf.readBytes(me3);
Number160 contentKey = new Number160(me3);
buf.readBytes(me3);
Number160 versionKey = new Number160(me3);
byte value = buf.readByte();
keyMapByte.put(new Number640(locationKey, domainKey, contentKey, versionKey), value);
}
message.keyMapByte(keyMapByte);
lastContent = contentTypes.poll();
keyMapByteSize = -1;
keyMapByte = null;
break;
case BYTE_BUFFER:
if (bufferSize == -1 && buf.readableBytes() < Utils.INTEGER_BYTE_SIZE) {
return false;
}
if (bufferSize == -1) {
bufferSize = buf.readInt();
}
if (buffer == null) {
buffer = new DataBuffer();
}
final int remaining = bufferSize - bufferTransferred;
bufferTransferred += buffer.transferFrom(buf, remaining);
if (bufferTransferred < bufferSize) {
LOG.debug(
"Still looking for data. Indicating that its not finished yet. Already Transferred = {}, Size = {}.",
bufferTransferred,
bufferSize);
return false;
}
message.buffer(new Buffer(buffer.toByteBuf(), bufferSize));
lastContent = contentTypes.poll();
bufferSize = -1;
bufferTransferred = 0;
buffer = null;
break;
case SET_TRACKER_DATA:
if (trackerDataSize == -1 && buf.readableBytes() < Utils.BYTE_BYTE_SIZE) {
return false;
}
if (trackerDataSize == -1) {
trackerDataSize = buf.readUnsignedByte();
}
if (trackerData == null) {
trackerData = new TrackerData(new HashMap<PeerAddress, Data>(2 * trackerDataSize));
}
if (currentTrackerData != null) {
if (!currentTrackerData.decodeBuffer(buf)) {
return false;
}
if (!currentTrackerData.decodeDone(buf, message.publicKey(0), signatureFactory)) {
return false;
}
currentTrackerData = null;
}
for (int i = trackerData.size(); i < trackerDataSize; i++) {
if (buf.readableBytes() < Utils.SHORT_BYTE_SIZE) {
return false;
}
int header = buf.getUnsignedShort(buf.readerIndex());
size = PeerAddress.size(header);
if (buf.readableBytes() < size) {
return false;
}
PeerAddress pa = new PeerAddress(buf);
currentTrackerData = Data.decodeHeader(buf, signatureFactory);
if (currentTrackerData == null) {
return false;
}
trackerData.peerAddresses().put(pa, currentTrackerData);
if (message.isSign()) {
currentTrackerData.publicKey(message.publicKey(0));
}
if (!currentTrackerData.decodeBuffer(buf)) {
return false;
}
if (!currentTrackerData.decodeDone(buf, message.publicKey(0), signatureFactory)) {
return false;
}
currentTrackerData = null;
}
message.trackerData(trackerData);
lastContent = contentTypes.poll();
trackerDataSize = -1;
trackerData = null;
break;
case PUBLIC_KEY: // fall-through
case PUBLIC_KEY_SIGNATURE:
receivedPublicKey = signatureFactory.decodePublicKey(buf);
if (content == Content.PUBLIC_KEY_SIGNATURE) {
if (receivedPublicKey == PeerBuilder.EMPTY_PUBLIC_KEY) {
throw new InvalidKeyException("The public key cannot be empty.");
}
}
if (receivedPublicKey == null) {
return false;
}
message.publicKey(receivedPublicKey);
lastContent = contentTypes.poll();
break;
default:
break;
}
}
LOG.debug("Parsed content in message {}", message);
if (message.isSign()) {
size = signatureFactory.signatureSize();
if (buf.readableBytes() < size) {
return false;
}
SignatureCodec signatureEncode = signatureFactory.signatureCodec(buf);
message.receivedSignature(signatureEncode);
}
return true;
}
public Map<Number640, Enum<?>> putAll(
final NavigableMap<Number640, Data> dataMap,
PublicKey publicKey,
boolean putIfAbsent,
boolean domainProtection,
boolean sendSelf) {
if (dataMap.isEmpty()) {
return Collections.emptyMap();
}
final Number640 min = dataMap.firstKey();
final Number640 max = dataMap.lastKey();
final Map<Number640, Enum<?>> retVal = new HashMap<Number640, Enum<?>>();
final HashSet<Number480> keysToCheck = new HashSet<Number480>();
final RangeLock<Number640>.Range lock = lock(min, max);
try {
for (Map.Entry<Number640, Data> entry : dataMap.entrySet()) {
Number640 key = entry.getKey();
keysToCheck.add(key.locationAndDomainAndContentKey());
Data newData = entry.getValue();
if (!securityDomainCheck(
key.locationAndDomainKey(), publicKey, publicKey, domainProtection)) {
retVal.put(key, PutStatus.FAILED_SECURITY);
newData.release();
continue;
}
// We need this check in case we did not use the encoder/decoder,
// which is the case if we send the message to ourself. In that
// case, the public key of the data is never set to the message
// publick key, if the publick key of the data was null.
final PublicKey dataKey;
if (sendSelf && newData.publicKey() == null) {
dataKey = publicKey;
} else {
dataKey = newData.publicKey();
}
if (!securityEntryCheck(
key.locationAndDomainAndContentKey(), publicKey, dataKey, newData.isProtectedEntry())) {
retVal.put(key, PutStatus.FAILED_SECURITY);
newData.release();
continue;
}
final Data oldDataGet = backend.get(key);
if (oldDataGet != null) {
if (putIfAbsent) {
retVal.put(key, PutStatus.FAILED_NOT_ABSENT);
newData.release();
continue;
}
if (oldDataGet.isDeleted()) {
retVal.put(key, PutStatus.DELETED);
newData.release();
continue;
}
if (!oldDataGet.basedOnSet().equals(newData.basedOnSet())) {
retVal.put(key, PutStatus.VERSION_FORK);
newData.release();
continue;
}
}
final Data oldDataPut = backend.put(key, newData);
long expiration = newData.expirationMillis();
// handle timeout
backend.addTimeout(key, expiration);
if (newData.hasPrepareFlag()) {
retVal.put(key, PutStatus.OK_PREPARED);
} else {
retVal.put(key, PutStatus.OK);
}
if (oldDataPut != null && oldDataPut != newData) {
oldDataPut.release();
}
}
for (Number480 key : keysToCheck) {
// now check for forks
Number640 minVersion = new Number640(key, Number160.ZERO);
Number640 maxVersion = new Number640(key, Number160.MAX_VALUE);
NavigableMap<Number640, Data> tmp = backend.subMap(minVersion, maxVersion);
tmp = filterCopyOrig(tmp, -1, true);
NavigableMap<Number640, Data> heads = getLatestInternalOrig(tmp);
final boolean forked = heads.size() > 1;
for (final Map.Entry<Number640, Data> entry : heads.entrySet()) {
if (forked) {
if (retVal.containsKey(entry.getKey())) {
retVal.put(entry.getKey(), PutStatus.VERSION_FORK);
}
}
}
// now remove old versions
if (maxVersions > 0) {
NavigableMap<Number640, Data> versions = backend.subMap(minVersion, maxVersion);
while (!versions.isEmpty()
&& versions.firstKey().versionKey().timestamp() + maxVersions
<= versions.lastKey().versionKey().timestamp()) {
Map.Entry<Number640, Data> entry = versions.pollFirstEntry();
Data removed = backend.remove(entry.getKey(), true);
if (removed != null) {
removed.release();
}
backend.removeTimeout(entry.getKey());
}
}
}
return retVal;
} finally {
lock.unlock();
}
}
