private static int getConnVariableHeaderFlag(MqttConnectVariableHeader variableHeader) { int flagByte = 0; if (variableHeader.hasUserName()) { flagByte |= 0x80; } if (variableHeader.hasPassword()) { flagByte |= 0x40; } if (variableHeader.isWillRetain()) { flagByte |= 0x20; } flagByte |= (variableHeader.willQos() & 0x03) << 3; if (variableHeader.isWillFlag()) { flagByte |= 0x04; } if (variableHeader.isCleanSession()) { flagByte |= 0x02; } return flagByte; }
MqttConnectVariableHeader variableHeader = message.variableHeader(); MqttConnectPayload payload = message.payload(); MqttVersion mqttVersion = MqttVersion.fromProtocolNameAndLevel(variableHeader.name(), (byte) variableHeader.version()); if (!variableHeader.hasUserName() && variableHeader.hasPassword()) { throw new DecoderException("Without a username, the password MUST be not set"); byte[] willMessage = payload.willMessageInBytes(); byte[] willMessageBytes = willMessage != null ? willMessage : EmptyArrays.EMPTY_BYTES; if (variableHeader.isWillFlag()) { payloadBufferSize += 2 + willTopicBytes.length; payloadBufferSize += 2 + willMessageBytes.length; if (variableHeader.hasUserName()) { payloadBufferSize += 2 + userNameBytes.length; if (variableHeader.hasPassword()) { payloadBufferSize += 2 + passwordBytes.length; buf.writeByte(variableHeader.version()); buf.writeByte(getConnVariableHeaderFlag(variableHeader)); buf.writeShort(variableHeader.keepAliveTimeSeconds()); if (variableHeader.isWillFlag()) { buf.writeShort(willTopicBytes.length); buf.writeBytes(willTopicBytes, 0, willTopicBytes.length); if (variableHeader.hasUserName()) {
private void initializeKeepAliveTimeout(Channel channel, MqttConnectMessage msg, String clientId) { int keepAlive = msg.variableHeader().keepAliveTimeSeconds(); NettyUtils.keepAlive(channel, keepAlive); NettyUtils.cleanSession(channel, msg.variableHeader().isCleanSession()); NettyUtils.clientID(channel, clientId); int idleTime = Math.round(keepAlive * 1.5f); setIdleTime(channel.pipeline(), idleTime); LOG.debug("Connection has been configured CId={}, keepAlive={}, removeTemporaryQoS2={}, idleTime={}", clientId, keepAlive, msg.variableHeader().isCleanSession(), idleTime); }
private void copySessionConfig(MqttConnectMessage msg, Session session) { final boolean clean = msg.variableHeader().isCleanSession(); final Session.Will will; if (msg.variableHeader().isWillFlag()) { will = createWill(msg); } else { will = null; } session.update(clean, will); }
MqttConnectVariableHeader connectHeader = (MqttConnectVariableHeader) message.variableHeader(); MqttConnectPayload payload = ((MqttConnectMessage)message).payload(); log.append(" protocol=(").append(connectHeader.name()).append(", ").append(connectHeader.version()).append(")") .append(", hasPassword=").append(connectHeader.hasPassword()) .append(", isCleanSession=").append(connectHeader.isCleanSession()) .append(", keepAliveTimeSeconds=").append(connectHeader.keepAliveTimeSeconds()) .append(", clientIdentifier=").append(payload.clientIdentifier()) .append(", hasUserName=").append(connectHeader.hasUserName()); if (connectHeader.hasUserName()) { log.append(", userName=").append(payload.userName()); log.append(", isWillFlag=").append(connectHeader.isWillFlag()); if (connectHeader.isWillFlag()) { log.append(", willQos=").append(connectHeader.willQos()) .append(", isWillRetain=").append(connectHeader.isWillRetain()) .append(", willTopic=").append(payload.willTopic());
/** * Called during connection. * * @param connect */ void handleConnect(MqttConnectMessage connect, ChannelHandlerContext ctx) throws Exception { this.ctx = ctx; connectionEntry.ttl = connect.variableHeader().keepAliveTimeSeconds() * 1500L; String clientId = connect.payload().clientIdentifier(); session.getConnectionManager().connect(clientId, connect.payload().userName(), connect.payload().passwordInBytes(), connect.variableHeader().isWillFlag(), connect.payload().willMessageInBytes(), connect.payload().willTopic(), connect.variableHeader().isWillRetain(), connect.variableHeader().willQos(), connect.variableHeader().isCleanSession()); }
private static void validateConnectVariableHeader( MqttConnectVariableHeader expected, MqttConnectVariableHeader actual) { assertEquals("MqttConnectVariableHeader ProtocolName mismatch ", expected.protocolName(), actual.protocolName()); assertEquals( "MqttConnectVariableHeader KeepAlive mismatch ", expected.keepAlive(), actual.keepAlive()); assertEquals("MqttConnectVariableHeader ProtocolLevel mismatch ", expected.protocolLevel(), actual.protocolLevel()); assertEquals("MqttConnectVariableHeader WillQos mismatch ", expected.willQos(), actual.willQos()); assertEquals("MqttConnectVariableHeader UserNameFlag mismatch ", expected.userNameFlag(), actual.userNameFlag()); assertEquals("MqttConnectVariableHeader PasswordFlag mismatch ", expected.passwordFlag(), actual.passwordFlag()); assertEquals( "MqttConnectVariableHeader CleanSession mismatch ", expected.cleanSession(), actual.cleanSession()); assertEquals("MqttConnectVariableHeader WillFlag mismatch ", expected.willFlag(), actual.willFlag()); assertEquals( "MqttConnectVariableHeader WillRetain mismatch ", expected.willRetain(), actual.willRetain()); }
private void storeWillMessage(MqttConnectMessage msg, String clientId) { // Handle will flag if (msg.variableHeader().isWillFlag()) { MqttQoS willQos = MqttQoS.valueOf(msg.variableHeader().willQos()); LOG.debug("Configuring MQTT last will and testament CId={}, willQos={}, willTopic={}, willRetain={}", clientId, willQos, msg.payload().willTopic(), msg.variableHeader().isWillRetain()); byte[] willPayload = msg.payload().willMessage().getBytes(StandardCharsets.UTF_8); ByteBuffer bb = (ByteBuffer) ByteBuffer.allocate(willPayload.length).put(willPayload).flip(); // save the will testament in the clientID store WillMessage will = new WillMessage(msg.payload().willTopic(), bb, msg.variableHeader().isWillRetain(), willQos); m_willStore.put(clientId, will); LOG.debug("MQTT last will and testament has been configured. CId={}", clientId); } }
private Session.Will createWill(MqttConnectMessage msg) { final ByteBuf willPayload = Unpooled.copiedBuffer(msg.payload().willMessageInBytes()); final String willTopic = msg.payload().willTopic(); final boolean retained = msg.variableHeader().isWillRetain(); final MqttQoS qos = MqttQoS.valueOf(msg.variableHeader().willQos()); return new Session.Will(willTopic, willPayload, qos, retained); }
public MqttConnectMessage build() { MqttFixedHeader mqttFixedHeader = new MqttFixedHeader(MqttMessageType.CONNECT, false, MqttQoS.AT_MOST_ONCE, false, 0); MqttConnectVariableHeader mqttConnectVariableHeader = new MqttConnectVariableHeader( version.protocolName(), version.protocolLevel(), hasUser, hasPassword, willRetain, willQos.value(), willFlag, cleanSession, keepAliveSecs); MqttConnectPayload mqttConnectPayload = new MqttConnectPayload(clientId, willTopic, willMessage, username, password); return new MqttConnectMessage(mqttFixedHeader, mqttConnectVariableHeader, mqttConnectPayload); } }
public boolean isCleanSession() { return msg.variableHeader().isCleanSession(); }
private boolean login(MqttConnectMessage msg, final String clientId) { // handle user authentication if (msg.variableHeader().hasUserName()) { byte[] pwd = null; if (msg.variableHeader().hasPassword()) { pwd = msg.payload().password().getBytes(StandardCharsets.UTF_8); } else if (!brokerConfig.isAllowAnonymous()) { LOG.error("Client didn't supply any password and MQTT anonymous mode is disabled CId={}", clientId); return false; } final String login = msg.payload().userName(); if (!authenticator.checkValid(clientId, login, pwd)) { LOG.error("Authenticator has rejected the MQTT credentials CId={}, username={}", clientId, login); return false; } NettyUtils.userName(channel, login); } else if (!brokerConfig.isAllowAnonymous()) { LOG.error("Client didn't supply any credentials and MQTT anonymous mode is disabled. CId={}", clientId); return false; } return true; }
private static int getConnVariableHeaderFlag(MqttConnectVariableHeader variableHeader) { int flagByte = 0; if (variableHeader.userNameFlag()) { flagByte |= 0x80; } if (variableHeader.passwordFlag()) { flagByte |= 0x40; } if (variableHeader.willRetain()) { flagByte |= 0x20; } flagByte |= (variableHeader.willQos().value() & 0x03) << 3; if (variableHeader.willFlag()) { flagByte |= 0x04; } if (variableHeader.cleanSession()) { flagByte |= 0x02; } return flagByte; }
LOG.debug("Processing CONNECT message. CId={}, username={}", clientId, payload.userName()); if (msg.variableHeader().version() != MqttVersion.MQTT_3_1.protocolLevel() && msg.variableHeader().version() != MqttVersion.MQTT_3_1_1.protocolLevel()) { MqttConnAckMessage badProto = connAck(CONNECTION_REFUSED_UNACCEPTABLE_PROTOCOL_VERSION); final boolean cleanSession = msg.variableHeader().isCleanSession(); if (clientId == null || clientId.length() == 0) { if (!cleanSession || !this.allowZeroByteClientId) {
public byte getWillQos() { return (byte) msg.variableHeader().willQos(); }
private boolean isServiceAviable(MqttConnectMessage connectMessage) { int version = connectMessage.variableHeader().version(); return version >= MIN_AVAILABLE_VERSION && version <= MAX_AVAILABLE_VERSION; }
public boolean isWillFlag() { return msg.variableHeader().isWillFlag(); }
public boolean isWillRetain() { return msg.variableHeader().isWillRetain(); }
public int getKeepAlive() { return msg.variableHeader().keepAliveTimeSeconds(); }
public boolean isUserFlag() { return msg.variableHeader().hasUserName(); }