int Policy::nodeToByteString(int father, Node* node, ByteString& bytes){ if(node == NULL){ return 0; } //find a node this->nodeIndex += 1; int sonFather = this->nodeIndex; int size = 0; //append father position unsigned char buf[4]; Utility::int2str(buf, father); bytes.append(buf, 4); size += 4; //length of bytes of node, -1 represents internal node, -2 represents leaf, >0 represents the real length of exLeaf int node_len = -1; if(node->getType() == LEAF){ node_len = -2; //// printf("leaf node"); } else if (node->getType() == EXTENDED_LEAF){ ExLeaf* tempNode = (ExLeaf*)node; node_len = tempNode->getLength(); // printf("exLeaf node"); } //append len info Utility::int2str(buf, node_len); bytes.append(buf, 4); size += 4; //append node itself info size += node->toByteString(bytes); // printf("\tnode size: %d\n", size); //handle sons of node if(node->getSonNum() > 0){ int i = 0; Node** sons = node->getSons(); for(i = 0; i < node->getSonNum(); i++){ size += nodeToByteString(sonFather, sons[i], bytes); } } return size; }
int CipherText::toByteString(ByteString& bytes){ int begin = bytes.getLength(); unsigned char* buf = (unsigned char*)malloc(sizeof(unsigned char) * ELEMENT_LENGTH); element_to_bytes(buf, this->c1); bytes.append(buf, ELEMENT_LENGTH); element_to_bytes(buf, this->c0); bytes.append(buf, ELEMENT_LENGTH); free(buf); this->policy->toByteString(bytes); int end = bytes.getLength(); return end - begin; }
int Policy::toByteString(ByteString& bytes){ this->nodeIndex = -1; unsigned char buf[4]; Utility::int2str(buf, this->nodeNum); bytes.append(buf, 4); return 4 + nodeToByteString(-1, this->root, bytes); }
/** * Send a RDM request to the widget */ bool RobeWidgetImpl::PackAndSendRDMRequest(uint8_t label, const RDMRequest *request) { ByteString frame; if (!RDMCommandSerializer::Pack(*request, &frame)) { return false; } frame.append(RDM_PADDING_BYTES, 0); return SendMessage(label, frame.data(), frame.size()); }
/** * Send a RDM Message */ void RobeWidgetImpl::SendRDMRequest(RDMRequest *request_ptr, ola::rdm::RDMCallback *on_complete) { auto_ptr<RDMRequest> request(request_ptr); if (m_rdm_request_callback) { OLA_FATAL << "Previous request hasn't completed yet, dropping request"; RunRDMCallback(on_complete, ola::rdm::RDM_FAILED_TO_SEND); return; } // prepare the buffer for the RDM data, we don't need to include the start // code. We need to include 4 bytes at the end, these bytes can be any value. ByteString data; unsigned int this_transaction_number = m_transaction_number++; unsigned int port_id = 1; request->SetSourceUID(m_uid); request->SetTransactionNumber(this_transaction_number); request->SetPortId(port_id); if (!RDMCommandSerializer::Pack(*request, &data)) { OLA_WARN << "Failed to pack message, dropping request"; RunRDMCallback(on_complete, ola::rdm::RDM_FAILED_TO_SEND); return; } // Append the extra padding bytes, which can be set to any value. data.append(RDM_PADDING_BYTES, 0); OLA_DEBUG << "Sending RDM command. CC: " << strings::ToHex(request->CommandClass()) << ", PID " << strings::ToHex(request->ParamId()) << ", TN: " << this_transaction_number; m_rdm_request_callback = on_complete; m_pending_request.reset(request.release()); const uint8_t label = m_pending_request->IsDUB() ? RDM_DISCOVERY : RDM_REQUEST; bool sent_ok = SendMessage(label, data.data(), data.size()); if (!sent_ok) { m_rdm_request_callback = NULL; m_pending_request.reset(); RunRDMCallback(on_complete, ola::rdm::RDM_FAILED_TO_SEND); } }
static bool ReadInterfaces() { ByteString buffer; if (FileSystem::FileExists(INTERFACE_VERSION_FILE)) { FileSystem::ReadFile(INTERFACE_VERSION_FILE, buffer); } else { std::string data = WebIO("Redacted").Get(hString::va("https://momo5502.com/SteamAPI/?app=%d", Global::Steam_AppID)); buffer.append(data.begin(), data.end()); FileSystem::WriteFile(INTERFACE_VERSION_FILE, buffer, false); } Json::Reader reader; Json::Value root; if (reader.parse(std::string(buffer.begin(), buffer.end()), root) && root.type() == Json::objectValue) { PARSEINTERFACE(root, _SteamApps, "Apps", INTERFACE_STEAMAPPS001) PARSEINTERFACE(root, _SteamClient, "Client", INTERFACE_STEAMCLIENT001) PARSEINTERFACE(root, _SteamContentServer, "ContentServer", INTERFACE_STEAMCONTENTSERVER001) // PARSEINTERFACE(root, _SteamController, "Controller", INTERFACE_STEAMCONTROLLER001) PARSEINTERFACE(root, _SteamFriends, "Friends", INTERFACE_STEAMFRIENDS001) PARSEINTERFACE(root, _SteamGameServer, "GameServer", INTERFACE_STEAMGAMESERVER001) PARSEINTERFACE(root, _SteamGameServerStats, "GameServerStats", INTERFACE_STEAMGAMESERVER001) PARSEINTERFACE(root, _SteamHTTP, "HTTP", INTERFACE_STEAMHTTP001) PARSEINTERFACE(root, _SteamMasterServerUpdater, "MasterServerUpdater", INTERFACE_STEAMMASTERUPDATER001) PARSEINTERFACE(root, _SteamMatchMaking, "MatchMaking", INTERFACE_STEAMMATCHMAKING001) PARSEINTERFACE(root, _SteamMatchMakingServers, "MatchMakingServers", INTERFACE_STEAMMATCHMAKINGSERVERS001) PARSEINTERFACE(root, _SteamMusic, "Music", INTERFACE_STEAMMUSIC001) // PARSEINTERFACE(root, _SteamMusicRemote, "MusicRemote", INTERFACE_STEAMMUSICREMOTE001) PARSEINTERFACE(root, _SteamNetworking, "Networking", INTERFACE_STEAMNETWORKING001) PARSEINTERFACE(root, _SteamRemoteStorage, "RemoteStorage", INTERFACE_STEAMREMOTESTORAGE001) PARSEINTERFACE(root, _SteamScreenshots, "Screenshots", INTERFACE_STEAMSCREENSHOTS001) PARSEINTERFACE(root, _SteamUnifiedMessages, "UnifiedMessages", INTERFACE_STEAMUNIFIEDMESSAGES001) PARSEINTERFACE(root, _SteamUser, "User", INTERFACE_STEAMUSER001) PARSEINTERFACE(root, _SteamUserStats, "UserStats", INTERFACE_STEAMUSERSTATS001) PARSEINTERFACE(root, _SteamUtils, "Utils", INTERFACE_STEAMUTILS001) PARSEINTERFACE(root, _SteamUGC, "UGC", INTERFACE_STEAMUGC001) return true; }
bool FileSystem::ReadFile(const char *Filename, ByteString &DataBuffer) { // Waste of time. if (!FileExists(Filename)) return false; bool Result = false; uint32_t ReadSize = GetFileSize(Filename); uint8_t *ReadBuffer = new uint8_t[ReadSize]; SecureZeroMemory(ReadBuffer, ReadSize); // Read the file. Result = ReadFile(Filename, ReadBuffer, ReadSize); // Append the data. DataBuffer.append(ReadBuffer, ReadSize); // Clear the buffer. SecureZeroMemory(ReadBuffer, ReadSize); delete[] ReadBuffer; return Result; }