private static void _testMessage(Message msg) throws Exception {
Buffer buf = Util.messageToByteBuffer(msg);
Message msg2 = Util.byteBufferToMessage(buf.getBuf(), buf.getOffset(), buf.getLength());
Assert.assertEquals(msg.getSrc(), msg2.getSrc());
Assert.assertEquals(msg.getDest(), msg2.getDest());
Assert.assertEquals(msg.getLength(), msg2.getLength());
}
/** When receive a message, analyze message content and then execute the command: Draw or Clear */
public void receive(Message msg) {
byte[] buf = msg.getRawBuffer();
if (buf == null) {
System.err.println(
"["
+ channel.getAddress()
+ "] received null buffer from "
+ msg.getSrc()
+ ", headers: "
+ msg.printHeaders());
return;
}
try {
DrawCommand comm =
(DrawCommand)
Util.streamableFromByteBuffer(
DrawCommand.class, buf, msg.getOffset(), msg.getLength());
switch (comm.mode) {
case DrawCommand.DRAW:
if (drawPanel != null) drawPanel.drawPoint(comm);
break;
case DrawCommand.CLEAR:
clearPanel();
default:
System.err.println("***** received invalid draw command " + comm.mode);
break;
}
} catch (Exception e) {
e.printStackTrace();
}
}
private void encryptAndSend(Message msg) throws Exception {
EncryptHeader hdr = new EncryptHeader(EncryptHeader.ENCRYPT, getSymVersion());
if (this.encrypt_entire_message) hdr.type |= EncryptHeader.ENCRYPT_ENTIRE_MSG;
if (encrypt_entire_message) {
if (msg.getSrc() == null) msg.setSrc(local_addr);
Buffer serialized_msg = Util.streamableToBuffer(msg);
byte[] encrypted_msg =
code(
serialized_msg.getBuf(),
serialized_msg.getOffset(),
serialized_msg.getLength(),
false);
// exclude existing headers, they will be seen again when we decrypt and unmarshal the msg at
// the receiver
Message tmp = msg.copy(false, false).setBuffer(encrypted_msg).putHeader(this.id, hdr);
down_prot.down(new Event(Event.MSG, tmp));
return;
}
// copy neeeded because same message (object) may be retransmitted -> no double encryption
Message msgEncrypted =
msg.copy(false)
.putHeader(this.id, hdr)
.setBuffer(code(msg.getRawBuffer(), msg.getOffset(), msg.getLength(), false));
down_prot.down(new Event(Event.MSG, msgEncrypted));
}
public static void testWriteStreamable() throws Exception {
Message m = new Message(null, null, "Hello");
ViewId vid2 = new ViewId(Util.createRandomAddress(), 35623);
ByteArrayOutputStream outstream = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(outstream);
Util.writeGenericStreamable(m, dos);
Util.writeGenericStreamable(vid2, dos);
dos.close();
byte[] buf = outstream.toByteArray();
ByteArrayInputStream instream = new ByteArrayInputStream(buf);
DataInputStream dis = new DataInputStream(instream);
Message m2 = (Message) Util.readGenericStreamable(dis);
ViewId v3 = (ViewId) Util.readGenericStreamable(dis);
assert m2.getBuffer() != null;
Assert.assertEquals(m.getLength(), m2.getLength());
assert v3 != null;
}
private Message _decrypt(final Cipher cipher, Message msg, boolean decrypt_entire_msg)
throws Exception {
byte[] decrypted_msg;
if (cipher == null)
decrypted_msg = code(msg.getRawBuffer(), msg.getOffset(), msg.getLength(), true);
else decrypted_msg = cipher.doFinal(msg.getRawBuffer(), msg.getOffset(), msg.getLength());
if (!decrypt_entire_msg) {
msg.setBuffer(decrypted_msg);
return msg;
}
Message ret = Util.streamableFromBuffer(Message.class, decrypted_msg, 0, decrypted_msg.length);
if (ret.getDest() == null) ret.setDest(msg.getDest());
if (ret.getSrc() == null) ret.setSrc(msg.getSrc());
return ret;
}
public Message visit(Message msg, MessageBatch batch) {
EncryptHeader hdr;
if (msg == null
|| (msg.getLength() == 0 && !encrypt_entire_message)
|| ((hdr = (EncryptHeader) msg.getHeader(id)) == null)) return null;
if (hdr.getType() == EncryptHeader.ENCRYPT) {
// if queueing then pass into queue to be dealt with later
if (queue_up) {
queueUpMessage(msg, batch);
return null;
}
// make sure we pass up any queued messages first
if (!suppliedKey) drainUpQueue();
if (lock == null) {
int index = getNextIndex();
lock = decoding_locks[index];
cipher = decoding_ciphers[index];
lock.lock();
}
try {
Message tmpMsg = decryptMessage(cipher, msg.copy()); // need to copy for possible xmits
if (tmpMsg != null) batch.replace(msg, tmpMsg);
} catch (Exception e) {
log.error(
"failed decrypting message from %s (offset=%d, length=%d, buf.length=%d): %s, headers are %s",
msg.getSrc(),
msg.getOffset(),
msg.getLength(),
msg.getRawBuffer().length,
e,
msg.printHeaders());
}
} else {
batch.remove(
msg); // a control message will get handled by ENCRYPT and should not be passed up
handleUpEvent(msg, hdr);
}
return null;
}
private Object handleUpMessage(Event evt) throws Exception {
Message msg = (Message) evt.getArg();
EncryptHeader hdr;
if (msg == null
|| (msg.getLength() == 0 && !encrypt_entire_message)
|| ((hdr = (EncryptHeader) msg.getHeader(this.id)) == null)) return up_prot.up(evt);
if (log.isTraceEnabled()) log.trace("header received %s", hdr);
switch (hdr.getType()) {
case EncryptHeader.ENCRYPT:
return handleEncryptedMessage(msg, evt, hdr);
default:
handleUpEvent(msg, hdr);
return null;
}
}
public Object down(Event evt) {
switch (evt.getType()) {
case Event.MSG:
Message msg = (Message) evt.getArg();
if (msg.getLength() == 0 && !encrypt_entire_message) break;
try {
if (queue_down) {
log.trace("queueing down message as no session key established: %s", msg);
downMessageQueue.put(msg); // queue messages if we are waiting for a new key
} else {
// make sure the down queue is drained first to keep ordering
if (!suppliedKey) drainDownQueue();
encryptAndSend(msg);
}
} catch (Exception e) {
log.warn("unable to send message down", e);
}
return null;
case Event.VIEW_CHANGE:
View view = (View) evt.getArg();
log.debug("new view: " + view);
if (!suppliedKey) handleViewChange(view, false);
break;
case Event.SET_LOCAL_ADDRESS:
local_addr = (Address) evt.getArg();
log.debug("set local address to %s", local_addr);
break;
case Event.TMP_VIEW:
view = (View) evt.getArg();
if (!suppliedKey) {
// if a tmp_view then we are trying to become coordinator so
// make us keyserver
handleViewChange(view, true);
}
break;
}
return down_prot.down(evt);
}
/**
* Callback method <br>
* Called by the ProtocolStack when a message is received.
*
* @param evt the event carrying the message from the protocol stack
*/
public Object up(Event evt) {
switch (evt.getType()) {
case Event.MSG:
Message msg = (Message) evt.getArg();
if (stats) {
received_msgs++;
received_bytes += msg.getLength();
}
// discard local messages (sent by myself to me)
if (discard_own_messages
&& local_addr != null
&& msg.getSrc() != null
&& local_addr.equals(msg.getSrc())) return null;
break;
case Event.VIEW_CHANGE:
View tmp = (View) evt.getArg();
if (tmp instanceof MergeView) my_view = new View(tmp.getViewId(), tmp.getMembers());
else my_view = tmp;
// Bela&Vladimir Oct 27th,2006 (JGroups 2.4): we need to set connected=true because a client
// can
// call channel.getView() in viewAccepted() callback invoked on this thread (see
// Event.VIEW_CHANGE handling below)
// not good: we are only connected when we returned from connect() - bela June 22 2007
// Changed: when a channel gets a view of which it is a member then it should be
// connected even if connect() hasn't returned yet ! (bela Noc 2010)
if (state != State.CONNECTED) state = State.CONNECTED;
break;
case Event.CONFIG:
Map<String, Object> cfg = (Map<String, Object>) evt.getArg();
if (cfg != null) {
if (cfg.containsKey("state_transfer")) {
state_transfer_supported = (Boolean) cfg.get("state_transfer");
}
if (cfg.containsKey("flush_supported")) {
flush_supported = (Boolean) cfg.get("flush_supported");
}
}
break;
case Event.GET_STATE_OK:
StateTransferResult result = (StateTransferResult) evt.getArg();
if (up_handler != null) {
try {
Object retval = up_handler.up(evt);
state_promise.setResult(new StateTransferResult());
return retval;
} catch (Throwable t) {
state_promise.setResult(new StateTransferResult(t));
}
}
if (receiver != null) {
try {
if (result.hasBuffer()) {
byte[] tmp_state = result.getBuffer();
ByteArrayInputStream input = new ByteArrayInputStream(tmp_state);
receiver.setState(input);
}
state_promise.setResult(result);
} catch (Throwable t) {
state_promise.setResult(new StateTransferResult(t));
}
}
break;
case Event.STATE_TRANSFER_INPUTSTREAM_CLOSED:
state_promise.setResult((StateTransferResult) evt.getArg());
break;
case Event.STATE_TRANSFER_INPUTSTREAM:
// Oct 13,2006 moved to down() when Event.STATE_TRANSFER_INPUTSTREAM_CLOSED is received
// state_promise.setResult(is != null? Boolean.TRUE : Boolean.FALSE);
if (up_handler != null) return up_handler.up(evt);
InputStream is = (InputStream) evt.getArg();
if (is != null && receiver != null) {
try {
receiver.setState(is);
} catch (Throwable t) {
throw new RuntimeException("failed calling setState() in state requester", t);
}
}
break;
case Event.STATE_TRANSFER_OUTPUTSTREAM:
if (receiver != null && evt.getArg() != null) {
try {
receiver.getState((OutputStream) evt.getArg());
} catch (Exception e) {
throw new RuntimeException("failed calling getState() in state provider", e);
}
}
break;
case Event.GET_LOCAL_ADDRESS:
return local_addr;
default:
break;
}
// If UpHandler is installed, pass all events to it and return (UpHandler is e.g. a building
// block)
if (up_handler != null) return up_handler.up(evt);
if (receiver != null) return invokeCallback(evt.getType(), evt.getArg());
return null;
}