//////////////////////////////////////////////////////////////////////////////////// /// /// \brief Test method to verify ability to read/write message data from /// an example wireshark log provided for testing systems for the JAUS /// Interoperability Challenge hosted at several AUVSI competitions. /// //////////////////////////////////////////////////////////////////////////////////// void VerifyAgainstLog() { Packet::List packets; Packet::List::iterator packet; Component component; component.DiscoveryService()->SetSubsystemIdentification(Subsystem::OCU, "OCP"); component.AddService(new LocalPoseSensor()); component.AddService(new VelocityStateSensor()); component.AddService(new ListManager()); component.AddService(new TestLocalWaypointListDriver()); Packet::LoadWiresharkCapturePacketExport("logs/example-capture.txt", packets); Address cop(42, 1, 1); Address sim(6000, 1, 1); //Packet::LoadWiresharkCapturePacketExport("logs/example_capture-2.txt", packets); Message::List messages; Message::List::iterator message; // Delete UDP header data to get to just the JAUS message. for(packet = packets.begin(); packet != packets.end();) { // Delete UDP header data. packet->Delete(43); // Read message header data. Header jausHeader; if(jausHeader.Read(*packet)) { UShort messageCode = 0; packet->Read(messageCode, Header::PayloadOffset); Message* jausMessage = component.TransportService()->CreateMessage(messageCode); if(jausMessage) { packet->SetReadPos(0); if(jausMessage->Read(*packet)) { messages.push_back(jausMessage); if(jausMessage->GetMessageCode() == SET_ELEMENT) { Element::List::iterator m; SetElement* setElement = (SetElement *)jausMessage; for(m = setElement->GetElementList()->begin(); m != setElement->GetElementList()->end(); m++) { UShort code = 0; m->mPayload.SetReadPos(0); m->mPayload.Read(code); Message* element = component.TransportService()->CreateMessage(code); if(element) { element->CopyHeaderData(jausMessage); if(element->ReadMessageBody(m->mPayload)) { messages.push_back(element); } else { std::cout << "Failed to Read Message Data [" << std::hex << element->GetMessageCode() << "]:\n"; delete element; } } } } } else { std::cout << "Failed to Read Message Data [" << std::hex << jausMessage->GetMessageCode() << "]:\n"; } } else { std::cout << "Unknown Message Type [" << std::hex << messageCode << "]:\n"; } } else { std::cout << "Bad Header!\n"; } packet++; } component.Initialize(cop); message = messages.begin(); for(message = messages.begin(); message != messages.end(); message++) { //(*message)->Print(); if((*message)->GetSourceID() == cop) { (*message)->SetDestinationID(sim); component.Send((*message)); } CxUtils::SleepMs(1); delete (*message); } }
void FourSectionDictionary::populateHeader(Header & header, string rootNode) { header.insert(rootNode, HDTVocabulary::DICTIONARY_TYPE, getType()); #if 0 header.insert(rootNode, HDTVocabulary::DICTIONARY_NUMSUBJECTS, getNsubjects()); header.insert(rootNode, HDTVocabulary::DICTIONARY_NUMPREDICATES, getNpredicates()); header.insert(rootNode, HDTVocabulary::DICTIONARY_NUMOBJECTS, getNobjects()); header.insert(rootNode, HDTVocabulary::DICTIONARY_MAXSUBJECTID, getMaxSubjectID()); header.insert(rootNode, HDTVocabulary::DICTIONARY_MAXPREDICATEID, getMaxPredicateID()); header.insert(rootNode, HDTVocabulary::DICTIONARY_MAXOBJECTTID, getMaxObjectID()); #endif header.insert(rootNode, HDTVocabulary::DICTIONARY_NUMSHARED, getNshared()); header.insert(rootNode, HDTVocabulary::DICTIONARY_MAPPING, this->mapping); header.insert(rootNode, HDTVocabulary::DICTIONARY_SIZE_STRINGS, size()); header.insert(rootNode, HDTVocabulary::DICTIONARY_BLOCK_SIZE, this->blocksize); }
Eigen::MatrixXd get_DW_scheme (const Header& header) { DEBUG ("searching for suitable gradient encoding..."); using namespace App; Eigen::MatrixXd grad; try { const auto opt_mrtrix = get_options ("grad"); if (opt_mrtrix.size()) grad = load_matrix<> (opt_mrtrix[0][0]); const auto opt_fsl = get_options ("fslgrad"); if (opt_fsl.size()) { if (opt_mrtrix.size()) throw Exception ("Please provide diffusion gradient table using either -grad or -fslgrad option (not both)"); grad = load_bvecs_bvals (header, opt_fsl[0][0], opt_fsl[0][1]); } if (!opt_mrtrix.size() && !opt_fsl.size()) grad = parse_DW_scheme (header); } catch (Exception& e) { throw Exception (e, "error importing diffusion gradient table for image \"" + header.name() + "\""); } if (!grad.rows()) return grad; if (grad.cols() < 4) throw Exception ("unexpected diffusion gradient table matrix dimensions"); INFO ("found " + str (grad.rows()) + "x" + str (grad.cols()) + " diffusion gradient table"); return grad; }
void Client::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { Header responseHeader; Header requestHeader; RequestMetadata requestMetadata; Message *message = NULL; ThreadError error; SuccessOrExit(error = responseHeader.FromMessage(aMessage)); aMessage.MoveOffset(responseHeader.GetLength()); message = FindRelatedRequest(responseHeader, aMessageInfo, requestHeader, requestMetadata); if (message == NULL) { ExitNow(); } switch (responseHeader.GetType()) { case kCoapTypeReset: if (responseHeader.IsEmpty()) { FinalizeCoapTransaction(*message, requestMetadata, NULL, NULL, kThreadError_Abort); } // Silently ignore non-empty reset messages (RFC 7252, p. 4.2). break; case kCoapTypeAcknowledgment: if (responseHeader.IsEmpty()) { // Empty acknowledgment. if (requestMetadata.mConfirmable) { requestMetadata.mAcknowledged = true; requestMetadata.UpdateIn(*message); } // Remove the message if response is not expected, otherwise await response. if (requestMetadata.mResponseHandler == NULL) { DequeueMessage(*message); } } else if (responseHeader.IsResponse() && responseHeader.IsTokenEqual(requestHeader)) { // Piggybacked response. FinalizeCoapTransaction(*message, requestMetadata, &responseHeader, &aMessage, kThreadError_None); } // Silently ignore acknowledgments carrying requests (RFC 7252, p. 4.2) // or with no token match (RFC 7252, p. 5.3.2) break; case kCoapTypeConfirmable: case kCoapTypeNonConfirmable: if (responseHeader.IsConfirmable()) { // Send empty ACK if it is a CON message. SendEmptyAck(aMessageInfo.GetPeerAddr(), aMessageInfo.mPeerPort, responseHeader.GetMessageId()); } FinalizeCoapTransaction(*message, requestMetadata, &responseHeader, &aMessage, kThreadError_None); break; } exit: if (error == kThreadError_None && message == NULL) { if (responseHeader.IsConfirmable() || responseHeader.IsNonConfirmable()) { // Successfully parsed a header but no matching request was found - reject the message by sending reset. SendReset(aMessageInfo.GetPeerAddr(), aMessageInfo.mPeerPort, responseHeader.GetMessageId()); } } }
Eigen::MatrixXd parse_scheme (const Header& header) { Eigen::MatrixXd PE; const auto it = header.keyval().find ("pe_scheme"); if (it != header.keyval().end()) { try { PE = parse_matrix (it->second); } catch (Exception& e) { throw Exception (e, "malformed PE scheme in image \"" + header.name() + "\""); } if (ssize_t(PE.rows()) != ((header.ndim() > 3) ? header.size(3) : 1)) throw Exception ("malformed PE scheme in image \"" + header.name() + "\" - number of rows does not equal number of volumes"); } else { // Header entries are cast to lowercase at some point const auto it_dir = header.keyval().find ("PhaseEncodingDirection"); const auto it_time = header.keyval().find ("TotalReadoutTime"); if (it_dir != header.keyval().end() && it_time != header.keyval().end()) { Eigen::Matrix<default_type, 4, 1> row; row.head<3>() = Axes::id2dir (it_dir->second); row[3] = to<default_type>(it_time->second); PE.resize ((header.ndim() > 3) ? header.size(3) : 1, 4); PE.rowwise() = row.transpose(); } } return PE; }
void MultiPartInputFile::initialize() { readMagicNumberAndVersionField(*_data->is, _data->version); bool multipart = isMultiPart(_data->version); bool tiled = isTiled(_data->version); // // Multipart files don't have and shouldn't have the tiled bit set. // if (tiled && multipart) throw IEX_NAMESPACE::InputExc ("Multipart files cannot have the tiled bit set"); int pos = 0; while (true) { Header header; header.readFrom(*_data->is, _data->version); // // If we read nothing then we stop reading. // if (header.readsNothing()) { pos++; break; } _data->_headers.push_back(header); if(multipart == false) break; } // // Perform usual check on headers. // for (size_t i = 0; i < _data->_headers.size(); i++) { // // Silently invent a type if the file is a single part regular image. // if( _data->_headers[i].hasType() == false ) { if(multipart) throw IEX_NAMESPACE::ArgExc ("Every header in a multipart file should have a type"); _data->_headers[i].setType(tiled ? TILEDIMAGE : SCANLINEIMAGE); } else { // // Silently fix the header type if it's wrong // (happens when a regular Image file written by EXR_2.0 is rewritten by an older library, // so doesn't effect deep image types) // if(!multipart && !isNonImage(_data->version)) { _data->_headers[i].setType(tiled ? TILEDIMAGE : SCANLINEIMAGE); } } if( _data->_headers[i].hasName() == false ) { if(multipart) throw IEX_NAMESPACE::ArgExc ("Every header in a multipart file should have a name"); } if (isTiled(_data->_headers[i].type())) _data->_headers[i].sanityCheck(true, multipart); else _data->_headers[i].sanityCheck(false, multipart); } // // Check name uniqueness. // if (multipart) { set<string> names; for (size_t i = 0; i < _data->_headers.size(); i++) { if (names.find(_data->_headers[i].name()) != names.end()) { throw IEX_NAMESPACE::InputExc ("Header name " + _data->_headers[i].name() + " is not a unique name."); } names.insert(_data->_headers[i].name()); } } // // Check shared attributes compliance. // if (multipart && strictSharedAttribute) { for (size_t i = 1; i < _data->_headers.size(); i++) { vector <string> attrs; if (_data->checkSharedAttributesValues (_data->_headers[0], _data->_headers[i], attrs)) { string attrNames; for (size_t j=0; j<attrs.size(); j++) attrNames += " " + attrs[j]; throw IEX_NAMESPACE::InputExc ("Header name " + _data->_headers[i].name() + " has non-conforming shared attributes: "+ attrNames); } } } // // Create InputParts and read chunk offset tables. // for (size_t i = 0; i < _data->_headers.size(); i++) _data->parts.push_back( new InputPartData(_data, _data->_headers[i], i, _data->numThreads, _data->version)); _data->readChunkOffsetTables(_data->reconstructChunkOffsetTable); }
oc::result<void> AndroidFormatWriter::write_header(File &file, const Header &header) { // Construct header m_hdr = {}; memcpy(m_hdr.magic, BOOT_MAGIC, BOOT_MAGIC_SIZE); if (auto address = header.kernel_address()) { m_hdr.kernel_addr = *address; } if (auto address = header.ramdisk_address()) { m_hdr.ramdisk_addr = *address; } if (auto address = header.secondboot_address()) { m_hdr.second_addr = *address; } if (auto address = header.kernel_tags_address()) { m_hdr.tags_addr = *address; } if (auto page_size = header.page_size()) { switch (*page_size) { case 2048: case 4096: case 8192: case 16384: case 32768: case 65536: case 131072: m_hdr.page_size = *page_size; break; default: //DEBUG("Invalid page size: %" PRIu32, *page_size); return AndroidError::InvalidPageSize; } } else { return AndroidError::MissingPageSize; } if (auto board_name = header.board_name()) { if (board_name->size() >= sizeof(m_hdr.name)) { return AndroidError::BoardNameTooLong; } strncpy(reinterpret_cast<char *>(m_hdr.name), board_name->c_str(), sizeof(m_hdr.name) - 1); m_hdr.name[sizeof(m_hdr.name) - 1] = '\0'; } if (auto cmdline = header.kernel_cmdline()) { if (cmdline->size() >= sizeof(m_hdr.cmdline)) { return AndroidError::KernelCmdlineTooLong; } strncpy(reinterpret_cast<char *>(m_hdr.cmdline), cmdline->c_str(), sizeof(m_hdr.cmdline) - 1); m_hdr.cmdline[sizeof(m_hdr.cmdline) - 1] = '\0'; } // TODO: UNUSED // TODO: ID std::vector<SegmentWriterEntry> entries; entries.push_back({ ENTRY_TYPE_KERNEL, 0, {}, m_hdr.page_size }); entries.push_back({ ENTRY_TYPE_RAMDISK, 0, {}, m_hdr.page_size }); entries.push_back({ ENTRY_TYPE_SECONDBOOT, 0, {}, m_hdr.page_size }); entries.push_back({ ENTRY_TYPE_DEVICE_TREE, 0, {}, m_hdr.page_size }); OUTCOME_TRYV(m_seg->set_entries(std::move(entries))); // Start writing after first page auto seek_ret = file.seek(m_hdr.page_size, SEEK_SET); if (!seek_ret) { if (file.is_fatal()) { m_writer.set_fatal(); } return seek_ret.as_failure(); } return oc::success(); }
int main(int argc, char** argv) { (void) argc; (void) argv; signal(SIGCHLD, SIG_IGN); int iSocket = socket(AF_INET, SOCK_STREAM, 0); if (iSocket < 0) { fprintf(stderr, "socket failed %d, errno %d\n", iSocket, errno); return 0; } struct sockaddr_in servAddr, cliAddr; socklen_t iCliLen = sizeof(cliAddr); memset(&servAddr, 0, sizeof(servAddr)); servAddr.sin_family = AF_INET; servAddr.sin_addr.s_addr = inet_addr(*(argv + 1)); servAddr.sin_port = htons(atoi(*(argv + 2))); int option = 1; setsockopt(iSocket, SOL_SOCKET, SO_REUSEADDR, (const void *)&option, sizeof(option)); bind(iSocket, (struct sockaddr *)&servAddr, sizeof(servAddr)); listen(iSocket, 512); while(1) { int iCliFd; iCliFd = accept(iSocket, (struct sockaddr *)&cliAddr, &iCliLen); if (iCliFd < 0) { fprintf(stderr, "accept failed %d, errno %d\n", iCliFd, errno); return 0; } pid_t pid = fork(); if (pid == 0) { #define USERID 1 char sBuf[10240]; ssize_t size; uint64_t iMsgId = 1ull; Encoder encoder(sBuf, sizeof(sBuf)); Decoder decoder; { ConnSvrConnectChallenge req; char sRandomStr[256]; memset(sRandomStr, 'z', sizeof(sRandomStr)); req.set_random_msg(sRandomStr, 256); Header header; header.set_type(kMsgTypeConnSvrConnectChallenge); header.set_msg_id(iMsgId++); encoder.EncodeHeader(header); encoder.Encode(req); size = send(iCliFd, encoder.Data(), encoder.DataLen(), 0); printf("send %ld\n", size); } { Header header; size = recv(iCliFd, sBuf, sizeof(sBuf), 0); decoder.DecodeHeader(sBuf, size, &header); ConnSvrConnectReq resp; decoder.DecodePayload(&resp); unsigned char sUserAgentBuf[1024]; UserAgent userAgent; if (resp.has_user_agent()) { const std::string &sUserAgent = resp.user_agent(); memcpy(sUserAgentBuf, sUserAgent.c_str(), sUserAgent.size()); if (sUserAgent.size()) { unsigned char inputKey = sUserAgentBuf[0]; unsigned char outputKey; for(int i = 1, n = sUserAgent.size(); i != n; i++) { outputKey = sUserAgentBuf[i]; sUserAgentBuf[i] ^= inputKey; inputKey = outputKey; } } userAgent.ParseFromArray(sUserAgentBuf + 1, sUserAgent.size() - 1); } printf("type %d, msgid %lu, phonenum %s, role %d, secretchap %s, ostype %s, osver %s, model %s, clientver %s, network %s, location %s operator %s\n", header.type(), header.has_msg_id() ? header.msg_id() : 0, resp.phone_num().c_str(), resp.role(), resp.secret_chap().c_str(), userAgent.has_os_type() ? userAgent.os_type().c_str() : "", userAgent.has_os_ver() ? userAgent.os_ver().c_str() : "", userAgent.has_model() ? userAgent.model().c_str() : "", userAgent.has_client_ver() ? userAgent.client_ver().c_str() : "", userAgent.has_network() ? userAgent.network().c_str() : "", userAgent.has_location() ? userAgent.location().c_str() : "", userAgent.has_carrier_operator() ? userAgent.carrier_operator().c_str() : ""); } { ConnSvrConnectRsp req; RspMsg* pRspMsg = req.mutable_rsp_msg(); pRspMsg->set_rsp_code(0); pRspMsg->set_rsp_msg("OK"); Header header; header.set_type(kMsgTypeConnSvrConnectRsp); header.set_msg_id(iMsgId++); encoder.EncodeHeader(header); encoder.Encode(req); size = send(iCliFd, encoder.Data(), encoder.DataLen(), 0); printf("send %ld\n", size); } int number = 0; while(number < 100) { size = recv(iCliFd, sBuf, sizeof(sBuf), 0); if (size == 0) { break; } Header header; decoder.DecodeHeader(sBuf, size, &header); printf("type %d, msgid %lu, ", header.type(), header.has_msg_id() ? header.msg_id() : 0); if (header.type() == kMsgTypeConnSvrHeartbeatReq) { ConnSvrHeartbeatReq resp; decoder.DecodePayload(&resp); printf("heartbeat\n"); } else if (header.type() == kMsgTypeCdntSvrUpReq) { Coordinate resp; decoder.DecodePayload(&resp); printf("x %lf, y %lf, coordinatetype %d\n", resp.x(), resp.y(), resp.type()); } else if (header.type() == kMsgTypeDispatchSvrNoRspReq) { BinaryMsg req; decoder.DecodePayload(&req); if (req.type() == kDispatchMessageTypeDriverOrderGetReq) { DriverOrderGetReq getReq; getReq.ParseFromArray(req.payload().data(), req.payload().size()); const DriverOrderGetReq::LastStatus &lastStatus = getReq.laststatus(); printf("type %d, phone %s, token %s, oid %s, down %d, play %d, cancel %d\n", req.type(), getReq.phone().c_str(), getReq.token().c_str(), lastStatus.oid().c_str(), lastStatus.down(), lastStatus.play(), lastStatus.cancel()); } } else { printf("unkown type %d\n", header.type()); } number++; if (number == 4) { ConnSvrHeartbeatReq req; Header header; header.set_type(kMsgTypeConnSvrHeartbeatReq); header.set_msg_id(iMsgId++); encoder.EncodeHeader(header); encoder.Encode(req); size = send(iCliFd, encoder.Data(), encoder.DataLen(), 0); printf("send %ld\n", size); } /* else if (number == 7) { CdntSvrDownReq req; Header header; header.set_type(kMsgTypeCdntSvrDownReq); header.set_msg_id(iMsgId++); { PeerCoordinateInfo* pPeerCoordinateInfo = req.add_peer_coordinate_infos(); Coordinate* pCoordinate = pPeerCoordinateInfo->mutable_coordinate(); pCoordinate->set_x(1.0f); pCoordinate->set_y(1.0f); pCoordinate->set_type(DidiPush::BD_09); pPeerCoordinateInfo->set_distance(10); pPeerCoordinateInfo->set_wait_time(10); pPeerCoordinateInfo->set_local_id("aslkdjflajk"); } { PeerCoordinateInfo* pPeerCoordinateInfo = req.add_peer_coordinate_infos(); Coordinate* pCoordinate = pPeerCoordinateInfo->mutable_coordinate(); pCoordinate->set_x(2.0f); pCoordinate->set_y(2.0f); pCoordinate->set_type(DidiPush::BD_09); pPeerCoordinateInfo->set_distance(20); pPeerCoordinateInfo->set_wait_time(20); pPeerCoordinateInfo->set_local_id("lkjlkjlkj"); } encoder.EncodeHeader(header); encoder.Encode(req); size = send(iCliFd, encoder.Data(), encoder.DataLen(), 0); printf("send %ld\n", size); } else if (number == 9) { Header header; header.set_type(kMsgTypeConnSvrDisconnectReq); header.set_msg_id(iMsgId++); ConnSvrDisconnectReq req; encoder.EncodeHeader(header); encoder.Encode(req); size = send(iCliFd, encoder.Data(), encoder.DataLen(), 0); printf("send %ld\n", size); } else if (number == 4) { BinaryMsg msg; msg.set_type(kPushMessageTypeDriverOrderStrivedReq); char sBuf[10240]; DriverOrderStrivedReq req; req.set_oid("asldkjfa"); req.set_dinfo("alskjdflakj"); req.set_msg("msg"); req.set_showtype(DriverMessageTipShowTypeWindow); req.SerializeToArray(sBuf, req.ByteSize()); msg.set_payload(sBuf, req.ByteSize()); msg.SerializeToArray(sBuf, msg.ByteSize()); Header header; header.set_type(kMsgTypeAppPushMessageReq); header.set_msg_id(iMsgId++); encoder.EncodeHeader(header); encoder.Encode(msg); size = send(iCliFd, encoder.Data(), encoder.DataLen(), 0); printf("send %ld\n", size); } */ } close(iCliFd); return 0; } else if (pid > 0) { close(iCliFd); } else { fprintf(stderr, "Fork failed\n"); } } return 0; }
std::shared_ptr<Handler::Base> MRtrix_sparse::create (Header& H) const { Header::const_iterator name_it = H.find (Image::Sparse::name_key); if (name_it == H.end()) throw Exception ("Cannot create sparse image " + H.name() + "; no knowledge of underlying data class type"); Header::const_iterator size_it = H.find (Image::Sparse::size_key); if (size_it == H.end()) throw Exception ("Cannot create sparse image " + H.name() + "; no knowledge of underlying data class size"); H.datatype() = DataType::UInt64; H.datatype().set_byte_order_native(); File::OFStream out (H.name(), std::ios::out | std::ios::binary); out << "mrtrix sparse image\n"; write_mrtrix_header (H, out); bool single_file = Path::has_suffix (H.name(), ".msf"); int64_t image_offset = 0, sparse_offset = 0; std::string image_path, sparse_path; if (single_file) { image_offset = out.tellp() + int64_t(54); image_offset += ((4 - (image_offset % 4)) % 4); sparse_offset = image_offset + Image::footprint(H); out << "file: . " << image_offset << "\nsparse_file: . " << sparse_offset << "\nEND\n"; File::resize (H.name(), sparse_offset); image_path = H.name(); sparse_path = H.name(); } else { image_path = Path::basename (H.name().substr (0, H.name().size()-4) + ".dat"); sparse_path = Path::basename (H.name().substr (0, H.name().size()-4) + ".sdat"); out << "file: " << image_path << "\nsparse_file: " << sparse_path << "\nEND\n"; File::create (image_path, Image::footprint(H)); File::create (sparse_path); } Handler::Default base_handler (H); base_handler.files.push_back (File::Entry (image_path, image_offset)); std::shared_ptr<Handler::Base> handler (new Handler::Sparse (base_handler, name_it->second, to<size_t>(size_it->second), File::Entry (sparse_path, sparse_offset))); return handler; }
int Control::process(Header &header) { size_ = header.payload_size() + 2; Utilities::Utf8::Byte utf8; uint8_t mask_offset = 0; uint8_t *buffer = &(*buffer_.get())[0]; buffer[0] = header.begin()[0]; buffer[1] = header.begin()[1]; Utilities::Print::hex(&buffer[0],header.payload_size()+2); std::cout << std::endl; if( (buffer[0] & 0x0F) == 0x08) { if(header.payload_size() >= 2) { Utilities::Websocket::applyMask(&buffer[2] , 2 , &header.mask(), mask_offset , false , utf8); Utilities::Websocket::applyMask(&buffer[4] , header.payload_size() -2 , &header.mask(), mask_offset , true , utf8); if(!utf8.complete()) { std::cout << "invalid utf in control" << std::endl; return 1007; } } state_ = ControlState::KILL; std::cout << "control kill" << std::endl; buffer[1] &= 0x7F; uint16_t code = buffer[2] << 8 | buffer[3] << 0; if( code < 1000 ||(code < 3000 && code != 1000 && code != 1001 && code != 1002 && code != 1003 && code != 1007 && code != 1008 && code != 1009 && code != 1010 && code != 1011) || code > 4999 ) { buffer[2] = 0x03; buffer[3] = 0xEA; } } else if ( (buffer[0] & 0x0F) == 0x09 ) { Utilities::Websocket::applyMask(&buffer[2] , header.payload_size() , &header.mask(), mask_offset , false , utf8); if(!utf8.complete()) { std::cout << "invalid utf in control" << std::endl; return 1007; } state_ = ControlState::PING; buffer[0] = ( buffer[0] & 0xF0 ) | 0x0A; buffer[1] &= 0x7F; std::cout << "control pong"; Utilities::Print::hex(&buffer[0],2);std::cout <<std::endl; } else if ( (buffer[0] & 0x0F) == 0x0A ) { state_ = ControlState::PONG; std::cout << "pong recieved" << std::endl; } else { state_ = ControlState::INVALID; } return 0; }
result EventListForm::OnInitializing(void) { result r = E_SUCCESS; Header* pHeader = GetHeader(); AppAssert(pHeader); DateTime today; String formattedString; SystemTime::GetCurrentTime(WALL_TIME, today); __pLocaleCalendar = Tizen::Locales::Calendar::CreateInstanceN(CALENDAR_GREGORIAN); __pLocaleCalendar->SetTime(today); DateTimeFormatter* pDateFormatter = DateTimeFormatter::CreateDateFormatterN(DATE_TIME_STYLE_DEFAULT); String customizedPattern = L"dd MMM yyyy"; pDateFormatter->ApplyPattern(customizedPattern); pDateFormatter->Format(*__pLocaleCalendar, formattedString); HeaderItem headerDaily; headerDaily.Construct(ID_HEADER_DAILY); headerDaily.SetText(L"일"); HeaderItem headerMonthly; headerMonthly.Construct(ID_HEADER_MONTHLY); headerMonthly.SetText(L"월"); pHeader->SetStyle(HEADER_STYLE_SEGMENTED_WITH_TITLE); pHeader->SetTitleText(formattedString); pHeader->AddItem(headerDaily); pHeader->AddItem(headerMonthly); pHeader->AddActionEventListener(*this); Footer* pFooter = GetFooter(); AppAssert(pFooter); pFooter->SetStyle(FOOTER_STYLE_BUTTON_TEXT); FooterItem footerCreate; footerCreate.Construct(ID_FOOTER_CREATE); footerCreate.SetText(L"일정 생성"); pFooter->AddItem(footerCreate); SetFormBackEventListener(this); pFooter->AddActionEventListener(*this); Tizen::Ui::Controls::Button* pPreviousButton = new (std::nothrow) Button(); pPreviousButton->Construct(Rectangle(0, 0, GetClientAreaBounds().width / 2, 72), L"이전"); pPreviousButton->SetActionId(ID_BUTTON_PREV); pPreviousButton->AddActionEventListener(*this); AddControl(pPreviousButton); Tizen::Ui::Controls::Button* pNextButton = new (std::nothrow) Button(); pNextButton->Construct(Rectangle(GetClientAreaBounds().width / 2, 0, GetClientAreaBounds().width / 2, 72), L"다음"); pNextButton->SetActionId(ID_BUTTON_NEXT); pNextButton->AddActionEventListener(*this); AddControl(pNextButton); __pGroupedListView = new (std::nothrow) GroupedListView(); __pGroupedListView->Construct(Rectangle(0, 72, GetClientAreaBounds().width, GetClientAreaBounds().height - 72), GROUPED_LIST_VIEW_STYLE_INDEXED, true, SCROLL_STYLE_FADE_OUT); __pGroupedListView->SetTextOfEmptyList(L"일정 없음"); __pGroupedListView->SetItemProvider(*this); __pGroupedListView->AddGroupedListViewItemEventListener(*this); __pGroupedListView->SetItemDividerColor(Tizen::Graphics::Color::GetColor(COLOR_ID_BLACK)); AddControl(__pGroupedListView); LocaleManager localeManager; localeManager.Construct(); __timeZone = localeManager.GetSystemTimeZone(); return r; }
void writeToFile(fs::path _path) { stringstream ss; if (fileCount < 0){ fileCount = 0; ss << fileCount; outFile.open(fs::path(string(BASE_MODEL_PATH)+"/Data"+ss.str()+".bin"), ios::binary); ss.flush(); } else if (byteCount > BYTE_LIMIT){ outFile.flush(); outFile.close(); fileCount++; ss << fileCount; outFile.open(fs::path(string(BASE_DEST_PATH)+"/Data"+ss.str()+".bin"), ios::binary); ss.flush(); byteCount = 0; // close file and open new } Header head; head.id = strToUint64(_path.stem()); idxFile.open(_path, ios::binary); dataFile.open(_path.parent_path() / (_path.stem()+".data"), ios::binary); idxFile.seekg(0, ios::beg); idxFile.read((char*)&head.indexCount, sizeof(unsigned)); idxFile.seekg(4, ios::beg); dataFile.seekg(0, ios::beg); dataFile.read((char*)&head.vertexCount, sizeof(unsigned)); dataFile.seekg(4, ios::beg); indexData = new unsigned[head.indexCount]; vertexData = new ooctools::V4N4[head.vertexCount]; idxFile.read((char*)indexData, sizeof(unsigned)*head.indexCount); idxFile.close(); dataFile.read((char*)vertexData, sizeof(V4N4)*head.vertexCount); dataFile.close(); // ------------------------------------ //write to file outFile.seekp(byteCount, ios::beg); //writing header-info outFile.write((char*)&head, sizeof(Header)); outFile.seekp(byteCount+sizeof(Header), ios::beg); //writing the indices outFile.write((char*)indexData, head.indexCount*sizeof(unsigned)); outFile.seekp(byteCount + sizeof(Header) + head.indexCount*sizeof(unsigned), ios::beg); //writing the vertices outFile.write((char*)vertexData, head.vertexCount*sizeof(V4N4)); byteCount += head.sizeOf(); outFile.flush(); delete[] vertexData; vertexData = 0; delete[] indexData; indexData = 0; }
void Multipart::simplifyMimeStructure() { // If we're looking at a multipart with just a single part, change // the mime type to avoid the middle multipart. This affects // Kaiten Mail. if ( header()->contentType() && header()->contentType()->type() == "multipart" && parts->count() == 1 && ( !parts->firstElement()->header()->contentType() || parts->firstElement()->header()->contentType()->type() != "multipart" ) ) { Header * me = header(); Header * sub = parts->firstElement()->header(); me->removeField( HeaderField::ContentType ); ContentType * ct = sub->contentType(); if ( ct ) me->add( ct ); me->removeField( HeaderField::ContentTransferEncoding ); ContentTransferEncoding * cte = sub->contentTransferEncoding(); if ( cte ) me->add( cte ); me->removeField( HeaderField::ContentDisposition ); ContentDisposition * cd = sub->contentDisposition(); if ( cd ) me->add( cd ); if ( !ct && !cte && !cd ) me->removeField( HeaderField::MimeVersion ); } }
/** * This method checks if Tokens in two CoAP headers are equal. * * @param[in] aHeader A header to compare. * * @retval TRUE If two Tokens are equal. * @retval FALSE If Tokens differ in length or value. * */ bool IsTokenEqual(const Header &aHeader) const { return ((this->GetTokenLength() == aHeader.GetTokenLength()) && (memcmp(this->GetToken(), aHeader.GetToken(), this->GetTokenLength()) == 0)); }
void GPUOctree::dumpIndirection(const char *filename) { m_idr = new short[INDIRECTIONPOOLSIZE*4]; m_dt = new float[DATAPOOLSIZE*4]; setIndirection(m_root); half *idr_r = new half[INDIRECTIONPOOLSIZE]; half *idr_g = new half[INDIRECTIONPOOLSIZE]; half *idr_b = new half[INDIRECTIONPOOLSIZE]; half *idr_a = new half[INDIRECTIONPOOLSIZE]; for(long i=0; i<INDIRECTIONPOOLSIZE; i++) { idr_r[i] = (half)m_idr[i*4]; idr_g[i] = (half)m_idr[i*4+1]; idr_b[i] = (half)m_idr[i*4+2]; idr_a[i] = (half)m_idr[i*4+3]; } // save indirection Header idrheader (INDIRECTIONPOOLWIDTH, INDIRECTIONPOOLWIDTH); idrheader.insert ("root_size", FloatAttribute (m_rootSize)); idrheader.insert ("root_center", V3fAttribute (Imath::V3f(m_rootCenter.x, m_rootCenter.y, m_rootCenter.z))); idrheader.channels().insert ("R", Channel (HALF)); idrheader.channels().insert ("G", Channel (HALF)); // 1 idrheader.channels().insert ("B", Channel (HALF)); idrheader.channels().insert ("A", Channel (HALF)); // 2 std::string idrname = filename; idrname += ".idr"; OutputFile idrfile (idrname.c_str(), idrheader); // 4 FrameBuffer idrframeBuffer; idrframeBuffer.insert ("R", // name // 6 Slice (HALF, // type // 7 (char *) idr_r, // base // 8 sizeof (*idr_r) * 1, // xStride// 9 sizeof (*idr_r) * INDIRECTIONPOOLWIDTH)); idrframeBuffer.insert ("G", // name // 6 Slice (HALF, // type // 7 (char *) idr_g, // base // 8 sizeof (*idr_g) * 1, // xStride// 9 sizeof (*idr_g) * INDIRECTIONPOOLWIDTH)); idrframeBuffer.insert ("B", // name // 6 Slice (HALF, // type // 7 (char *) idr_b, // base // 8 sizeof (*idr_b) * 1, // xStride// 9 sizeof (*idr_b) * INDIRECTIONPOOLWIDTH)); idrframeBuffer.insert ("A", // name // 6 Slice (HALF, // type // 7 (char *) idr_a, // base // 8 sizeof (*idr_a) * 1, // xStride// 9 sizeof (*idr_a) * INDIRECTIONPOOLWIDTH)); idrfile.setFrameBuffer (idrframeBuffer); // 16 idrfile.writePixels (INDIRECTIONPOOLWIDTH); delete[] idr_r; delete[] idr_g; delete[] idr_b; delete[] idr_a; // save data half *dt_r = new half[DATAPOOLSIZE]; half *dt_g = new half[DATAPOOLSIZE]; half *dt_b = new half[DATAPOOLSIZE]; half *dt_a = new half[DATAPOOLSIZE]; for(long i=0; i<DATAPOOLSIZE; i++) { dt_r[i] = (half)m_dt[i*4]; dt_g[i] = (half)m_dt[i*4+1]; dt_b[i] = (half)m_dt[i*4+2]; dt_a[i] = (half)m_dt[i*4+3]; } Header dtheader (DATAPOOLWIDTH, DATAPOOLWIDTH); dtheader.channels().insert ("R", Channel (HALF)); dtheader.channels().insert ("G", Channel (HALF)); // 1 dtheader.channels().insert ("B", Channel (HALF)); dtheader.channels().insert ("A", Channel (HALF)); // 2 std::string dtname = filename; dtname += ".exr"; OutputFile dtfile (dtname.c_str(), dtheader); // 4 FrameBuffer dtframeBuffer; dtframeBuffer.insert ("R", // name // 6 Slice (HALF, // type // 7 (char *) dt_r, // base // 8 sizeof (*dt_r) * 1, // xStride// 9 sizeof (*dt_r) * DATAPOOLWIDTH)); dtframeBuffer.insert ("G", // name // 6 Slice (HALF, // type // 7 (char *) dt_g, // base // 8 sizeof (*dt_g) * 1, // xStride// 9 sizeof (*dt_g) * DATAPOOLWIDTH)); dtframeBuffer.insert ("B", // name // 6 Slice (HALF, // type // 7 (char *) dt_b, // base // 8 sizeof (*dt_b) * 1, // xStride// 9 sizeof (*dt_b) * DATAPOOLWIDTH)); dtframeBuffer.insert ("A", // name // 6 Slice (HALF, // type // 7 (char *) dt_a, // base // 8 sizeof (*dt_a) * 1, // xStride// 9 sizeof (*dt_a) * DATAPOOLWIDTH)); dtfile.setFrameBuffer (dtframeBuffer); // 16 dtfile.writePixels (DATAPOOLWIDTH); delete[] dt_r; delete[] dt_g; delete[] dt_b; delete[] dt_a; }
Injectee * DSN::result() const { Injectee * r = new Injectee; Bodypart * plainText = new Bodypart( 1, r ); Bodypart * dsn = new Bodypart( 2, r ); Bodypart * original = new Bodypart( 3, r ); plainText->setParent( r ); dsn->setParent( r ); original->setParent( r ); r->children()->append( plainText ); r->children()->append( dsn ); r->children()->append( original ); // set up the original message, either full or header-only if ( fullReport() ) { original->header()->add( "Content-Type", "text/rfc822-headers" ); original->setData( message()->header()->asText() ); // this is what we _should_ do, except that we don't. the body // of the message is lost, probably because original-> has a // null parent. //original->header()->add( "Content-Type", "message/rfc822" ); //original->setMessage( message() ); // and maybe we shouldn't anyway. sending a potentially big // body in a bounce is not necessarily a good idea. } else { // nasty mime name there original->header()->add( "Content-Type", "text/rfc822-headers" ); original->setData( message()->header()->asText() ); } // the from field has to contain... what? let's try this for now. Address * from = new Address( Configuration::hostname(), "postmaster", Configuration::hostname() ); // set up the top-level header Header * h = r->header(); if ( resultDate() ) { h->add( "Date", resultDate()->rfc822() ); } else { Date * now = new Date; now->setCurrentTime(); h->add( "Date", now->rfc822() ); } h->add( "From", from->toString() ); if ( sender() ) h->add( "To", sender()->toString() ); if ( allOk() ) h->add( "Subject", "Message delivered" ); else if ( allFailed() ) h->add( "Subject", "Message delivery failed" ); else h->add( "Subject", "Message delivery reports" ); h->add( "Mime-Version", "1.0" ); h->add( "Content-Type", "multipart/report; boundary=" + Message::acceptableBoundary( message()->rfc822() ) ); // set up the plaintext and DSN parts // what charset should we use for plainText? plainText->header()->add( "Content-Type", "text/plain; format=flowed" ); dsn->header()->add( "Content-Type", "message/delivery-status" ); plainText->setData( plainBody() ); dsn->setData( dsnBody() ); r->addMessageId(); return r; }
bool MultiPartInputFile::Data::checkSharedAttributesValues(const Header & src, const Header & dst, vector<string> & conflictingAttributes) const { conflictingAttributes.clear(); bool conflict = false; // // Display Window // if (src.displayWindow() != dst.displayWindow()) { conflict = true; conflictingAttributes.push_back ("displayWindow"); } // // Pixel Aspect Ratio // if (src.pixelAspectRatio() != dst.pixelAspectRatio()) { conflict = true; conflictingAttributes.push_back ("pixelAspectRatio"); } // // Timecode // const TimeCodeAttribute * srcTimeCode = src.findTypedAttribute< TimeCodeAttribute> (TimeCodeAttribute::staticTypeName()); const TimeCodeAttribute * dstTimeCode = dst.findTypedAttribute< TimeCodeAttribute> (TimeCodeAttribute::staticTypeName()); if (dstTimeCode) { if ( (srcTimeCode && (srcTimeCode->value() != dstTimeCode->value())) || (!srcTimeCode)) { conflict = true; conflictingAttributes.push_back (TimeCodeAttribute::staticTypeName()); } } // // Chromaticities // const ChromaticitiesAttribute * srcChrom = src.findTypedAttribute< ChromaticitiesAttribute> (ChromaticitiesAttribute::staticTypeName()); const ChromaticitiesAttribute * dstChrom = dst.findTypedAttribute< ChromaticitiesAttribute> (ChromaticitiesAttribute::staticTypeName()); if (dstChrom) { if ( (srcChrom && (srcChrom->value() != dstChrom->value())) || (!srcChrom)) { conflict = true; conflictingAttributes.push_back (ChromaticitiesAttribute::staticTypeName()); } } return conflict; }
void Exporter::execute() { if ( Mailbox::refreshing() ) { Database::notifyWhenIdle( this ); return; } if ( !d->mailbox && !d->sourceName.isEmpty() ) { d->mailbox = Mailbox::find( d->sourceName ); if ( !d->mailbox ) { log( "No such mailbox: " + d->sourceName.utf8(), Log::Disaster ); return; } } if ( !d->find ) { EStringList wanted; wanted.append( "message" ); d->find = d->selector->query( 0, d->mailbox, 0, this, true, &wanted, false ); d->find->execute(); } if ( !d->find->done() ) return; if ( !d->fetcher ) { d->messages = new List<Message>; while ( d->find->hasResults() ) { Row * r = d->find->nextRow(); Message * m = new Message; m->setDatabaseId( r->getInt( "message" ) ); d->messages->append( m ); } d->fetcher = new Fetcher( d->messages, this, 0 ); d->fetcher->fetch( Fetcher::Addresses ); d->fetcher->fetch( Fetcher::OtherHeader ); d->fetcher->fetch( Fetcher::Body ); d->fetcher->fetch( Fetcher::Trivia ); d->fetcher->execute(); } while ( !d->messages->isEmpty() ) { Message * m = d->messages->firstElement(); if ( !m->hasAddresses() ) return; if ( !m->hasHeaders() ) return; if ( !m->hasBodies() ) return; if ( !m->hasTrivia() ) return; d->messages->shift(); EString from = "From "; Header * h = m->header(); List<Address> * rp = 0; if ( h ) { rp = h->addresses( HeaderField::ReturnPath ); if ( !rp ) rp = h->addresses( HeaderField::Sender ); if ( !rp ) rp = h->addresses( HeaderField::From ); } if ( rp ) from.append( rp->firstElement()->lpdomain() ); else from.append( "*****@*****.**" ); from.append( " " ); Date id; if ( m->internalDate() ) id.setUnixTime( m->internalDate() ); else if ( m->header()->date() ) id = *m->header()->date(); // Tue Jul 23 19:39:23 2002 from.append( weekdays[id.weekday()] ); from.append( " " ); from.append( months[id.month()-1] ); from.append( " " ); from.appendNumber( id.day() ); from.append( " " ); from.appendNumber( id.hour() ); from.append( ":" ); if ( id.minute() < 10 ) from.append( "0" ); from.appendNumber( id.minute() ); from.append( ":" ); if ( id.second() < 10 ) from.append( "0" ); from.appendNumber( id.second() ); from.append( " " ); from.appendNumber( id.year() ); from.append( "\r\n" ); EString rfc822 = m->rfc822(); int r = ::write( 1, from.data(), from.length() ) + ::write( 1, rfc822.data(), rfc822.length() ); // we don't really care whether the write succeeds or not, so // just fool the compiler. r = r; } EventLoop::global()->stop(); }
void SieveCommand::parse( const EString & previous ) { if ( identifier().isEmpty() ) setError( "Command name is empty" ); bool test = false; bool blk = false; EString i = identifier(); if ( i == "if" || i == "elsif" ) { test = true; blk = true; if ( i == "elsif" && previous != "if" && previous != "elsif" ) setError( "elsif is only permitted after if/elsif" ); } else if ( i == "else" ) { blk = true; if ( previous != "if" && previous != "elsif" ) setError( "else is only permitted after if/elsif" ); } else if ( i == "require" ) { arguments()->numberRemainingArguments(); UStringList::Iterator i( arguments()->takeStringList( 1 ) ); EStringList a; EStringList e; while ( i ) { if ( supportedExtensions()->contains( i->ascii() ) ) a.append( i->ascii().quoted() ); else e.append( i->ascii().quoted() ); ++i; } if ( !e.isEmpty() ) setError( "Each string must be a supported " "sieve extension. " "These are not: " + e.join( ", " ) ); if ( !d->require ) setError( "require is only permitted as the first command." ); else if ( parent() ) parent()->addExtensions( &a ); } else if ( i == "stop" ) { // nothing needed } else if ( i == "reject" ) { require( "reject" ); if ( arguments()->arguments()->isEmpty() ) { // we accept reject without reason } else { // if there is an argument, it must be a string arguments()->numberRemainingArguments(); (void)arguments()->takeString( 1 ); } } else if ( i == "ereject" ) { require( "reject" ); arguments()->numberRemainingArguments(); (void)arguments()->takeString( 1 ); } else if ( i == "fileinto" ) { require( "fileinto" ); if ( arguments()->findTag( ":copy" ) ) require( "copy" ); if ( arguments()->findTag( ":flags" ) ) { require( "imap4flags" ); (void)arguments()->takeTaggedStringList( ":copy" ); } arguments()->numberRemainingArguments(); UString mailbox = arguments()->takeString( 1 ); UString p; p.append( "/" ); p.append( mailbox ); if ( !Mailbox::validName( mailbox ) && !Mailbox::validName( p ) ) { setError( "Expected mailbox name, but got: " + mailbox.utf8() ); } else if ( mailbox.startsWith( "INBOX." ) ) { // a sieve script which wants to reference a // mailbox called INBOX.X must use lower case // (inbox.x). UString aox = UStringList::split( '.', mailbox.mid( 6 ) )->join( "/" ); setError( mailbox.utf8().quoted() + " is Cyrus syntax. Archiveopteryx uses " + aox.utf8().quoted() ); } } else if ( i == "redirect" ) { (void)arguments()->findTag( ":copy" ); arguments()->numberRemainingArguments(); EString s = arguments()->takeString( 1 ).utf8(); AddressParser ap( s ); ap.assertSingleAddress(); if ( !ap.error().isEmpty() ) setError( "Expected one normal address (local@domain), but got: " + s ); } else if ( i == "keep" ) { // nothing needed } else if ( i == "discard" ) { // nothing needed } else if ( i == "vacation" ) { // vacation [":days" number] [":subject" string] // [":from" string] [":addresses" string-list] // [":mime"] [":handle" string] <reason: string> require( "vacation" ); // :days uint days = 7; if ( arguments()->findTag( ":days" ) ) days = arguments()->takeTaggedNumber( ":days" ); if ( days < 1 || days > 365 ) arguments()->tagError( ":days", "Number must be 1..365" ); // :subject (void)arguments()->takeTaggedString( ":subject" ); // anything is acceptable, right? // :from if ( arguments()->findTag( ":from" ) ) { parseAsAddress( arguments()->takeTaggedString( ":from" ), ":from" ); // XXX we don't enforce its being a local address. } // :addresses if ( arguments()->findTag( ":addresses" ) ) { UStringList * addresses = arguments()->takeTaggedStringList( ":addresses" ); UStringList::Iterator i( addresses ); while ( i ) { parseAsAddress( *i, ":addresses" ); ++i; } } // :mime bool mime = false; if ( arguments()->findTag( ":mime" ) ) mime = true; // :handle (void)arguments()->takeTaggedString( ":handle" ); // reason arguments()->numberRemainingArguments(); UString reason = arguments()->takeString( 1 ); if ( mime ) { if ( !reason.isAscii() ) setError( ":mime bodies must be all-ASCII, " "8-bit text is not permitted" ); // so says the RFC EString x = reason.utf8(); uint i = 0; Header * h = Message::parseHeader( i, x.length(), x, Header::Mime ); Bodypart * bp = Bodypart::parseBodypart( i, x.length(), x, h, 0 ); if ( !h->error().isEmpty() ) setError( "While parsing MIME header: " + h->error() ); else if ( !bp->error().isEmpty() ) setError( "While parsing MIME bodypart: " + bp->error() ); List<HeaderField>::Iterator f( h->fields() ); while ( f ) { if ( !f->name().startsWith( "Content-" ) ) setError( "Header field not permitted: " + f->name() ); ++f; } if ( bp->children()->isEmpty() && bp->text().isEmpty() ) setError( "Vacation reply does not contain any text" ); } else { if ( reason.isEmpty() ) setError( "Empty vacation text does not make sense" ); } } else if ( i == "setflag" || i == "addflags" || i == "removeflag" ) { arguments()->numberRemainingArguments(); (void)arguments()->takeStringList( 1 ); } else if ( i == "notify" ) { require( "enotify" ); UString from; if ( arguments()->findTag( ":from" )) from = arguments()->takeTaggedString( ":from" ); UString importance; importance.append( "2" ); if ( arguments()->findTag( ":importance" ) ) importance = arguments()->takeTaggedString( ":from" ); uint c = importance[0]; if ( c < '1' || c > '3' ) arguments()->tagError( ":importance", "Importance must be 1, 2 or 3" ); UStringList * options; if ( arguments()->findTag( ":options" ) ) options = arguments()->takeTaggedStringList( ":options" ); UString message; if ( arguments()->findTag( ":message" ) ) message = arguments()->takeTaggedString( ":message" ); arguments()->numberRemainingArguments(); UString method = arguments()->takeString( 1 ); SieveNotifyMethod * m = new SieveNotifyMethod( method, arguments()->takeArgument( 1 ), this ); if ( m->valid() ) { if ( arguments()->findTag( ":from" ) ) m->setFrom( from, arguments()->findTag( ":from" ) ); if ( arguments()->findTag( ":message" ) ) m->setMessage( message, arguments()->findTag( ":message" ) ); } } else { setError( "Command unknown: " + identifier() ); } arguments()->flagUnparsedAsBad(); if ( test ) { // we must have a test if ( !arguments() || arguments()->tests()->count() != 1 ) setError( "Command " + identifier() + " requires one test" ); if ( arguments() ) { List<SieveTest>::Iterator i( arguments()->tests() ); while ( i ) { i->parse(); if ( blk && block() ) { if ( i->ihaveFailed() ) block()->setIhaveFailed(); else block()->addExtensions( i->addedExtensions() ); } ++i; } } } else { // we cannot have a test if ( arguments() && arguments()->tests()->isEmpty() ) { List<SieveTest>::Iterator i( arguments()->tests() ); while ( i ) { i->setError( "Command " + identifier() + " does not use tests" ); ++i; } } } if ( blk ) { // we must have a subsidiary block if ( !block() ) { setError( "Command " + identifier() + " requires a subsidiary {..} block" ); } else { EString prev; List<SieveCommand>::Iterator i( block()->commands() ); while ( i ) { i->parse( prev ); prev = i->identifier(); ++i; } } } else { // we cannot have a subsidiary block if ( block() ) block()->setError( "Command " + identifier() + " does not use a subsidiary command block" ); // in this case we don't even bother syntax-checking the test // or block } }
bool isSUVI(const Header& header) { return header.has("INSTRUME") && header.get<string>("INSTRUME").find("GOES-R") != string::npos; }
Frame *FrameFactory::createFrame(const ByteVector &data, unsigned int version) const { Header tagHeader; tagHeader.setMajorVersion(version); return createFrame(data, &tagHeader); }
void run () { auto amp = Image<value_type>::open (argument[0]).with_direct_io (3); Header header (amp); std::vector<size_t> bzeros, dwis; Eigen::MatrixXd dirs; auto opt = get_options ("directions"); if (opt.size()) { dirs = load_matrix (opt[0][0]); } else { auto hit = header.keyval().find ("directions"); if (hit != header.keyval().end()) { std::vector<default_type> dir_vector; for (auto line : split_lines (hit->second)) { auto v = parse_floats (line); dir_vector.insert (dir_vector.end(), v.begin(), v.end()); } dirs.resize(dir_vector.size() / 2, 2); for (size_t i = 0; i < dir_vector.size(); i += 2) { dirs(i/2, 0) = dir_vector[i]; dirs(i/2, 1) = dir_vector[i+1]; } } else { auto grad = DWI::get_valid_DW_scheme (amp); DWI::Shells shells (grad); shells.select_shells (true, true); if (shells.smallest().is_bzero()) bzeros = shells.smallest().get_volumes(); dwis = shells.largest().get_volumes(); dirs = DWI::gen_direction_matrix (grad, dwis); } } auto sh2amp = DWI::compute_SH2amp_mapping (dirs, true, 8); bool normalise = get_options ("normalise").size(); if (normalise && !bzeros.size()) throw Exception ("the normalise option is only available if the input data contains b=0 images."); header.size (3) = sh2amp.cols(); Stride::set_from_command_line (header); auto SH = Image<value_type>::create (argument[1], header); Amp2SHCommon common (sh2amp, bzeros, dwis, normalise); opt = get_options ("rician"); if (opt.size()) { auto noise = Image<value_type>::open (opt[0][0]).with_direct_io(); ThreadedLoop ("mapping amplitudes to SH coefficients", amp, 0, 3) .run (Amp2SH (common), SH, amp, noise); } else { ThreadedLoop ("mapping amplitudes to SH coefficients", amp, 0, 3) .run (Amp2SH (common), SH, amp); } }
static void bsToHeader(Header& param, BitWriter& bs) { ASSERT(BIT_WRITER_BIT_SIZE (&bs) % 8 == 0); param.insert(param.end(), BIT_WRITER_DATA (&bs), BIT_WRITER_DATA (&bs) + BIT_WRITER_BIT_SIZE (&bs)/8); }
result CreateProfileForm::OnInitializing(void) { result r = E_SUCCESS; Header* pHeader = GetHeader(); AppAssert(pHeader); pHeader->SetStyle(HEADER_STYLE_TITLE); String getProfileCreationTitle; Application::GetInstance()->GetAppResource()->GetString(IDS_CREATE_TITLE, getProfileCreationTitle); pHeader->SetTitleText(getProfileCreationTitle); Footer* pFooter = GetFooter(); AppAssert(pFooter); pFooter->SetStyle(FOOTER_STYLE_BUTTON_TEXT); FooterItem footerSave; footerSave.Construct(ID_BUTTON_SAVE); String getSave; Application::GetInstance()->GetAppResource()->GetString(IDS_SAVE, getSave); footerSave.SetText(getSave); pFooter->AddItem(footerSave); pFooter->AddActionEventListener(*this); SetFormBackEventListener(this); static const unsigned int COLOR_BACKGROUND_LABEL = 0xFFEFEDE5; static const unsigned int COLOR_TITLE_LABEL = 0xFF808080; static const int UI_X_POSITION_GAP = 20; static const int UI_WIDTH = GetClientAreaBounds().width - 40; static const int UI_X_POSITION_MIDDLE = UI_WIDTH / 4; static const int UI_HEIGHT = 112; static const int UI_SPACE = 26; int yPosition = 0; __pScrollPanel = new (std::nothrow) ScrollPanel(); __pScrollPanel->Construct(Rectangle(0, 0, GetClientAreaBounds().width, GetClientAreaBounds().height)); // Subject __pSubjectEditField = new (std::nothrow) EditField(); __pSubjectEditField->Construct(Rectangle(UI_X_POSITION_GAP, yPosition, UI_WIDTH, UI_HEIGHT), EDIT_FIELD_STYLE_NORMAL, INPUT_STYLE_FULLSCREEN, EDIT_FIELD_TITLE_STYLE_TOP); String getProfileName, getProfileNameGuid; Application::GetInstance()->GetAppResource()->GetString(IDS_PROFILE_NAME, getProfileName); Application::GetInstance()->GetAppResource()->GetString(IDS_PROFILE_GUIDE, getProfileNameGuid); __pSubjectEditField->SetGuideText(getProfileNameGuid); __pSubjectEditField->SetName(L"Subject"); __pSubjectEditField->SetTitleText(getProfileName); __pSubjectEditField->SetOverlayKeypadCommandButtonVisible(false); __pScrollPanel->AddControl(__pSubjectEditField); // Start Date int minYear = Calendarbook::GetMinDateTime().GetYear() + 1; int maxYear = Calendarbook::GetMaxDateTime().GetYear() - 1; Label* pStartDateLabel = new (std::nothrow) Label(); String getStartDateTime, getEndDateTime; Application::GetInstance()->GetAppResource()->GetString(IDS_START_DATETIME, getStartDateTime); Application::GetInstance()->GetAppResource()->GetString(IDS_END_DATETIME, getEndDateTime); pStartDateLabel->Construct(Rectangle(UI_X_POSITION_GAP, yPosition += UI_HEIGHT + UI_SPACE, UI_WIDTH, UI_HEIGHT), getStartDateTime); pStartDateLabel->SetTextVerticalAlignment(ALIGNMENT_TOP); pStartDateLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT); pStartDateLabel->SetTextColor(COLOR_TITLE_LABEL); pStartDateLabel->SetBackgroundColor(COLOR_BACKGROUND_LABEL); __pScrollPanel->AddControl(pStartDateLabel); __pStartEditDate = new (std::nothrow) EditDate(); __pStartEditDate->Construct(Point(UI_X_POSITION_GAP, yPosition + 10)); __pStartEditDate->SetCurrentDate(); __pStartEditDate->SetYearRange(minYear, maxYear); __pStartEditDate->AddDateChangeEventListener(*this); __pScrollPanel->AddControl(__pStartEditDate); __pStartEditTime = new (std::nothrow) EditTime(); __pStartEditTime->Construct(Point(UI_X_POSITION_MIDDLE * 2 + UI_SPACE, yPosition + 10)); __pStartEditTime->SetCurrentTime(); __pStartEditTime->AddTimeChangeEventListener(*this); __pScrollPanel->AddControl(__pStartEditTime); // Due Date Label* pDueDateLabel = new (std::nothrow) Label(); pDueDateLabel->Construct(Rectangle(UI_X_POSITION_GAP, yPosition += UI_HEIGHT, UI_WIDTH, UI_HEIGHT), getEndDateTime); pDueDateLabel->SetTextVerticalAlignment(ALIGNMENT_TOP); pDueDateLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT); pDueDateLabel->SetTextColor(COLOR_TITLE_LABEL); pDueDateLabel->SetBackgroundColor(COLOR_BACKGROUND_LABEL); __pScrollPanel->AddControl(pDueDateLabel); __pDueEditDate = new (std::nothrow) EditDate(); __pDueEditDate->Construct(Point(UI_X_POSITION_GAP, yPosition + 10)); __pDueEditDate->SetCurrentDate(); __pDueEditDate->SetYearRange(minYear, maxYear); __pDueEditDate->AddDateChangeEventListener(*this); __pScrollPanel->AddControl(__pDueEditDate); DateTime endTime; endTime = __pStartEditTime->GetTime(); endTime.AddHours(1); __pDueEditTime = new (std::nothrow) EditTime(); __pDueEditTime->Construct(Point(UI_X_POSITION_MIDDLE * 2 + UI_SPACE, yPosition + 10)); __pDueEditTime->SetTime(endTime); __pDueEditTime->AddTimeChangeEventListener(*this); __pScrollPanel->AddControl(__pDueEditTime); // Location String getLocationGuide; Application::GetInstance()->GetAppResource()->GetString(IDS_LOCATION_GUIDE, getLocationGuide); __pLocationButton = new (std::nothrow) Button(); __pLocationButton->Construct(Rectangle(UI_X_POSITION_GAP, yPosition += UI_HEIGHT + UI_SPACE, UI_WIDTH, UI_HEIGHT), getLocationGuide); __pLocationButton->SetActionId(ID_LOCATION_BUTTON); __pLocationButton->AddActionEventListener(*this); __pScrollPanel->AddControl(__pLocationButton); // Volume String getVolume; Application::GetInstance()->GetAppResource()->GetString(IDS_VOLUME, getVolume); __pVolumeSlider = new (std::nothrow) Slider(); __pVolumeSlider->Construct(Rectangle(UI_X_POSITION_GAP, yPosition += UI_HEIGHT + UI_SPACE, UI_WIDTH/*GetClientAreaBounds().width*/, UI_HEIGHT + 30), BACKGROUND_STYLE_DEFAULT, true, 0, 15); __pVolumeSlider->SetValue(5); __pVolumeSlider->SetTitleText(getVolume); __pVolumeSlider->AddAdjustmentEventListener(*this); __pScrollPanel->AddControl(__pVolumeSlider); // Wifi String getWifi; Application::GetInstance()->GetAppResource()->GetString(IDS_WIFI, getWifi); __pWifiCheckButton = new (std::nothrow) CheckButton(); __pWifiCheckButton->Construct(Rectangle(UI_X_POSITION_GAP, yPosition += UI_HEIGHT + UI_SPACE, UI_WIDTH, UI_HEIGHT), CHECK_BUTTON_STYLE_ONOFF_SLIDING, BACKGROUND_STYLE_DEFAULT, false, getWifi); __pWifiCheckButton->SetActionId(ID_BUTTON_CHECKED, ID_BUTTON_UNCHECKED, ID_BUTTON_SELECTED); __pWifiCheckButton->AddActionEventListener(*this); __pScrollPanel->AddControl(__pWifiCheckButton); // Description String getDescription, getDescriptionGuide; Application::GetInstance()->GetAppResource()->GetString(IDS_DESCRIPTION, getDescription); Application::GetInstance()->GetAppResource()->GetString(IDS_DESCRIPTION_GUIDE, getDescriptionGuide); __pDescriptionEditField = new (std::nothrow) EditField(); __pDescriptionEditField->Construct(Rectangle(UI_X_POSITION_GAP, yPosition += UI_HEIGHT + UI_SPACE, UI_WIDTH, UI_HEIGHT), EDIT_FIELD_STYLE_NORMAL, INPUT_STYLE_FULLSCREEN, EDIT_FIELD_TITLE_STYLE_TOP); __pDescriptionEditField->SetGuideText(getDescriptionGuide); __pDescriptionEditField->SetName(L"Description"); __pDescriptionEditField->SetTitleText(getDescription); __pDescriptionEditField->SetOverlayKeypadCommandButtonVisible(false); __pScrollPanel->AddControl(__pDescriptionEditField); AddControl(__pScrollPanel); return r; }
result ProfileListForm::OnInitializing(void) { result r = E_SUCCESS; Header* pHeader = GetHeader(); AppAssert(pHeader); pHeader->SetStyle(HEADER_STYLE_TITLE); String getHeaderTitle; Application::GetInstance()->GetAppResource()->GetString(IDS_HEADER_TITLE, getHeaderTitle); pHeader->SetTitleText(getHeaderTitle); Footer* pFooter = GetFooter(); AppAssert(pFooter); pFooter->SetStyle(FOOTER_STYLE_BUTTON_TEXT); FooterItem footerCreate; footerCreate.Construct(ID_FOOTER_CREATE); String getFooterCreate; UiApp::GetInstance()->GetAppResource()->GetString(IDS_FOOTER_CREATE, getFooterCreate); footerCreate.SetText(getFooterCreate); pFooter->AddItem(footerCreate); pFooter->AddActionEventListener(*this); SetFormBackEventListener(this); String sql (L"CREATE TABLE IF NOT EXISTS profile(id INTEGER PRIMARY KEY, " "title TEXT, " "year INTEGER, month INTEGER, day INTEGER, hour INTEGER, minute INTEGER, " "year2 INTEGER, month2 INTEGER, day2 INTEGER, hour2 INTEGER, minute2 INTEGER, " "latitude INTEGER, longitude INTEGER, volume INTEGER, wifi INTEGER, memo TEXT)"); __pProfileDatabase->ExecuteSql(sql, true); __pTitleList.RemoveAll(true); __pIndexList.RemoveAll(true); // static const int UI_POSITION_GAP = 0; // __pStatusContextButton = new (std::nothrow) Button(); // __pStatusContextButton->Construct(Rectangle(GetClientAreaBounds().width * 2 / 3, UI_POSITION_GAP, GetClientAreaBounds().width / 3, BUTTON_HEIGHT), L"All"); // __pStatusContextButton->SetActionId(ID_BUTTON_STATUS); // __pStatusContextButton->AddActionEventListener(*this); // AddControl(__pStatusContextButton); // // __pStatusContextMenu = new (std::nothrow) ContextMenu(); // __pStatusContextMenu->Construct(Point(GetClientAreaBounds().width * 5 / 6, BUTTON_HEIGHT * 3), CONTEXT_MENU_STYLE_LIST); // __pStatusContextMenu->AddItem(L"All", ID_CONTEXT_STATUS_ALL); // __pStatusContextMenu->AddItem(L"None", ID_CONTEXT_STATUS_NONE); // __pStatusContextMenu->AddItem(L"Needs action", ID_CONTEXT_STATUS_NEEDS_ACTION); // __pStatusContextMenu->AddItem(L"Completed", ID_CONTEXT_STATUS_COMPLETED); // __pStatusContextMenu->AddItem(L"In process", ID_CONTEXT_STATUS_IN_PROCESS); // __pStatusContextMenu->AddItem(L"Cancelled", ID_CONTEXT_STATUS_CANCELLED); // __pStatusContextMenu->AddActionEventListener(*this); __pProfileListView = new (std::nothrow) ListView(); __pProfileListView->Construct(Rectangle(0 /*UI_POSITION_GAP*/, 0/*BUTTON_HEIGHT*/, GetClientAreaBounds().width, GetClientAreaBounds().height /*- BUTTON_HEIGHT*/)); String getNoList; Application::GetInstance()->GetAppResource()->GetString(IDS_EMPTY_LIST, getNoList); __pProfileListView->SetTextOfEmptyList(getNoList); __pProfileListView->SetItemProvider(*this); __pProfileListView->AddListViewItemEventListener(*this); __pProfileListView->SetSweepEnabled(true); AddControl(__pProfileListView); //(*this); SettingInfo::AddSettingEventListener(*this); ListUpdate(); // __selectedStatus = TODO_STATUS_ALL; return r; }
int main(int argc, char **argv) { int c; char *inputFile=NULL, *insertFile=NULL, *removeFile=NULL, *outputFile=NULL; char *insertSubject=NULL, *insertPredicate=NULL, *insertObject=NULL; char *removeSubject=NULL, *removePredicate=NULL, *removeObject=NULL; bool insertSingle = false; bool removeSingle = false; bool insertMultiple = false; bool removeMultiple = false; while ((c = getopt(argc, argv, "hO:i:r:I:R:")) != -1) { switch (c) { case 'h': help(); break; case 'O': outputFile = optarg; break; case 'i': insertSingle = true; insertSubject = optarg; insertPredicate = argv[optind++]; insertObject = argv[optind++]; break; case 'r': removeSingle = true; removeSubject = optarg; removePredicate = argv[optind++]; removeObject = argv[optind++]; break; case 'I': insertMultiple = true; insertFile = optarg; break; case 'R': removeMultiple = true; removeFile = optarg; break; default: cout << "ERROR: Unknown option" << endl; help(); return 1; } } if (argc - optind < 2) { cout << "ERROR: You must supply an input and output HDT File" << endl << endl; help(); return 1; } inputFile = argv[optind]; outputFile = argv[optind+1]; if (strcmp(inputFile,outputFile)==0){ cerr<< "ERROR: input and output files must me different" << endl <<endl; return 1; } try { // LOAD HDT *hdt = HDTManager::mapHDT(inputFile); // Replace header Header *head = hdt->getHeader(); if (insertSingle) { TripleString ti(insertSubject, insertPredicate, insertObject); head->insert(ti); } if (removeSingle) { TripleString ti(removeSubject, removePredicate, removeObject); head->remove(ti); } if (insertMultiple) { string line; std::ifstream infile(insertFile); while (getline(infile, line)) { TripleString ti; ti.read(line); head->insert(ti); } } if (removeMultiple) { string line; std::ifstream infile(removeFile); while (getline(infile, line)) { TripleString ti; ti.read(line); head->remove(ti); } } // SAVE hdt->saveToHDT(outputFile); delete hdt; } catch (std::exception& e) { cerr << "ERROR: " << e.what() << endl; return 1; } }
void clear_DW_scheme (Header& header) { auto it = header.keyval().find ("dw_scheme"); if (it != header.keyval().end()) header.keyval().erase (it); }
//////////////////////////////////////////////////////////////////////////////////// /// /// \brief Writes message contents to packet for the transport layer to /// send. Begins writing from current write position in packet. /// /// Message contents are written to the packet following the JAUS standard. /// /// \param[out] packet Packet to write header and payload data to. /// \param[out] header Packet transport header data. /// \param[in] transportHeader Optional parameter for transport header data to /// write before the general transport header. /// \param[in] clearPacket If true, packet contents are cleared before /// writing takes place. /// \param[in] startingSequenceNumber Sequence number to use for packets. /// \param[in] broadcastFlag Values to use to signify if message should be /// sent using any broadcast options (e.g. /// multicast). 0 = no options, 1 = local broadcast, /// 2 = global broadcast. /// /// \return FAILURE on error, otherwise number of bytes written. /// //////////////////////////////////////////////////////////////////////////////////// int Message::Write(Packet& packet, Header& header, const Packet* transportHeader, const bool clearPacket, const UShort startingSequenceNumber, const Byte broadcastFlag) const { int total = 0; // Build JAUS header data. header.mSourceID = mSourceID; header.mDestinationID = mDestinationID; header.mPriorityFlag = mPriority; header.mControlFlag = Header::DataControl::Single; header.mCompressionFlag = Header::Compression::None; header.mSequenceNumber = startingSequenceNumber; header.mBroadcastFlag = broadcastFlag; // Clear out any previous message data. if(clearPacket) { packet.Clear(); packet.Reserve(Header::MinSize + USHORT_SIZE + 1); } unsigned int writePos = packet.GetWritePos(); if(transportHeader && transportHeader->Length() > 0) { writePos += (unsigned int)packet.Write(*transportHeader); } // The first thing we must do is advance // the write position to after the JAUS Header // data. The header is not written first because // we do not know how large the message body will // be yet. packet.SetLength(writePos + Header::PayloadOffset); packet.SetWritePos(writePos + Header::PayloadOffset); total += packet.Write(mMessageCode); int payloadSize = 0; if( (payloadSize = WriteMessageBody(packet)) >= 0) { total += payloadSize; // Check for large data set. if(total + Header::MinSize > Header::MaxPacketSize) { return FAILURE; } else { header.mSize = total + Header::MinSize; packet.SetWritePos(writePos); // Go back, and re-write the header since // we now know the size of the message. if(header.Write(packet)) { // Set the write position to the end of message we just wrote. packet.SetWritePos(writePos + header.mSize); // Return the number of bytes written. if(transportHeader) { return header.mSize + transportHeader->Length(); } else { return header.mSize; } } } } return FAILURE; }
oc::result<void> SonyElfFormatWriter::write_header(File &file, const Header &header) { m_cmdline.clear(); m_hdr = {}; m_hdr_kernel = {}; m_hdr_ramdisk = {}; m_hdr_cmdline = {}; m_hdr_ipl = {}; m_hdr_rpm = {}; m_hdr_appsbl = {}; // Construct ELF header memcpy(&m_hdr.e_ident, SONY_E_IDENT, SONY_EI_NIDENT); m_hdr.e_type = 2; m_hdr.e_machine = 40; m_hdr.e_version = 1; m_hdr.e_phoff = 52; m_hdr.e_shoff = 0; m_hdr.e_flags = 0; m_hdr.e_ehsize = sizeof(Sony_Elf32_Ehdr); m_hdr.e_phentsize = sizeof(Sony_Elf32_Phdr); m_hdr.e_shentsize = 0; m_hdr.e_shnum = 0; m_hdr.e_shstrndx = 0; if (auto entrypoint_address = header.entrypoint_address()) { m_hdr.e_entry = *entrypoint_address; } else if (auto kernel_address = header.kernel_address()) { m_hdr.e_entry = *kernel_address; } // Construct kernel program header m_hdr_kernel.p_type = SONY_E_TYPE_KERNEL; m_hdr_kernel.p_flags = SONY_E_FLAGS_KERNEL; m_hdr_kernel.p_align = 0; if (auto address = header.kernel_address()) { m_hdr_kernel.p_vaddr = *address; m_hdr_kernel.p_paddr = *address; } // Construct ramdisk program header m_hdr_ramdisk.p_type = SONY_E_TYPE_RAMDISK; m_hdr_ramdisk.p_flags = SONY_E_FLAGS_RAMDISK; m_hdr_ramdisk.p_align = 0; if (auto address = header.ramdisk_address()) { m_hdr_ramdisk.p_vaddr = *address; m_hdr_ramdisk.p_paddr = *address; } // Construct cmdline program header m_hdr_cmdline.p_type = SONY_E_TYPE_CMDLINE; m_hdr_cmdline.p_vaddr = 0; m_hdr_cmdline.p_paddr = 0; m_hdr_cmdline.p_flags = SONY_E_FLAGS_CMDLINE; m_hdr_cmdline.p_align = 0; if (auto cmdline = header.kernel_cmdline()) { m_cmdline = *cmdline; } // Construct IPL program header m_hdr_ipl.p_type = SONY_E_TYPE_IPL; m_hdr_ipl.p_flags = SONY_E_FLAGS_IPL; m_hdr_ipl.p_align = 0; if (auto address = header.sony_ipl_address()) { m_hdr_ipl.p_vaddr = *address; m_hdr_ipl.p_paddr = *address; } // Construct RPM program header m_hdr_rpm.p_type = SONY_E_TYPE_RPM; m_hdr_rpm.p_flags = SONY_E_FLAGS_RPM; m_hdr_rpm.p_align = 0; if (auto address = header.sony_rpm_address()) { m_hdr_rpm.p_vaddr = *address; m_hdr_rpm.p_paddr = *address; } // Construct APPSBL program header m_hdr_appsbl.p_type = SONY_E_TYPE_APPSBL; m_hdr_appsbl.p_flags = SONY_E_FLAGS_APPSBL; m_hdr_appsbl.p_align = 0; if (auto address = header.sony_appsbl_address()) { m_hdr_appsbl.p_vaddr = *address; m_hdr_appsbl.p_paddr = *address; } std::vector<SegmentWriterEntry> entries; entries.push_back({ ENTRY_TYPE_KERNEL, 0, {}, 0 }); entries.push_back({ ENTRY_TYPE_RAMDISK, 0, {}, 0 }); entries.push_back({ SONY_ELF_ENTRY_CMDLINE, 0, {}, 0 }); entries.push_back({ ENTRY_TYPE_SONY_IPL, 0, {}, 0 }); entries.push_back({ ENTRY_TYPE_SONY_RPM, 0, {}, 0 }); entries.push_back({ ENTRY_TYPE_SONY_APPSBL, 0, {}, 0 }); OUTCOME_TRYV(m_seg->set_entries(std::move(entries))); // Start writing at offset 4096 auto seek_ret = file.seek(4096, SEEK_SET); if (!seek_ret) { if (file.is_fatal()) { m_writer.set_fatal(); } return seek_ret.as_failure(); } return oc::success(); }
/*! * \brief Read header for new-style Loki image * * \param[in] reader Reader to set error message * \param[in] file File handle * \param[in] hdr Android header for image * \param[in] loki_hdr Loki header for image * \param[out] header Header instance to store header values * \param[out] kernel_offset_out Pointer to store kernel offset * \param[out] kernel_size_out Pointer to store kernel size * \param[out] ramdisk_offset_out Pointer to store ramdisk offset * \param[out] ramdisk_size_out Pointer to store ramdisk size * \param[out] dt_offset_out Pointer to store device tree offset * * \return Nothing if the header is successfully read. Otherwise, a specific * error code. */ oc::result<void> LokiFormatReader::read_header_new(Reader &reader, File &file, const android::AndroidHeader &hdr, const LokiHeader &loki_hdr, Header &header, uint64_t &kernel_offset_out, uint32_t &kernel_size_out, uint64_t &ramdisk_offset_out, uint32_t &ramdisk_size_out, uint64_t &dt_offset_out) { uint32_t fake_size; uint32_t ramdisk_addr; if (hdr.page_size == 0) { return LokiError::PageSizeCannotBeZero; } if (is_lg_ramdisk_address(hdr.ramdisk_addr)) { fake_size = hdr.page_size; } else { fake_size = 0x200; } // Find original ramdisk address OUTCOME_TRYV(find_ramdisk_address(reader, file, hdr, loki_hdr, ramdisk_addr)); // Restore original values in boot image header kernel_size_out = loki_hdr.orig_kernel_size; ramdisk_size_out = loki_hdr.orig_ramdisk_size; auto *name_ptr = reinterpret_cast<const char *>(hdr.name); auto name_size = strnlen(name_ptr, sizeof(hdr.name)); auto *cmdline_ptr = reinterpret_cast<const char *>(hdr.cmdline); auto cmdline_size = strnlen(cmdline_ptr, sizeof(hdr.cmdline)); header.set_supported_fields(NEW_SUPPORTED_FIELDS); header.set_board_name({{name_ptr, name_size}}); header.set_kernel_cmdline({{cmdline_ptr, cmdline_size}}); header.set_page_size(hdr.page_size); header.set_kernel_address(hdr.kernel_addr); header.set_ramdisk_address(ramdisk_addr); header.set_secondboot_address(hdr.second_addr); header.set_kernel_tags_address(hdr.tags_addr); uint64_t pos = 0; // pos cannot overflow due to the nature of the operands (adding UINT32_MAX // a few times can't overflow a uint64_t). File length overflow is checked // during read. // Header pos += hdr.page_size; // Kernel kernel_offset_out = pos; pos += loki_hdr.orig_kernel_size; pos += align_page_size<uint64_t>(pos, hdr.page_size); // Ramdisk ramdisk_offset_out = pos; pos += loki_hdr.orig_ramdisk_size; pos += align_page_size<uint64_t>(pos, hdr.page_size); // Device tree if (hdr.dt_size != 0) { pos += fake_size; } dt_offset_out = pos; pos += hdr.dt_size; pos += align_page_size<uint64_t>(pos, hdr.page_size); return oc::success(); }