Refine search
private static ByteBuf encodePublishMessage( ByteBufAllocator byteBufAllocator, MqttPublishMessage message) { MqttFixedHeader mqttFixedHeader = message.fixedHeader(); MqttPublishVariableHeader variableHeader = message.variableHeader(); ByteBuf payload = message.payload().duplicate(); String topicName = variableHeader.topicName(); byte[] topicNameBytes = encodeStringUtf8(topicName); int variableHeaderBufferSize = 2 + topicNameBytes.length + (mqttFixedHeader.qosLevel().value() > 0 ? 2 : 0); int payloadBufferSize = payload.readableBytes(); int variablePartSize = variableHeaderBufferSize + payloadBufferSize; int fixedHeaderBufferSize = 1 + getVariableLengthInt(variablePartSize); ByteBuf buf = byteBufAllocator.buffer(fixedHeaderBufferSize + variablePartSize); buf.writeByte(getFixedHeaderByte1(mqttFixedHeader)); writeVariableLengthInt(buf, variablePartSize); buf.writeShort(topicNameBytes.length); buf.writeBytes(topicNameBytes); if (mqttFixedHeader.qosLevel().value() > 0) { buf.writeShort(variableHeader.messageId()); } buf.writeBytes(payload); return buf; }
byte [] bytes = new byte[publishMessage.payload().readableBytes()]; publishMessage.payload().getBytes(0, bytes); buf.writeBytes(bytes); MqttPublishMessage msg = new MqttPublishMessage( new MqttFixedHeader( MqttMessageType.PUBLISH, publishMessage.fixedHeader().isDup(), MqttQoS.valueOf(MessageUtil.actualQos(publishMessage.fixedHeader().qosLevel().value())), publishMessage.fixedHeader().isRetain(), publishMessage.fixedHeader().remainingLength()
public static MqttQoS valueOf(int value) { for (MqttQoS q: values()) { if (q.value == value) { return q; } } throw new IllegalArgumentException("invalid QoS: " + value); } }
buf.writeByte(getFixedHeaderByte1(mqttFixedHeader)); writeVariableLengthInt(buf, variablePartSize); buf.writeShort(messageId); String topicName = topic.topicName(); byte[] topicNameBytes = encodeStringUtf8(topicName); buf.writeShort(topicNameBytes.length); buf.writeBytes(topicNameBytes, 0, topicNameBytes.length); buf.writeByte(topic.qualityOfService().value());
private static ByteBuf encodePublishMessage( ByteBufAllocator byteBufAllocator, MqttPublishMessage message) { MqttFixedHeader mqttFixedHeader = message.fixedHeader(); MqttPublishVariableHeader variableHeader = message.variableHeader(); ByteBuf payload = message.payload().duplicate(); String topicName = variableHeader.topicName(); byte[] topicNameBytes = encodeStringUtf8(topicName); int variableHeaderBufferSize = 2 + topicNameBytes.length + (mqttFixedHeader.qos().value() > 0 ? 2 : 0); int payloadBufferSize = payload.readableBytes(); int variablePartSize = variableHeaderBufferSize + payloadBufferSize; int fixedHeaderBufferSize = 1 + getVariableLengthInt(variablePartSize); ByteBuf buf = byteBufAllocator.buffer(fixedHeaderBufferSize + variablePartSize); buf.writeByte(getFixedHeaderByte1(mqttFixedHeader)); writeVariableLengthInt(buf, variablePartSize); buf.writeShort(topicNameBytes.length); buf.writeBytes(topicNameBytes); if (mqttFixedHeader.qos().value() > 0) { buf.writeShort(variableHeader.packetId()); } buf.writeBytes(payload); return buf; }
public void processPublish(Channel channel, MqttPublishMessage msg) { String clientId = (String) channel.attr(AttributeKey.valueOf("clientId")).get(); if (msg.fixedHeader().qosLevel() == MqttQoS.AT_MOST_ONCE) { byte[] messageBytes = new byte[msg.payload().readableBytes()]; msg.payload().getBytes(msg.payload().readerIndex(), messageBytes); InternalMessage internalMessage = new InternalMessage().setTopic(msg.variableHeader().topicName()) .setMqttQoS(msg.fixedHeader().qosLevel().value()).setMessageBytes(messageBytes) .setDup(false).setRetain(false).setClientId(clientId); internalCommunication.internalSend(internalMessage); this.sendPublishMessage(msg.variableHeader().topicName(), msg.fixedHeader().qosLevel(), messageBytes, false, false); msg.payload().getBytes(msg.payload().readerIndex(), messageBytes); InternalMessage internalMessage = new InternalMessage().setTopic(msg.variableHeader().topicName()) .setMqttQoS(msg.fixedHeader().qosLevel().value()).setMessageBytes(messageBytes) .setDup(false).setRetain(false).setClientId(clientId); internalCommunication.internalSend(internalMessage); msg.payload().getBytes(msg.payload().readerIndex(), messageBytes); InternalMessage internalMessage = new InternalMessage().setTopic(msg.variableHeader().topicName()) .setMqttQoS(msg.fixedHeader().qosLevel().value()).setMessageBytes(messageBytes) .setDup(false).setRetain(false).setClientId(clientId); internalCommunication.internalSend(internalMessage); retainMessageStoreService.remove(msg.variableHeader().topicName()); } else { RetainMessageStore retainMessageStore = new RetainMessageStore().setTopic(msg.variableHeader().topicName()).setMqttQoS(msg.fixedHeader().qosLevel().value()) .setMessageBytes(messageBytes); retainMessageStoreService.put(msg.variableHeader().topicName(), retainMessageStore);
logger.trace("Send a copy of DISCONNECT message from client {} to 3rd party application", this.clientId); this.cluster.sendToApplication(new Message<>( new MqttFixedHeader(MqttMessageType.DISCONNECT, false, MqttQoS.AT_MOST_ONCE, false, 0), new MqttAdditionalHeader(this.version, this.clientId, this.userName, this.brokerId), null, null)); MqttQoS willQos = this.willMessage.fixedHeader().qos(); String willTopic = this.willMessage.variableHeader().topicName(); boolean willRetain = this.willMessage.fixedHeader().retain(); AuthorizeResult result = this.authenticator.authPublish(this.clientId, this.userName, willTopic, willQos.value(), willRetain);
private void sendRetainMessage(Channel channel, String topicFilter, MqttQoS mqttQoS) { List<RetainMessageStore> retainMessageStores = retainMessageStoreService.search(topicFilter); retainMessageStores.forEach(retainMessageStore -> { MqttQoS respQoS = retainMessageStore.getMqttQoS() > mqttQoS.value() ? mqttQoS : MqttQoS.valueOf(retainMessageStore.getMqttQoS()); if (respQoS == MqttQoS.AT_MOST_ONCE) { MqttPublishMessage publishMessage = (MqttPublishMessage) MqttMessageFactory.newMessage( new MqttFixedHeader(MqttMessageType.PUBLISH, false, respQoS, false, 0), new MqttPublishVariableHeader(retainMessageStore.getTopic(), 0), Unpooled.buffer().writeBytes(retainMessageStore.getMessageBytes())); LOGGER.debug("PUBLISH - clientId: {}, topic: {}, Qos: {}", (String) channel.attr(AttributeKey.valueOf("clientId")).get(), retainMessageStore.getTopic(), respQoS.value()); channel.writeAndFlush(publishMessage); } if (respQoS == MqttQoS.AT_LEAST_ONCE) { int messageId = messageIdService.getNextMessageId(); MqttPublishMessage publishMessage = (MqttPublishMessage) MqttMessageFactory.newMessage( new MqttFixedHeader(MqttMessageType.PUBLISH, false, respQoS, false, 0), new MqttPublishVariableHeader(retainMessageStore.getTopic(), messageId), Unpooled.buffer().writeBytes(retainMessageStore.getMessageBytes())); LOGGER.debug("PUBLISH - clientId: {}, topic: {}, Qos: {}, messageId: {}", (String) channel.attr(AttributeKey.valueOf("clientId")).get(), retainMessageStore.getTopic(), respQoS.value(), messageId); channel.writeAndFlush(publishMessage); } if (respQoS == MqttQoS.EXACTLY_ONCE) { int messageId = messageIdService.getNextMessageId(); MqttPublishMessage publishMessage = (MqttPublishMessage) MqttMessageFactory.newMessage( new MqttFixedHeader(MqttMessageType.PUBLISH, false, respQoS, false, 0), new MqttPublishVariableHeader(retainMessageStore.getTopic(), messageId), Unpooled.buffer().writeBytes(retainMessageStore.getMessageBytes())); LOGGER.debug("PUBLISH - clientId: {}, topic: {}, Qos: {}, messageId: {}", (String) channel.attr(AttributeKey.valueOf("clientId")).get(), retainMessageStore.getTopic(), respQoS.value(), messageId); channel.writeAndFlush(publishMessage); } }); }
public static MqttPublishMessage getMqttPublishMessage(Message message, boolean isDup) { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBLISH, isDup, MqttQoS.valueOf(message.getHeaders().get(MQTT_QOS_LEVEL)), Boolean.valueOf(message.getHeaders().get(MQTT_IS_RETAIN)), Integer.valueOf(message.getHeaders().get(MQTT_REMAINING_LENGTH)) ); MqttPublishVariableHeader variableHeader = new MqttPublishVariableHeader( message.getHeaders().get(MQTT_TOPIC_NAME), Integer.valueOf(message.getHeaders().get(MQTT_PACKET_ID)) ); ByteBuf buf = Unpooled.buffer(); buf.writeBytes((byte[]) message.getPayload()); return new MqttPublishMessage(fixedHeader, variableHeader, buf); }
private static Result<MqttConnectVariableHeader> decodeConnectionVariableHeader(ByteBuf buffer) { final Result<String> protocolName = decodeString(buffer); int numberOfBytesConsumed = protocolName.numberOfBytesConsumed; final byte protocolLevel = buffer.readByte(); numberOfBytesConsumed += 1; final MqttVersion mqttVersion = MqttVersion.fromProtocolNameAndLevel(protocolName.value, protocolLevel); final int b1 = buffer.readUnsignedByte(); numberOfBytesConsumed += 1; final Result<Integer> keepAlive = decodeMsbLsb(buffer); numberOfBytesConsumed += keepAlive.numberOfBytesConsumed; final boolean userNameFlag = (b1 & 0x80) == 0x80; final boolean passwordFlag = (b1 & 0x40) == 0x40; final boolean willRetain = (b1 & 0x20) == 0x20; final int willQos = (b1 & 0x18) >> 3; final boolean willFlag = (b1 & 0x04) == 0x04; final boolean cleanSession = (b1 & 0x02) == 0x02; final MqttConnectVariableHeader mqttConnectVariableHeader = new MqttConnectVariableHeader( mqttVersion.protocolName(), mqttVersion.protocolLevel(), userNameFlag, passwordFlag, willRetain, MqttQoS.valueOf(willQos), willFlag, cleanSession, keepAlive.value); return new Result<>(mqttConnectVariableHeader, numberOfBytesConsumed); }
public static NutMap transPublishToMapBeta(SessionStore store) { try { NutMap sessionStore = new NutMap(); sessionStore.addv("clientId", store.getClientId()); sessionStore.addv("channelId", store.getChannelId()); sessionStore.addv("cleanSession", store.isCleanSession()); MqttPublishMessage msg = store.getWillMessage(); if (null != msg) { sessionStore.addv("payload", new String(msg.payload().array(), "UTF-8")); sessionStore.addv("messageType", msg.fixedHeader().messageType().value()); sessionStore.addv("isDup", msg.fixedHeader().isDup()); sessionStore.addv("qosLevel", msg.fixedHeader().qosLevel().value()); sessionStore.addv("isRetain", msg.fixedHeader().isRetain()); sessionStore.addv("remainingLength", msg.fixedHeader().remainingLength()); sessionStore.addv("topicName", msg.variableHeader().topicName()); sessionStore.addv("packetId", msg.variableHeader().packetId()); sessionStore.addv("hasWillMessage", true); } return sessionStore; } catch (Exception e) { LOGGER.error(e.getMessage(), e); } return null; }
/** * Decodes the fixed header. It's one byte for the flags and then variable bytes for the remaining length. * * @param buffer the buffer to decode from * @return the fixed header */ private static MqttFixedHeader decodeFixedHeader(ByteBuf buffer) { short b1 = buffer.readUnsignedByte(); MqttMessageType messageType = MqttMessageType.valueOf(b1 >> 4); boolean dupFlag = (b1 & 0x08) == 0x08; int qosLevel = (b1 & 0x06) >> 1; boolean retain = (b1 & 0x01) != 0; int remainingLength = 0; int multiplier = 1; short digit; int loops = 0; do { digit = buffer.readUnsignedByte(); remainingLength += (digit & 127) * multiplier; multiplier *= 128; loops++; } while ((digit & 128) != 0 && loops < 4); // MQTT protocol limits Remaining Length to 4 bytes if (loops == 4 && (digit & 128) != 0) { throw new DecoderException("remaining length exceeds 4 digits (" + messageType + ')'); } MqttFixedHeader decodedFixedHeader = new MqttFixedHeader(messageType, dupFlag, MqttQoS.valueOf(qosLevel), retain, remainingLength); return validateFixedHeader(resetUnusedFields(decodedFixedHeader)); }
private static Result<MqttSubscribePayload> decodeSubscribePayload( ByteBuf buffer, int bytesRemainingInVariablePart) { final List<MqttTopicSubscription> subscribeTopics = new ArrayList<MqttTopicSubscription>(); int numberOfBytesConsumed = 0; while (numberOfBytesConsumed < bytesRemainingInVariablePart) { final Result<String> decodedTopicName = decodeString(buffer); numberOfBytesConsumed += decodedTopicName.numberOfBytesConsumed; int qos = buffer.readUnsignedByte() & 0x03; numberOfBytesConsumed++; subscribeTopics.add(new MqttTopicSubscription(decodedTopicName.value, MqttQoS.valueOf(qos))); } return new Result<MqttSubscribePayload>(new MqttSubscribePayload(subscribeTopics), numberOfBytesConsumed); }
private static Result<MqttSubAckPayload> decodeSubackPayload( ByteBuf buffer, int bytesRemainingInVariablePart) { final List<Integer> grantedQos = new ArrayList<Integer>(); int numberOfBytesConsumed = 0; while (numberOfBytesConsumed < bytesRemainingInVariablePart) { int qos = buffer.readUnsignedByte(); if (qos != MqttQoS.FAILURE.value()) { qos &= 0x03; } numberOfBytesConsumed++; grantedQos.add(qos); } return new Result<MqttSubAckPayload>(new MqttSubAckPayload(grantedQos), numberOfBytesConsumed); }
private static int getFixedHeaderByte1(MqttFixedHeader header) { int ret = 0; ret |= header.messageType().value() << 4; if (header.isDup()) { ret |= 0x08; } ret |= header.qosLevel().value() << 1; if (header.isRetain()) { ret |= 0x01; } return ret; }
protected void send(int messageId, String topicName, int qosLevel, boolean isRetain, ByteBuf payload, int deliveryCount) { boolean redelivery = qosLevel == 0 ? false : (deliveryCount > 0); MqttFixedHeader header = new MqttFixedHeader(MqttMessageType.PUBLISH, redelivery, MqttQoS.valueOf(qosLevel), isRetain, 0); MqttPublishVariableHeader varHeader = new MqttPublishVariableHeader(topicName, messageId); MqttMessage publish = new MqttPublishMessage(header, varHeader, payload); sendToClient(publish); }
/** * Create the SUBACK response from a list of topicFilters */ private MqttSubAckMessage doAckMessageFromValidateFilters(List<MqttTopicSubscription> topicFilters, int messageId) { List<Integer> grantedQoSLevels = new ArrayList<>(); for (MqttTopicSubscription req : topicFilters) { grantedQoSLevels.add(req.qualityOfService().value()); } MqttFixedHeader fixedHeader = new MqttFixedHeader(MqttMessageType.SUBACK, false, AT_MOST_ONCE, false, 0); MqttSubAckPayload payload = new MqttSubAckPayload(grantedQoSLevels); return new MqttSubAckMessage(fixedHeader, from(messageId), payload); }
if (!clientId.equals(subscribeStore.getClientId()) && sessionStoreService.containsKey(subscribeStore.getClientId())) { MqttQoS respQoS = mqttQoS.value() > subscribeStore.getMqttQoS() ? MqttQoS.valueOf(subscribeStore.getMqttQoS()) : mqttQoS; if (respQoS == MqttQoS.AT_MOST_ONCE) { MqttPublishMessage publishMessage = (MqttPublishMessage) MqttMessageFactory.newMessage( new MqttFixedHeader(MqttMessageType.PUBLISH, dup, respQoS, retain, 0), new MqttPublishVariableHeader(topic, 0), ByteBuffer.wrap(messageBytes)); LOGGER.debug("PUBLISH - clientId: {}, topic: {}, Qos: {}", subscribeStore.getClientId(), topic, respQoS.value()); ChannelId channelId = channelIdMap.get(sessionStoreService.get(subscribeStore.getClientId()).getChannelId()); if (channelId != null) { int messageId = messageIdService.getNextMessageId(); MqttPublishMessage publishMessage = (MqttPublishMessage) MqttMessageFactory.newMessage( new MqttFixedHeader(MqttMessageType.PUBLISH, dup, respQoS, retain, 0), new MqttPublishVariableHeader(topic, messageId), ByteBuffer.wrap(messageBytes)); LOGGER.debug("PUBLISH - clientId: {}, topic: {}, Qos: {}, messageId: {}", subscribeStore.getClientId(), topic, respQoS.value(), messageId); ChannelId channelId = channelIdMap.get(sessionStoreService.get(subscribeStore.getClientId()).getChannelId()); if (channelId != null) { int messageId = messageIdService.getNextMessageId(); MqttPublishMessage publishMessage = (MqttPublishMessage) MqttMessageFactory.newMessage( new MqttFixedHeader(MqttMessageType.PUBLISH, dup, respQoS, retain, 0), new MqttPublishVariableHeader(topic, messageId), ByteBuffer.wrap(messageBytes)); LOGGER.debug("PUBLISH - clientId: {}, topic: {}, Qos: {}, messageId: {}", subscribeStore.getClientId(), topic, respQoS.value(), messageId); ChannelId channelId = channelIdMap.get(sessionStoreService.get(subscribeStore.getClientId()).getChannelId()); if (channelId != null) {
private static int getFixedHeaderByte1(MqttFixedHeader header) { int ret = 0; ret |= header.messageType().value() << 4; if (header.dup()) { ret |= 0x08; } ret |= header.qos().value() << 1; if (header.retain()) { ret |= 0x01; } return ret; }