@Override public String toString() { String appendix = ""; // crude way to check nothing extra is set in an empty message if (!hasEmptyToken() || getOptions().asSortedList().size()>0 || getPayloadSize()>0) { String payload = getPayloadString(); if (payload == null) { payload = "no payload"; } else { int len = payload.length(); if (payload.indexOf("\n")!=-1) payload = payload.substring(0, payload.indexOf("\n")); if (payload.length() > 24) payload = payload.substring(0,20); payload = "\""+payload+"\""; if (payload.length() != len+2) payload += ".. " + payload.length() + " bytes"; } appendix = " NON-EMPTY: Token="+Arrays.toString(getToken())+", "+getOptions()+", "+payload; } return String.format("%s MID=%5d%s", getType(), getMID(), appendix); }
/** * Create a new acknowledgment for the specified message. * * @param message the message to acknowledge * @return the acknowledgment */ public static EmptyMessage newACK(Message message) { EmptyMessage ack = new EmptyMessage(Type.ACK); ack.setDestination(message.getSource()); ack.setDestinationPort(message.getSourcePort()); ack.setMID(message.getMID()); return ack; }
private void reject(Message message) { EmptyMessage rst = EmptyMessage.newRST(message); // sending directly through connector, not stack, thus set token rst.setToken(new byte[0]); for (MessageInterceptor interceptor:interceptors) interceptor.sendEmptyMessage(rst); // MessageInterceptor might have canceled if (!rst.isCanceled()) connector.send(serializer.serialize(rst)); }
public CoapMessage(EmptyMessage request, boolean incoming) { this(incoming, request.getType(), request.getMID(), request.getTokenString(), request.getOptions(), request .getPayload()); }
if (!parser.isReply()) { EmptyMessage rst = new EmptyMessage(Type.RST); rst.setMID(parser.getMID()); rst.setToken(new byte[0]); rst.setDestination(raw.getAddress()); rst.setDestinationPort(raw.getPort()); for (MessageInterceptor interceptor:interceptors) interceptor.sendEmptyMessage(rst); message.setSource(raw.getAddress()); message.setSourcePort(raw.getPort()); if (!message.isCanceled()) { if (message.getType() == Type.CON || message.getType() == Type.NON) { LOGGER.info("Responding to ping by " + raw.getInetSocketAddress()); reject(message);
/** * Serializes empty messages and caches bytes on the emptyMessage object to skip future serializations. * * @param emptyMessage The message to serialize. * @return The object containing the serialized message. */ public final RawData serializeEmptyMessage(final EmptyMessage emptyMessage) { if (emptyMessage.getBytes() == null) { DatagramWriter writer = new DatagramWriter(); byte[] body = serializeOptionsAndPayload(emptyMessage); MessageHeader header = new MessageHeader(CoAP.VERSION, emptyMessage.getType(), emptyMessage.getToken(), 0, emptyMessage.getMID(), body.length); serializeHeader(writer, header); writer.writeBytes(body); byte[] bytes = writer.toByteArray(); emptyMessage.setBytes(bytes); } return new RawData(emptyMessage.getBytes(), emptyMessage.getDestination(), emptyMessage.getDestinationPort()); }
protected final void appendEmptyMessageDetails(final EmptyMessage message) { if (message.isCanceled()) { buffer.append("CANCELED "); } buffer.append(message.getType()).append(" [MID=").append(message.getMID()).append("]"); }
@Override public void receiveEmptyMessage(EmptyMessage message) { if (message.getType() == Type.RST) { int counter = resetCounter.incrementAndGet(); System.out.println("Received " + counter + ". RST: " + message.getMID()); // this cancel stops the message processing // => notifies will continue message.cancel(); } } }
@Override public void go() { EmptyMessage message = new EmptyMessage(null); if (destination != null) { message.setDestination(destination.getAddress()); message.setDestinationPort(destination.getPort()); } setProperties(message); RawData raw = serializer.serializeEmptyMessage(message); send(raw); } }
public Exchange receiveEmptyMessage(EmptyMessage message) { // local namespace KeyMID idByMID = new KeyMID(message.getMID(), null, 0); Exchange exchange = exchangesByMID.get(idByMID); if (exchange != null) { if (LOGGER.isLoggable(Level.FINE)) LOGGER.fine("Exchange got reply: Cleaning up "+idByMID); exchangesByMID.remove(idByMID, exchange); return exchange; } else { LOGGER.info("Ignoring unmatchable empty message from "+message.getSource()+":"+message.getSourcePort()+": "+message); return null; } }
@Override public void receiveEmptyMessage(Exchange exchange, EmptyMessage message) { // NOTE: We could also move this into the MessageObserverAdapter from // sendResponse into the method rejected(). if (message.getType() == Type.RST && exchange.getOrigin() == Origin.REMOTE) { // The response has been rejected ObserveRelation relation = exchange.getRelation(); if (relation != null) { relation.cancel(); } // else there was no observe relation ship and this layer ignores the rst } super.receiveEmptyMessage(exchange, message); }
private void receiveEmptyMessage(final EmptyMessage message, final RawData raw) { /* * Logging here causes significant performance loss. * If necessary, add an interceptor that logs the messages, * e.g., the MessageTracer. */ for (MessageInterceptor interceptor:interceptors) { interceptor.receiveEmptyMessage(message); } // MessageInterceptor might have canceled if (!message.isCanceled()) { // CoAP Ping if (message.getType() == Type.CON || message.getType() == Type.NON) { LOGGER.log(Level.FINER, "responding to ping from {0}", raw.getInetSocketAddress()); reject(message); } else { Exchange exchange = matcher.receiveEmptyMessage(message); if (exchange != null) { exchange.setEndpoint(CoapEndpoint.this); coapstack.receiveEmptyMessage(exchange, message); } } } } }
/** * Serializes the specified empty message. Message identifier and code are * converted into a byte array and wrapped in a {@link RawData} object. The * message's destination address and port are stored as address and port in * the RawData object. * * @param message * the message * @return the empty message as raw data */ public RawData serialize(EmptyMessage message) { byte[] bytes = message.getBytes(); if (bytes == null) bytes = new DataSerializer().serializeEmptyMessage(message); message.setBytes(bytes); return new RawData(bytes, message.getDestination(), message.getDestinationPort()); } }
@Override public void sendEmptyMessage(Exchange exchange, EmptyMessage message) { if (message.getDestination() == null) throw new NullPointerException("Message has no destination address"); if (message.getDestinationPort() == 0) throw new NullPointerException("Message has no destination port"); matcher.sendEmptyMessage(exchange, message); /* * Logging here causes significant performance loss. * If necessary, add an interceptor that logs the messages, * e.g., the MessageTracer. */ for (MessageInterceptor interceptor:interceptors) interceptor.sendEmptyMessage(message); // MessageInterceptor might have canceled if (message.isCanceled()) { if (null != exchange) { exchange.setComplete(); } } else { connector.send(serializer.serialize(message)); } } }
public EmptyMessage parseEmptyMessage() { assert(!isRequest() && !isResponse()); EmptyMessage message = new EmptyMessage(Type.valueOf(type)); parseMessage(message); return message; }
@Override public void sendEmptyMessage(Exchange exchange, EmptyMessage message) { assertMessageHasDestinationAddress(message); matcher.sendEmptyMessage(exchange, message); /* * Logging here causes significant performance loss. * If necessary, add an interceptor that logs the messages, * e.g., the MessageTracer. */ for (MessageInterceptor interceptor:interceptors) { interceptor.sendEmptyMessage(message); } // MessageInterceptor might have canceled if (message.isCanceled()) { if (null != exchange) { exchange.setComplete(); } } else { connector.send(serializer.serializeEmptyMessage(message)); } }
@Override public void receiveEmptyMessage(final Exchange exchange, final EmptyMessage message) { // NOTE: We could also move this into the MessageObserverAdapter from // sendResponse into the method rejected(). if (message.getType() == Type.RST && exchange.getOrigin() == Origin.REMOTE) { // The response has been rejected ObserveRelation relation = exchange.getRelation(); if (relation != null) { relation.cancel(); } // else there was no observe relation ship and this layer ignores // the rst } upper().receiveEmptyMessage(exchange, message); }