public static MqttMsgPubcomp BuildPubComp(ushort messageId) { MqttMsgPubcomp pubComp = new MqttMsgPubcomp(); pubComp.MessageId = messageId; return(pubComp); }
/// <summary> /// Parse bytes for a PUBCOMP message /// </summary> /// <param name="fixedHeaderFirstByte">First fixed header byte</param> /// <param name="protocolVersion">Protocol Version</param> /// <param name="channel">Channel connected to the broker</param> /// <returns>PUBCOMP message instance</returns> public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel) { byte[] buffer; int index = 0; MqttMsgPubcomp msg = new MqttMsgPubcomp(); if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) { // [v3.1.1] check flag bits if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBCOMP_FLAG_BITS) { throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits); } } // get remaining length and allocate buffer int remainingLength = MqttMsgBase.decodeRemainingLength(channel); buffer = new byte[remainingLength]; // read bytes from socket... channel.Receive(buffer); // message id msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00); msg.messageId |= (buffer[index++]); return(msg); }
public static void Pubcomp(MqttClientConnection clientConnection, ushort messageId) { MqttMsgPubcomp pubcomp = new MqttMsgPubcomp(); pubcomp.MessageId = messageId; Send(clientConnection, pubcomp); }
public void PubcompBasicDecodeTestv311() { // Arrange byte[] encodedCorrect = new byte[] { 2, 0, 42 }; MokChannel mokChannel = new(encodedCorrect); // Act MqttMsgPubcomp pubcomp = MqttMsgPubcomp.Parse(112, MqttProtocolVersion.Version_3_1_1, mokChannel); // Assert Assert.Equal((ushort)42, pubcomp.MessageId); }
public void PubcompBasicDecodeTestv5() { // Arrange byte[] encodedCorrect = new byte[] { 4, 0, 42, 0x97, 0 }; MokChannel mokChannel = new(encodedCorrect); // Act MqttMsgPubcomp pubcomp = MqttMsgPubcomp.Parse(112, MqttProtocolVersion.Version_5, mokChannel); // Assert Assert.Equal((byte)MqttMessageType.PublishComplete, (byte)pubcomp.Type); Assert.Equal((ushort)42, pubcomp.MessageId); Assert.Equal((byte)0x97, (byte)pubcomp.ReasonCode); }
/// <summary> /// Parse bytes for a PUBCOMP message /// </summary> /// <param name="fixedHeaderFirstByte">First fixed header byte</param> /// <param name="channel">Channel connected to the broker</param> /// <returns>PUBCOMP message instance</returns> public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel) { byte[] buffer; int index = 0; MqttMsgPubcomp msg = new MqttMsgPubcomp(); // get remaining length and allocate buffer int remainingLength = MqttMsgBase.decodeRemainingLength(channel); buffer = new byte[remainingLength]; // read bytes from socket... channel.Receive(buffer); // message id msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00); msg.messageId |= (buffer[index++]); return msg; }
/// <summary> /// Parse bytes for a PUBCOMP message /// </summary> /// <param name="fixedHeaderFirstByte">First fixed header byte</param> /// <param name="channel">Channel connected to the broker</param> /// <returns>PUBCOMP message instance</returns> public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel) { byte[] buffer; int index = 0; MqttMsgPubcomp msg = new MqttMsgPubcomp(); // get remaining length and allocate buffer int remainingLength = MqttMsgBase.decodeRemainingLength(channel); buffer = new byte[remainingLength]; // read bytes from socket... channel.Receive(buffer); // message id msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00); msg.messageId |= (buffer[index++]); return(msg); }
public void PubcompAdvanceDecodeTestv5() { // Arrange byte[] encodedCorrect = new byte[] { 53, 0, 42, 151, 49, 31, 0, 26, 89, 111, 117, 32, 104, 97, 118, 101, 32, 101, 120, 99, 101, 101, 100, 32, 121, 111, 117, 114, 32, 113, 117, 111, 116, 97, 38, 0, 4, 80, 114, 111, 112, 0, 1, 49, 38, 0, 4, 80, 114, 111, 112, 0, 1, 50 }; MokChannel mokChannel = new(encodedCorrect); // Act MqttMsgPubcomp pubcomp = MqttMsgPubcomp.Parse(112, MqttProtocolVersion.Version_5, mokChannel); // Assert Assert.Equal((ushort)42, pubcomp.MessageId); Assert.Equal((byte)pubcomp.ReasonCode, (byte)MqttReasonCode.QuotaExceeded); Assert.Equal(pubcomp.Reason, "You have exceed your quota"); Assert.Equal(pubcomp.UserProperties.Count, 2); var prop = new UserProperty("Prop", "1"); Assert.Equal(((UserProperty)pubcomp.UserProperties[0]).Name, prop.Name); Assert.Equal(((UserProperty)pubcomp.UserProperties[0]).Value, prop.Value); prop = new UserProperty("Prop", "2"); Assert.Equal(((UserProperty)pubcomp.UserProperties[1]).Name, prop.Name); Assert.Equal(((UserProperty)pubcomp.UserProperties[1]).Value, prop.Value); }
private void HandlePUBCOMPType(uint clientIndex, MqttMsgPubcomp pubComp, bool isWebSocketClient) { CrestronLogger.WriteToLog("MQTTSERVER - " + GetClientByIndex(clientIndex, isWebSocketClient).ClientId + " HandlePUBCOMPType - ricevuto PUBCOMP , packetIdentifier: " + pubComp.MessageId, 5); }
public static MqttMsgBase DecodeControlPacket(byte[] data) { byte fixedHeaderFirstByte = (byte)(data[0] >> MqttMsgBase.MSG_TYPE_OFFSET); switch (fixedHeaderFirstByte) { case MqttMsgBase.MQTT_MSG_CONNECT_TYPE: { return(MqttMsgConnect.Parse(data)); } case MqttMsgBase.MQTT_MSG_CONNACK_TYPE: { return(MqttMsgConnack.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE: { return(MqttMsgPublish.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBACK_TYPE: { return(MqttMsgPuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREC_TYPE: { return(MqttMsgPubrec.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREL_TYPE: { return(MqttMsgPubrel.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE: { return(MqttMsgPubcomp.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE: { return(MqttMsgSubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBACK_TYPE: { return(MqttMsgSuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE: { return(MqttMsgUnsubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE: { return(MqttMsgUnsuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE: { return(MqttMsgPingReq.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE: { return(MqttMsgPingResp.Parse(data)); } case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE: { CrestronLogger.WriteToLog("PACKETDECODER - Riconosciuto DISCONNNECT: ", 1); return(MqttMsgDisconnect.Parse(data)); } default: { throw new FormatException(); } } }
/// <summary> /// Thread for receiving messages from broker /// </summary> private void ReceiveThread() { int readBytes; byte[] fixedHeaderFirstByte = new byte[1]; byte msgType; while (this.isRunning) { try { // read first byte (fixed header) readBytes = this.socket.Receive(fixedHeaderFirstByte); if (readBytes > 0) { // extract message type from received byte msgType = (byte)((fixedHeaderFirstByte[0] & MqttMsgBase.MSG_TYPE_MASK) >> MqttMsgBase.MSG_TYPE_OFFSET); switch (msgType) { // impossible, broker can't send CONNECT message case MqttMsgBase.MQTT_MSG_CONNECT_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); // CONNACK message received from broker case MqttMsgBase.MQTT_MSG_CONNACK_TYPE: this.msgReceived = MqttMsgConnack.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); break; // impossible, broker can't send PINGREQ message case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); // CONNACK message received from broker case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE: this.msgReceived = MqttMsgPingResp.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); break; // impossible, broker can't send SUBSCRIBE message case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); // SUBACK message received from broker case MqttMsgBase.MQTT_MSG_SUBACK_TYPE: this.msgReceived = MqttMsgSuback.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); // raise subscribed topic event (SUBACK message received) this.OnMqttMsgSubscribed((MqttMsgSuback)this.msgReceived); break; // PUBLISH message received from broker case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE: MqttMsgPublish msgReceived = MqttMsgPublish.Parse(fixedHeaderFirstByte[0], this.socket); // for QoS Level 1 and 2, client sends PUBACK message to broker if ((this.msgReceived.QosLevel == MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE) || (this.msgReceived.QosLevel == MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE)) { MqttMsgPuback puback = new MqttMsgPuback(); puback.MessageId = (msgReceived).MessageId; this.Send(puback.GetBytes()); } // raise PUBLISH message received event this.OnMqttMsgPublishReceived(msgReceived); break; // PUBACK message received from broker case MqttMsgBase.MQTT_MSG_PUBACK_TYPE: this.msgReceived = MqttMsgPuback.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); // raise published message event // (PUBACK received for QoS Level 1) this.OnMqttMsgPublished(((MqttMsgPuback)this.msgReceived).MessageId); break; // PUBREC message received from broker case MqttMsgBase.MQTT_MSG_PUBREC_TYPE: this.msgReceived = MqttMsgPubrec.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); break; // impossible, broker can't send PUBREL message case MqttMsgBase.MQTT_MSG_PUBREL_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); // PUBCOMP message received from broker case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE: this.msgReceived = MqttMsgPubcomp.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); // raise published message event // (PUBCOMP received for QoS Level 2) this.OnMqttMsgPublished(((MqttMsgPuback)this.msgReceived).MessageId); break; // impossible, broker can't send UNSUBSCRIBE message case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); // UNSUBACK message received from broker case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE: this.msgReceived = MqttMsgUnsuback.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); // raise unsubscribed topic event this.OnMqttMsgUnsubscribed(((MqttMsgUnsuback)this.msgReceived).MessageId); break; default: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); } this.exReceiving = null; } } catch (Exception) { this.exReceiving = new MqttCommunicationException(); } } }
/// <summary> /// Publish a message to the broker /// </summary> /// <param name="topic">Message topic</param> /// <param name="message">Message data (payload)</param> /// <param name="qosLevel">QoS Level</param> /// <param name="retain">Retain flag</param> /// <returns>Message Id related to PUBLISH message</returns> public ushort Publish(string topic, byte[] message, byte qosLevel = MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE, bool retain = false) { ushort messageId = 0; int attempts = 0; bool acknowledged = false; MqttMsgPublish publish = new MqttMsgPublish(topic, message, false, qosLevel, retain); // based on QoS level, the messages flow between client and broker changes switch (qosLevel) { // QoS Level 0, no answer from broker case MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE: this.Send(publish.GetBytes()); break; // QoS Level 1, waiting for PUBACK message from broker case MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE: attempts = 0; acknowledged = false; do { MqttMsgPuback puback = null; try { // try publish puback = (MqttMsgPuback)this.SendReceive(publish.GetBytes()); acknowledged = true; } catch (MqttTimeoutException) { // no PUBACK message received in time, retry with duplicate flag attempts++; publish.DupFlag = true; // delay before retry if (attempts < MQTT_ATTEMPTS_RETRY) { Thread.Sleep(MQTT_DELAY_RETRY); } } } while ((attempts < MQTT_ATTEMPTS_RETRY) && !acknowledged); if (acknowledged) { messageId = publish.MessageId; } break; // QoS Level 2, waiting for PUBREC message from broker, // send PUBREL message and waiting for PUBCOMP message from broker case MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE: attempts = 0; acknowledged = false; do { MqttMsgPubrec pubrec = null; try { // try publish pubrec = (MqttMsgPubrec)this.SendReceive(publish.GetBytes()); acknowledged = true; } catch (MqttTimeoutException) { // no PUBREC message received in time, retry with duplicate flag attempts++; publish.DupFlag = true; // delay before retry if (attempts < MQTT_ATTEMPTS_RETRY) { Thread.Sleep(MQTT_DELAY_RETRY); } } } while ((attempts < MQTT_ATTEMPTS_RETRY) && !acknowledged); // first phase ok if (acknowledged) { attempts = 0; acknowledged = false; do { // set publish message identifier into PUBREL message MqttMsgPubrel pubrel = new MqttMsgPubrel(); pubrel.MessageId = publish.MessageId; MqttMsgPubcomp pubcomp = null; try { // try send PUBREL message pubcomp = (MqttMsgPubcomp)this.SendReceive(pubrel.GetBytes()); acknowledged = true; } catch (MqttTimeoutException) { // no PUBCOMP message received in time, retry with duplicate flag attempts++; pubrel.DupFlag = true; // delay before retry if (attempts < MQTT_ATTEMPTS_RETRY) { Thread.Sleep(MQTT_DELAY_RETRY); } } } while ((attempts < MQTT_ATTEMPTS_RETRY) && !acknowledged); if (acknowledged) { messageId = publish.MessageId; } } break; default: throw new MqttClientException(MqttClientErrorCode.QosNotAllowed); } return(messageId); }
public MqttMsgBase DecodeControlPacket(byte[] data) { byte fixedHeaderFirstByte = (byte)(data[0] >> MSG_TYPE_OFFSET); switch (fixedHeaderFirstByte) { case MqttMsgBase.MQTT_MSG_CONNECT_TYPE: { return(MqttMsgConnect.Parse(data)); } case MqttMsgBase.MQTT_MSG_CONNACK_TYPE: { return(MqttMsgConnack.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE: { return(MqttMsgPublish.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBACK_TYPE: { return(MqttMsgPuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREC_TYPE: { return(MqttMsgPubrec.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREL_TYPE: { return(MqttMsgPubrel.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE: { return(MqttMsgPubcomp.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE: { return(MqttMsgSubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBACK_TYPE: { return(MqttMsgSuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE: { return(MqttMsgUnsubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE: { return(MqttMsgUnsuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE: { return(MqttMsgPingReq.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE: { return(MqttMsgPingResp.Parse(data)); } case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE: { return(MqttMsgDisconnect.Parse(data)); } default: { throw new FormatException(" First byte shifted : " + fixedHeaderFirstByte); } } }
public void ProcessReceivedMessage(MqttRawMessage rawMessage) { if (!rawMessage.Connection.IsRunning) { return; } // update last message received ticks rawMessage.Connection.LastCommunicationTime = Environment.TickCount; // extract message type from received byte var msgType = (byte)((rawMessage.MessageType & MqttMsgBase.MSG_TYPE_MASK) >> MqttMsgBase.MSG_TYPE_OFFSET); var protocolVersion = (byte)rawMessage.Connection.ProtocolVersion; switch (msgType) { case MqttMsgBase.MQTT_MSG_CONNECT_TYPE: var connect = MqttMsgConnect.Parse( rawMessage.MessageType, protocolVersion, rawMessage.PayloadBuffer); rawMessage.Connection.EnqueueInternalEvent(new InternalEvent(connect)); break; case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE: var pingReqest = MqttMsgPingReq.Parse(rawMessage.MessageType, protocolVersion); outgoingMessageHandler.PingResp(rawMessage.Connection); break; case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE: var subscribe = MqttMsgSubscribe.Parse( rawMessage.MessageType, protocolVersion, rawMessage.PayloadBuffer, rawMessage.PayloadLength); rawMessage.Connection.EnqueueInternalEvent(new InternalEvent(subscribe)); break; case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE: var publish = MqttMsgPublish.Parse( rawMessage.MessageType, protocolVersion, rawMessage.PayloadBuffer, rawMessage.PayloadLength); EnqueueInflight(rawMessage.Connection, publish, MqttMsgFlow.ToAcknowledge); break; case MqttMsgBase.MQTT_MSG_PUBACK_TYPE: // enqueue PUBACK message received (for QoS Level 1) into the internal queue var puback = MqttMsgPuback.Parse( rawMessage.MessageType, protocolVersion, rawMessage.PayloadBuffer); EnqueueInternal(rawMessage.Connection, puback); break; case MqttMsgBase.MQTT_MSG_PUBREC_TYPE: // enqueue PUBREC message received (for QoS Level 2) into the internal queue var pubrec = MqttMsgPubrec.Parse( rawMessage.MessageType, protocolVersion, rawMessage.PayloadBuffer); EnqueueInternal(rawMessage.Connection, pubrec); break; case MqttMsgBase.MQTT_MSG_PUBREL_TYPE: // enqueue PUBREL message received (for QoS Level 2) into the internal queue var pubrel = MqttMsgPubrel.Parse( rawMessage.MessageType, protocolVersion, rawMessage.PayloadBuffer); EnqueueInternal(rawMessage.Connection, pubrel); break; case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE: // enqueue PUBCOMP message received (for QoS Level 2) into the internal queue var pubcomp = MqttMsgPubcomp.Parse( rawMessage.MessageType, protocolVersion, rawMessage.PayloadBuffer); EnqueueInternal(rawMessage.Connection, pubcomp); break; case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE: var unsubscribe = MqttMsgUnsubscribe.Parse( rawMessage.MessageType, protocolVersion, rawMessage.PayloadBuffer, rawMessage.PayloadLength); rawMessage.Connection.EnqueueInternalEvent(new InternalEvent(unsubscribe)); break; case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE: var disconnect = MqttMsgDisconnect.Parse(rawMessage.MessageType, protocolVersion); rawMessage.Connection.EnqueueInternalEvent(new InternalEvent(disconnect)); break; case MqttMsgBase.MQTT_MSG_CONNACK_TYPE: case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE: case MqttMsgBase.MQTT_MSG_SUBACK_TYPE: case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); default: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); } }
private void HandlePUBCOMPType(MqttMsgPubcomp pubComp) { throw new NotImplementedException(); //publisherManager.ManagePubComp(pubComp); }
public MqttMsgBase DecodeControlPacket(byte[] data) { #if PACKET_DEBUG CrestronLogger.WriteToLog("MQTTCLIENT - RECEIVE - " + BitConverter.ToString(data), 2); #endif byte fixedHeaderFirstByte = (byte)(data[0] >> MSG_TYPE_OFFSET); switch (fixedHeaderFirstByte) { case MqttMsgBase.MQTT_MSG_CONNECT_TYPE: { return(MqttMsgConnect.Parse(data)); } case MqttMsgBase.MQTT_MSG_CONNACK_TYPE: { return(MqttMsgConnack.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE: { return(MqttMsgPublish.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBACK_TYPE: { return(MqttMsgPuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREC_TYPE: { return(MqttMsgPubrec.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREL_TYPE: { return(MqttMsgPubrel.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE: { return(MqttMsgPubcomp.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE: { return(MqttMsgSubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBACK_TYPE: { return(MqttMsgSuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE: { return(MqttMsgUnsubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE: { return(MqttMsgUnsuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE: { return(MqttMsgPingReq.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE: { return(MqttMsgPingResp.Parse(data)); } case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE: { return(MqttMsgDisconnect.Parse(data)); } default: { throw new FormatException(" First byte shifted : " + fixedHeaderFirstByte); } } }