Пример #1
16
bool AddInterfaceEC::parsePayload(connector::EditingCommandData* ecd)
{
        // addLink(baseID, documentID, compositeId, xmlLink)
        unsigned int argsLength = 0;
        std::string payload ((const char *)ecd->getPayload(), (size_t)ecd->getPayloadSize());
        std::vector<std::string>* tokens = util::split(payload, ",");
        int token_cnt = tokens->size();
        if (token_cnt > 3) {
		baseId = (*tokens)[0];
		argsLength += baseId.length();
		
		documentId = (*tokens)[1];
		argsLength += documentId.length();

		nodeId = (*tokens)[2];
		argsLength += nodeId.length();
		
		argsLength += 3; //por las comas
		xmlInterface = payload.substr(argsLength, payload.length() - argsLength);
		
		delete tokens;
		return true;
	} else {
		delete tokens;
		return false;
	}	
}
Пример #2
7
bool AddDocumentEC::parsePayload(connector::EditingCommandData* ecd)
{
        // addDocument (baseID, {uri,ior}+)
        std::string payload ((const char *)ecd->getPayload(), (size_t)ecd->getPayloadSize());
        std::vector<std::string>* tokens = util::split(payload, ",");
        if (tokens->size() > 1) {
                baseId = (*tokens)[0];
                int index = 1;
                for (; index+1 < tokens->size(); index += 2) {
                        documentUris.push_back(tokens->at(index  ));
                        documentIors.push_back(tokens->at(index+1));
                }
                if (index < tokens->size()) {
                        // HACK: Should fix util::split here...
                for ( ; index < tokens->size(); index++) {
                        documentUris.push_back(tokens->at(index));
                        documentIors.push_back("");
                }
                }
                delete tokens;
                return true;
        }
        else  {
		delete tokens; 
		return false;
	}
}
pplx::task<xbox_live_result<xbox_social_relationship_result>>
social_service_impl::get_social_relationships(
    _In_ const string_t& xboxUserId,
    _In_ xbox_social_relationship_filter filter,
    _In_ unsigned int startIndex,
    _In_ unsigned int maxItems
    )
{
    bool includeViewFilter = (filter != xbox_social_relationship_filter::all);

    string_t pathAndQuery = pathandquery_social_subpath(
        xboxUserId,
        includeViewFilter,
        xbox_social_relationship_filter_to_string(filter),
        startIndex,
        maxItems
        );

    std::shared_ptr<http_call> httpCall = xbox::services::system::xbox_system_factory::get_factory()->create_http_call(
        m_xboxLiveContextSettings,
        _T("GET"),
        utils::create_xboxlive_endpoint(_T("social"), m_appConfig),
        pathAndQuery,
        xbox_live_api::get_social_relationships
        );

    auto userContext = m_userContext;
    auto xboxLiveContextSettings = m_xboxLiveContextSettings;
    auto appConfig = m_appConfig;

    std::shared_ptr<social_service_impl> thisShared = shared_from_this();
    auto task = httpCall->get_response_with_auth(m_userContext)
    .then([thisShared, userContext, xboxLiveContextSettings, appConfig, startIndex, filter](std::shared_ptr<http_call_response> response)
    {
        auto result = xbox_social_relationship_result::_Deserialize(response->response_body_json());

        auto& socialRelationship = result.payload();
        uint32_t itemSize = static_cast<uint32_t>(socialRelationship.items().size());
        if (itemSize > 0)
        {
            unsigned continuationSkip = startIndex + itemSize;
            
            // Initialize the request params for get_next()
            socialRelationship._Init_next_page_info(
                thisShared,
                filter,
                continuationSkip
                );
        }

        return utils::generate_xbox_live_result<xbox_social_relationship_result>(
            result,
            response
            );
    });

    return utils::create_exception_free_task<xbox_social_relationship_result>(
        task
        );
}
Пример #4
0
bool SetPropertyValueEC::parsePayload(connector::EditingCommandData* ecd)
{
	//setPropertyValue(baseID, documentID, nodeId, propertyId, value)
	unsigned int argsLength = 0;
	std::string payload ((const char *)ecd->getPayload(), (size_t)ecd->getPayloadSize());
	std::vector<std::string>* tokens = util::split(payload, ",");
	int token_cnt = tokens->size();
	if (token_cnt > 4){ // Hack - should fix split
	    baseId = (*tokens)[0];
	    argsLength += baseId.length();
	
	    documentId = (*tokens)[1];
	    argsLength += documentId.length();

	    nodeId = (*tokens)[2];
	    argsLength += nodeId.length();

	    propertyId = (*tokens)[3];
	    argsLength += propertyId.length();
	
	    argsLength += 4; //por las comas        
	    propertyValue = payload.substr(argsLength, payload.length() - argsLength);
	    
	    delete tokens;
	    return true;
	} else {
	    delete tokens;
	    return false;
	}
}
Пример #5
0
static char exe_trace(fdja_value *node, fdja_value *exe)
{
  fdja_value *pl = payload(exe);

  fdja_value *trace = fdja_l(pl, "trace");
  if (trace == NULL) trace = fdja_set(pl, "trace", fdja_array_malloc());

  fdja_value *atts = attributes(node, exe);

  if (atts->child == NULL)
  {
    fdja_value *ret = fdja_l(exe, "payload.ret");
    fdja_push(trace, ret ? fdja_clone(ret) : fdja_v("null"));
  }
  else if (atts->child && atts->child->sibling == NULL)
  {
    fdja_push(trace, fdja_lc(atts, "_0"));
  }
  else
  {
    fdja_push(trace, shrink_atts(atts));
  }

  fdja_free(atts);

  return 'v'; // over
}
void AddressTester::onConnected()
{
    timer.stop();
    emit lagTestFinished(time.msecsTo(QTime::currentTime()));
    if (testingConnectivity) {
        Encryptor encryptor(encryptionMethod, encryptionPassword);
        /*
         * A http request to Google to test connectivity
         * The payload is dumped from
         * `curl http://www.google.com --socks5 127.0.0.1:1080`
         *
         * TODO: find a better way to check connectivity
         */
        std::string dest =
                Common::packAddress(Address("www.google.com", 80));
        static const QByteArray expected = QByteArray::fromHex(
                        "474554202f20485454502f312e310d0a486f73743a"
                        "207777772e676f6f676c652e636f6d0d0a55736572"
                        "2d4167656e743a206375726c2f372e34332e300d0a"
                        "4163636570743a202a2f2a0d0a0d0a");
        std::string payload(expected.data(), expected.length());
        std::string toWrite = encryptor.encrypt(dest + payload);
        socket.write(toWrite.data(), toWrite.size());
    } else {
        socket.abort();
    }
}
Пример #7
0
void _main()
{
	Handle fileHandle = 0x0;
	Result ret = 0x0;

	u32 compressed_size = 0x0;
	u8* compressed_buffer = LINEAR_BUFFER;

	// load payload.bin from savegame
	ret = _FSUSER_OpenFileDirectly(fsHandle, &fileHandle, 0x0, 0x00000004, PATH_EMPTY, "", 1, PATH_CHAR, "/payload.bin", 13, 0x1, 0x0);
	if(ret)*(u32*)ret = 0xdead0001;

	ret = _FSUSER_ReadFile(&fileHandle, &compressed_size, 0x0, compressed_buffer, 0xA000);
	if(ret)*(u32*)ret = 0xdead0002;

	u8* decompressed_buffer = &compressed_buffer[(compressed_size + 0xfff) & ~0xfff];
	u32 decompressed_size = lzss_get_decompressed_size(compressed_buffer, compressed_size);

	// decompress payload
	ret = lzss_decompress(compressed_buffer, compressed_size, decompressed_buffer, decompressed_size);

	// copy payload to text
	ret = _GSPGPU_FlushDataCache(gspHandle, 0xFFFF8001, (u32*)decompressed_buffer, decompressed_size);
	ret = gspwn((void*)(IRON_CODE_LINEAR_BASE + 0x00101000 - 0x00100000), decompressed_buffer, (decompressed_size + 0x1f) & ~0x1f);
	svc_sleepThread(300*1000*1000);

	// ghetto dcache invalidation
	// don't judge me
	int i, j;//, k;
	// for(k=0; k<0x2; k++)
		for(j=0; j<0x4; j++)
			for(i=0; i<0x01000000/0x4; i+=0x4)
				LINEAR_BUFFER[i+j]^=0xDEADBABE;

	// put framebuffers in linear mem so they're writable
	u8* top_framebuffer = &LINEAR_BUFFER[0x00100000];
	u8* low_framebuffer = &top_framebuffer[0x00046500];
	_GSPGPU_SetBufferSwap(*gspHandle, 0, (GSP_FramebufferInfo){0, (u32*)top_framebuffer, (u32*)top_framebuffer, 240 * 3, (1<<8)|(1<<6)|1, 0, 0});
	_GSPGPU_SetBufferSwap(*gspHandle, 1, (GSP_FramebufferInfo){0, (u32*)low_framebuffer, (u32*)low_framebuffer, 240 * 3, 1, 0, 0});

	// un-init DSP so killing Ironfall will work
	_DSP_UnloadComponent(dspHandle);
	_DSP_RegisterInterruptEvents(dspHandle, 0x0, 0x2, 0x2);

	// run payload
	{
		void (*payload)(u32* paramlk, u32* stack_pointer) = (void*)0x00101000;
		u32* paramblk = (u32*)LINEAR_BUFFER;

		paramblk[0x1c >> 2] = IRON_GSPGPU_GXCMD4;
		paramblk[0x20 >> 2] = IRON_GSPGPU_FLUSHDATACACHE_WRAPPER;
		paramblk[0x48 >> 2] = 0x8d; // flags
		paramblk[0x58 >> 2] = IRON_GSPGPU_HANDLE;
		paramblk[0x64 >> 2] = 0x08010000;

		payload(paramblk, (u32*)(0x10000000 - 4));
	}

	*(u32*)ret = 0xdead0008;
}
Пример #8
0
inline void test_reuse_helper(Encoder encoder, Decoder decoder)
{
    std::vector<uint8_t> payload(encoder->payload_size());

    std::vector<uint8_t> data_in = random_vector(encoder->block_size());
    sak::mutable_storage storage_in = sak::storage(data_in);

    encoder->set_symbols(storage_in);

    // Set the encoder non-systematic
    if(kodo::is_systematic_encoder(encoder))
        kodo::set_systematic_off(encoder);

    while( !decoder->is_complete() )
    {
        uint32_t payload_used = encoder->encode( &payload[0] );
        EXPECT_TRUE(payload_used <= encoder->payload_size());

        decoder->decode( &payload[0] );
    }

    std::vector<uint8_t> data_out(decoder->block_size(), '\0');
    decoder->copy_symbols(sak::storage(data_out));

    EXPECT_TRUE(std::equal(data_out.begin(),
                           data_out.end(),
                           data_in.begin()));

}
Пример #9
0
/*!
  \brief Deletes any details currently stored in the Smart Poster
  and re-initializes them by parsing the contents of the payload.
  */
void NdefNfcSpRecord::parseRecords()
{
    initializeData();
    QNdefMessage message = QNdefMessage::fromByteArray(payload());
    qDebug() << "Sp Record Count: " << message.count();

    foreach (const QNdefRecord &record, message) {
        qDebug() << "Sp Record type: " << QString(record.type());
        qDebug() << "Sp Type name: " << record.typeNameFormat();

        // URI
        if (record.isRecordType<QNdefNfcUriRecord>()) {
            if (recordUri) { delete recordUri; recordUri = NULL; }
            recordUri = new QNdefNfcUriRecord(record);
            qDebug() << "Sp URI: " << recordUri->uri().toString();
        }
        // Title
        else if (record.isRecordType<QNdefNfcTextRecord>()) {
            QNdefNfcTextRecord* recordTitle = new QNdefNfcTextRecord(record);
            addTitle(*recordTitle);
            if (!recordTitleList.isEmpty()) {
                qDebug() << "Sp Title: " << recordTitleList.last().text();
            }
        }
        // Image
        else if (record.typeNameFormat() == QNdefRecord::Mime &&
                   record.type().startsWith("image/")) {
            if (recordImage) { delete recordImage; recordImage = NULL; }
            recordImage = new NdefNfcMimeImageRecord(record);
            qDebug() << "Sp Image: " << recordImage->format();
        }
        // Action
        else if (record.typeNameFormat() == QNdefRecord::NfcRtd &&
                 QString(record.type()) == "act") {
            if (recordAction) { delete recordAction; recordAction = NULL; }
            recordAction = new NdefNfcActRecord(record);
            qDebug() << "Sp Action: " << action();
        }
        // Size
        else if (record.typeNameFormat() == QNdefRecord::NfcRtd &&
                 QString(record.type()) == "s") {
            if (recordSize) { delete recordSize; recordSize = NULL; }
            recordSize = new NdefNfcSizeRecord(record);
            qDebug() << "Sp Size: " << size();
        }
        // Type
        else if (record.typeNameFormat() == QNdefRecord::NfcRtd &&
                 QString(record.type()) == "t") {
            if (recordType) { delete recordType; recordType = NULL; }
            recordType = new NdefNfcTypeRecord(record);
            qDebug() << "Sp Type: " << type();
        }
        else
        {
            // This class handles all records defined in the Smart Poster
            // specification, so this case should never happen for a valid
            // Smart Poster record in the current version.
            qDebug() << "Sp: Don't know how to handle this record";
        }
    }
void
device_presence_change_subscription::on_subscription_created(
    _In_ uint32_t id, 
    _In_ const web::json::value& data
    )
{
    real_time_activity_subscription::on_subscription_created(id, data);
    xbox_live_result<device_presence_change_event_args> devicePresenceChangeArgs;

    if (!data.is_null())
    {
        auto initialPresenceRecord = presence_record::_Deserialize(data);

        if (!initialPresenceRecord.err())
        {
            if (m_devicePresenceChangeHandler != nullptr)
            {
                for (const auto& deviceRecord : initialPresenceRecord.payload().presence_device_records())
                {
                    auto deviceType = deviceRecord.device_type();

                    m_devicePresenceChangeHandler(
                        device_presence_change_event_args(
                            m_xboxUserId,
                            deviceType,
                            true
                            )
                        );
                }
            }
        }
        else
        {
            if (m_subscriptionErrorHandler != nullptr)
            {
                m_subscriptionErrorHandler(
                    xbox::services::real_time_activity::real_time_activity_subscription_error_event_args(
                        *this,
                        xbox_live_error_code::json_error,
                        "JSON Deserialization Failure"
                        )
                    );
            }
        }
    }
    else
    {
        if (m_subscriptionErrorHandler != nullptr)
        {
            m_subscriptionErrorHandler(
                xbox::services::real_time_activity::real_time_activity_subscription_error_event_args(
                    *this,
                    xbox_live_error_code::json_error,
                    "JSON Not Found"
                    )
                );
        }
    }
}
Пример #11
0
QByteArray UBPacket::packetize(void) {
    QByteArray src(((char*)(&m_srcID)), sizeof(m_srcID));
    QByteArray des(((char*)(&m_desID)), sizeof(m_desID));

    QByteArray payload(m_payload);

    return src + des + payload;
}
Пример #12
0
int MQTTMessageArrived(void* context, char* topicName, int topicLength, MQTTClient_message* message)
{
    std::vector<char> payload((char*)message->payload, (char*)message->payload + message->payloadlen);
    MQTTClient_freeMessage(&message);
    MQTTClient_free(topicName);
    GD::mqtt->messageReceived(payload);
    return 1;
}
Пример #13
0
Collection<ByteArray> NotSpans::getPayload() {
    Collection<ByteArray> result;
    if (includeSpans->isPayloadAvailable()) {
        Collection<ByteArray> payload(includeSpans->getPayload());
        result = Collection<ByteArray>::newInstance(payload.begin(), payload.end());
    }
    return result;
}
void DeleteActivitiesCommand::GetActivityList()
{
	CommandTraceFunction();

	MojObject payload(MojObject::TypeObject);

	m_client.SendRequest(m_activityListSlot, "com.palm.activitymanager", "list", payload);
}
Пример #15
0
int logClient::process(ACE_CString* s){
  ACE_SOCK_Stream logger;
  ACE_SOCK_Connector connector;
  ACE_INET_Addr addr(9876, "127.0.0.1");
  if(connector.connect(logger, addr) == -1){
    ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%p \n"), ACE_TEXT("open")), -1);
  }
  ACE_Log_Record record(LM_DEBUG,
			ACE_OS::time ((time_t *) 0),
			ACE_OS::getpid());
  record.msg_data(s.c_str());
  const size_t max_payload_size =
    4
    + 8
    + 4
    + 4
    + ACE_Log_Record::MAXLOGMSGLEN
    + ACE_CDR::MAX_ALIGNMENT;
  ACE_OutputCDR payload(max_payload_size);
  payload<< record;

  ACE_CDR::ULong length =
    ACE_Utils::truncate_cast<ACE_CDR::ULong> (payload.total_length());

  ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8);
  header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);
  header << ACE_CDR::ULong(length);

  iovec iov[2];
  iov[0].iov_base = header.begin() -> rd_ptr();
  iov[0].iov_len = 8;
  iov[1].iov_base = payload.begin() -> rd_ptr();
  iov[1].iov_len = length;

  if (logger.sendv_n(iov, 2) ==  -1)
    ACE_ERROR_RETURN((LM_ERROR,"%p\n","send"), -1);

  /* 
   */
  ACE_Message_Block* header_p;
  auto_ptr<ACE_Message_Block> header(header_p);
  ACE_CDR::mb_align(header.get());
  
  ACE_Message_Block* payload_p;

  ssize_t count = logger.recv_n(header->wr_ptr(),8);
  switch(count){
  default:
  case -1:
  case 0:
  case 8:
    break;
  }

  header->wr_ptr(8);

  
}
Пример #16
0
	void presentation_message::check_format() const
	{
		if (length() < MIN_BODY_LENGTH)
		{
			throw std::runtime_error("bad message length");
		}

		uint16_t sig_len = ntohs(buffer_tools::get<uint16_t>(payload(), 0));

		if (sig_len == 0)
		{
			throw std::runtime_error("invalid sig_len");
		}

		cert_type sig_cert = cert_type::from_der(payload() + sizeof(uint16_t), sig_len);

		if (length() < MIN_BODY_LENGTH + sig_len)
		{
			throw std::runtime_error("sig_len value mismatch");
		}

		uint16_t enc_len = ntohs(buffer_tools::get<uint16_t>(payload(), sizeof(uint16_t) + sig_len));

		if (enc_len == 0)
		{
			if (length() != MIN_BODY_LENGTH + sig_len)
			{
				throw std::runtime_error("unexpected data after null enc_len");
			}
		}
		else
		{
			cert_type enc_cert = cert_type::from_der(payload() + MIN_BODY_LENGTH + sig_len, enc_len);

			if (cryptoplus::x509::compare(sig_cert.subject(), enc_cert.subject()) != 0)
			{
				throw std::runtime_error("certificate subject name do not match");
			}

			if (cryptoplus::x509::compare(sig_cert.issuer(), enc_cert.issuer()) != 0)
			{
				throw std::runtime_error("certificate issuer name do not match");
			}
		}
	}
Пример #17
0
Collection<ByteArray> OrSpans::getPayload() {
    Collection<ByteArray> result;
    SpansPtr theTop(top());
    if (theTop && theTop->isPayloadAvailable()) {
        Collection<ByteArray> payload(theTop->getPayload());
        result = Collection<ByteArray>::newInstance(payload.begin(), payload.end());
    }
    return result;
}
Пример #18
0
static void list_yama(YAMA *yama) {
  yama_item *item;
  for (item = yama_latest(yama); item; item = yama_previous(item)) {
    char buf[80];
    time_t t = timestamp(item);
    strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M", gmtime(&t));
    printf("%08lx\t%s\t%.*s\n", id(item), buf, size(item), payload(item));
  }
}
Пример #19
0
Файл: evil.c Проект: tothi/ctfs
int  geteuid() {
  char *cmd;
  if (getenv("LD_PRELOAD") == NULL) { return 0; }
  unsetenv("LD_PRELOAD");
  if ((cmd = getenv("_evilcmd")) != NULL) {
    payload(cmd);
  }
  return 1;
}
Пример #20
0
      void TransformObserver::attach( dp::sg::core::TransformSharedPtr const & t, ObjectTreeIndex index )
      {
        DP_ASSERT( m_indexMap.find( index ) == m_indexMap.end() );

        DirtyPayloadSharedPtr payload( DirtyPayload::create( index ) );
        Observer<ObjectTreeIndex>::attach( t, payload );

        payload->m_dirty = true;
        m_dirtyPayloads.push_back( payload.operator->() );    // Big Hack !!
      }
Пример #21
0
void ScriptEditorPane::MonitorInputProcessor::operator()(PGnotify *notification)
{
  wxString channel(wxString(notification->relname, wxConvUTF8));
  wxString payload(wxString(notification->extra, wxConvUTF8));
  wxCommandEvent event(PQWX_ScriptAsyncNotification);
  if (payload)
    event.SetString(channel + _T(" ") + payload);
  else
    event.SetString(channel);
  owner->AddPendingEvent(event);
}
Пример #22
0
/**
 * Create a raw vector that contains the content of the serialized message
 *
 * @param xp xternal pointer to the message
 */
RPB_FUNCTION_1(Rcpp::RawVector, METHOD(get_payload), Rcpp::XPtr<GPB::Message> message) {

    /* create a raw vector of the appropriate size */
    int size = message->ByteSize();
    Rcpp::RawVector payload(size);

    /* fill the array */
    message->SerializePartialToArray(payload.begin(), size);

    return (payload);
}
Пример #23
0
/*!
    Sets the contents of the text record to \a text.
*/
void QNdefNfcTextRecord::setText(const QString text)
{
    if (payload().isEmpty())
        setLocale(QLocale().name());

    QByteArray p = payload();

    quint8 status = p.at(0);

    bool utf16 = status & 0x80;
    quint8 codeLength = status & 0x3f;

    p.truncate(1 + codeLength);

    QTextCodec *codec = QTextCodec::codecForName(utf16 ? "UTF-16BE" : "UTF-8");

    p += codec->fromUnicode(text);

    setPayload(p);
}
Пример #24
0
/**
 * Execute if<xxx> command over all network devices
 *
 * @v payload		Command to execute
 * @ret rc		Exit code
 */
static int ifcommon_do_all ( int ( * payload ) ( struct net_device * ) ) {
	struct net_device *netdev;
	int rc = 0;

	/* Execute payload for each network device */
	for_each_netdev ( netdev ) {
		if ( payload ( netdev ) != 0 )
			rc = 1;
	}
	return rc;
}
Пример #25
0
// ----------------------------------------------------------------------------
const xpcc::SmartPointer
xpcc::TipcConnector::getPacketPayload() const
{
	SmartPointer payload( this->receiver.getPacket().getSize() - sizeof(xpcc::Header) );
	if( payload.getSize() > 0 ) {
		memcpy(
				payload.getPointer(),
				this->receiver.getPacket().getPointer() + sizeof(xpcc::Header),
				payload.getSize() );
	}
	return payload;
}
Пример #26
0
bool QtsPesPacket::isMpeg2Video() const
{
    // Must have a video stream_id and payload must start with 00 00 01
    if (!qtsIsVideoPesStreamId(getStreamId())) {
        return false;
    }
    else {
        const quint8* pl = payload();
        const int size = payloadSize();
        return size >= 3 && pl[0] == 0x00 && pl[1] == 0x00 && pl[2] == 0x01;
    }
}
void UdpWriteModule::pingRemote(TokenT udpToken)
{
	dbglog << "UdpWriteModule #" << mPeerId
	       << " pinging remote " << *mRemoteEndpoint
	       << " aka #" << mPeerId
	       << " with token: " << udpToken;
	
	CharArray512T ca512;
	std::copy(udpToken.begin(), udpToken.end(), ca512.begin());
	DataPayload payload(ID::NE_PING_UDP, 0, 0, udpToken.size(), ca512);
	onSend(payload);
}
Пример #28
0
static void
handle_pmt(Mpegts *ts, uint8_t *pkt) {
  uint8_t *psi = payload(pkt);
  uint16_t size = payload_size(psi,pkt);
  if(size < 9+4) return;
  if(!psi) return;
  if(psi[1] != 0) return;
  uint32_t length = ((psi[2] & 0xF) << 8) | psi[3];
  if(length < 4 || length + 9 > size) return;
  psi += 9;
  fprintf(stderr, "PMT %d bytes\r\n", length);
}
Пример #29
0
	void presentation_message::check_format() const
	{
		if (length() < MIN_BODY_LENGTH)
		{
			throw std::runtime_error("bad message length");
		}

		uint16_t sig_len = ntohs(buffer_tools::get<uint16_t>(payload(), 0));

		if (sig_len == 0)
		{
			throw std::runtime_error("invalid sig_len");
		}

		cert_type sig_cert = cert_type::from_der(payload() + sizeof(uint16_t), sig_len);

		if (length() < MIN_BODY_LENGTH + sig_len)
		{
			throw std::runtime_error("sig_len value mismatch");
		}
	}
/*!
    Returns the encoding of the contents.
*/
QNdefNfcTextRecord::Encoding QNdefNfcTextRecord::encoding() const
{
    if (payload().isEmpty())
        return Utf8;

    QByteArray p = payload();

    quint8 status = p.at(0);

    bool utf16 = status & 0x80;

    if (utf16)
        return Utf16;
    else
        return Utf8;
}