ByteVector Ogg::Page::render() const { ByteVector data; data.append(d->header.render()); if(d->packets.isEmpty()) { if(d->file) { d->file->seek(d->fileOffset + d->header.size()); data.append(d->file->readBlock(d->header.dataSize())); } else debug("Ogg::Page::render() -- this page is empty!"); } else { ByteVectorList::ConstIterator it = d->packets.begin(); for(; it != d->packets.end(); ++it) data.append(*it); } // Compute and set the checksum for the Ogg page. The checksum is taken over // the entire page with the 4 bytes reserved for the checksum zeroed and then // inserted in bytes 22-25 of the page header. const ByteVector checksum = ByteVector::fromUInt(data.checksum(), false); std::copy(checksum.begin(), checksum.end(), data.begin() + 22); return data; }
String::String(const ByteVector &v, Type t) { d = new StringPrivate; if(v.isEmpty()) return; if(t == Latin1 || t == UTF8) { int length = 0; d->data.resize(v.size()); wstring::iterator targetIt = d->data.begin(); for(ByteVector::ConstIterator it = v.begin(); it != v.end() && (*it); ++it) { *targetIt = uchar(*it); ++targetIt; ++length; } d->data.resize(length); } else { d->data.resize(v.size() / 2); wstring::iterator targetIt = d->data.begin(); for(ByteVector::ConstIterator it = v.begin(); it != v.end() && it + 1 != v.end() && combine(*it, *(it + 1)); it += 2) { *targetIt = combine(*it, *(it + 1)); ++targetIt; } } prepare(t); }
// for 5.17 bootloaders the region 80040e00-80041000 is not added to // the checksum. void UpdateChecksum(DWORD& sum, const ByteVector& buffer) { for (ByteVector::const_iterator bufp= buffer.begin() ; bufp != buffer.end() ; bufp+=4) { sum+=*(const DWORD*)iteratorptr(bufp); } }
void BufferReader::SetData(uchar* thePtr, int theCount) { mData.clear(); mData.reserve(theCount); mData.insert(mData.begin(), thePtr, thePtr + theCount); mDataBitSize = mData.size() * 8; }
void IpmiPayload::serializeEncryptedRmcpp(ByteVector& out, const ByteVector& key, const IpmiPayloadData& payload) { IpmiPayloadData cryptedPayload; // generate random IV ByteVector iv; CryptoProxy::getInstance()->genRand(16, iv); // calculate padding length byte_t padLength = (16 - static_cast<byte_t>((payload.data.length() + 1/*for padLength field*/) % 16)) % 16; ByteVector payloadToCrypt(payload.data); // append padding for (byte_t i = 1; i <= padLength; ++i) { payloadToCrypt += i; } // append padding length payloadToCrypt += padLength; // crypt payload CryptoProxy::getInstance()->encrypt(key, iv, payloadToCrypt, cryptedPayload.data); // prefix crypted payload with IV cryptedPayload.data.insert(cryptedPayload.data.begin(), iv.begin(), iv.end()); // serialize payload serializeRmcpp(out, cryptedPayload); }
// --------- typed value to specific type conversions bool Registry::ValueToStringList(const ByteVector& value, StringList& list) { ByteVector::const_iterator str_start= value.begin(); for (ByteVector::const_iterator i= value.begin() ; i!=value.end() ; ++i) { if (*i==0) { list.push_back(string(str_start, i)); str_start= i+1; } } if (str_start!=value.end()) { list.push_back(string(str_start, value.end())); str_start= value.end(); } return true; }
bool Registry::ValueToString(const ByteVector& value, std::string& str) { str.clear(); for (ByteVector::const_iterator i=value.begin() ; i!=value.end() && (*i)!=0 ; ++i) { str += (char)(*i); } return true; }
unsigned long calculateDistance(Byte inBaseValue,const ByteVector& inVector) { unsigned long result = 0; ByteVector::const_iterator it = inVector.begin(); for(; it != inVector.end();++it) result+=std::abs(*it-inBaseValue); return result; }
//============================================================================== void CC_UnitDriver::convert_lock_data_std_set( const StringVector& qualifiers, const ByteVector& lock_sizes, ByteVector& lock_data) { ByteVector data(1, 0x1F); foreach (const String &item, qualifiers) { if (item == "debug") data[0] &= ~1; else if (item == "boot") data[0] &= ~0x10; else if (item == "flash" || item == "pages") data[0] &= ~0x0E; else if (item.find("flash:") == 0) { uint_t size = 0; String arg = item.substr(ARRAY_SIZE("flash:") - 1); if (!string_to_number(arg, size)) throw std::runtime_error("incorrect flash size value"); ByteVector::const_iterator it = std::find( lock_sizes.begin(), lock_sizes.end(), size); if (it == lock_sizes.end()) throw std::runtime_error("target unsupport flash size " + arg); uint8_t index = (uint8_t)(it - lock_sizes.begin()); data[0] &= ~(7 << 1); // clear out prev lock size data data[0] |= (~index & 0x07) << 1; } else throw std::runtime_error("unknown lock qualifyer: " + item); } lock_data = data; }
bool Registry::StringListToValue(const StringList& list, ByteVector& value) { value.clear(); ByteVector::iterator out= value.begin(); for (StringList::const_iterator i= list.begin() ; i!=list.end() ; ++i) { value.reserve(value.size() + (*i).size()+1); copy((*i).begin(), (*i).end(), out); *out++= 0; } *out++= 0; return true; }
static void setIpAddr(ByteVector &result,mg_con_t *mgp) { // This is the IP address, only IPv4 supported. // If the MS asks for IPv6, it is supposed to accept IPv4 anyway. result = ByteVector(6);// IPv4 address + 2 byte header. // 3GPP 24.008 10.5.6.4 result.setByte(0,0x01); // IETF allocated address, which is all we support. result.setByte(1,0x21); // IPv4. // This is a special case - we cannot use setUIint32 because it converts to network order, // but the ip address is already in network order, which is what 3GPP requires, so just copy it. memcpy(result.begin()+2, &mgp->mg_ip, 4); printf("IP address: %0x\n",mgp->mg_ip); }
void IpmiPayload::deserializeEncryptedRmcpp(ByteVector& outData, const ByteVector& key, const ByteVector& in, size_t& pos) { // deserialize payload deserializeRmcpp(outData, in, pos); // strip IV from payload ByteVector iv(outData.c_ptr(), 16); outData.erase(outData.begin(), outData.begin() + 16); // decrypt payload ByteVector decryptedPayload; CryptoProxy::getInstance()->decrypt(key, iv, outData, decryptedPayload); // verify padding byte_t padLength = decryptedPayload[decryptedPayload.length() - 1]; const byte_t* pad = decryptedPayload.c_ptr(decryptedPayload.length() - padLength -1); for (byte_t i = 1; i <= padLength; ++i, ++pad) { if (*pad != i) throw runtime_error("Incorrect padding on incoming encrypted message"); } // strip padding outData.assign(decryptedPayload.begin(), decryptedPayload.end() - padLength -1); }
void Header::parse(const ByteVector &data) { if(data.size() < size()) return; // do some sanity checking -- even in ID3v2.3.0 and less the tag size is a // synch-safe integer, so all bytes must be less than 128. If this is not // true then this is an invalid tag. // note that we're doing things a little out of order here -- the size is // later in the bytestream than the version ByteVector sizeData = data.mid(6, 4); if(sizeData.size() != 4) { d->tagSize = 0; debug("TagLib::ID3v2::Header::parse() - The tag size as read was 0 bytes!"); return; } for(ByteVector::Iterator it = sizeData.begin(); it != sizeData.end(); it++) { if(uchar(*it) >= 128) { d->tagSize = 0; debug("TagLib::ID3v2::Header::parse() - One of the size bytes in the id3v2 header was greater than the allowed 128."); return; } } // The first three bytes, data[0..2], are the File Identifier, "ID3". (structure 3.1 "file identifier") // Read the version number from the fourth and fifth bytes. d->majorVersion = data[3]; // (structure 3.1 "major version") d->revisionNumber = data[4]; // (structure 3.1 "revision number") // Read the flags, the first four bits of the sixth byte. std::bitset<8> flags(data[5]); d->unsynchronisation = flags[7]; // (structure 3.1.a) d->extendedHeader = flags[6]; // (structure 3.1.b) d->experimentalIndicator = flags[5]; // (structure 3.1.c) d->footerPresent = flags[4]; // (structure 3.1.d) // Get the size from the remaining four bytes (read above) d->tagSize = SynchData::toUInt(sizeData); // (structure 3.1 "size") }
ByteVector ID3v2::Tag::render(int version) const { // We need to render the "tag data" first so that we have to correct size to // render in the tag's header. The "tag data" -- everything that is included // in ID3v2::Header::tagSize() -- includes the extended header, frames and // padding, but does not include the tag's header or footer. if(version != 3 && version != 4) { debug("Unknown ID3v2 version, using ID3v2.4"); version = 4; } // TODO: Render the extended header. // Downgrade the frames that ID3v2.3 doesn't support. FrameList newFrames; newFrames.setAutoDelete(true); FrameList frameList; if(version == 4) { frameList = d->frameList; } else { downgradeFrames(&frameList, &newFrames); } // Reserve a 10-byte blank space for an ID3v2 tag header. ByteVector tagData(Header::size(), '\0'); // Loop through the frames rendering them and adding them to the tagData. for(FrameList::ConstIterator it = frameList.begin(); it != frameList.end(); it++) { (*it)->header()->setVersion(version); if((*it)->header()->frameID().size() != 4) { debug("An ID3v2 frame of unsupported or unknown type \'" + String((*it)->header()->frameID()) + "\' has been discarded"); continue; } if(!(*it)->header()->tagAlterPreservation()) { const ByteVector frameData = (*it)->render(); if(frameData.size() == Frame::headerSize((*it)->header()->version())) { debug("An empty ID3v2 frame \'" + String((*it)->header()->frameID()) + "\' has been discarded"); continue; } tagData.append(frameData); } } // Compute the amount of padding, and append that to tagData. // TODO: Should be calculated in long long in taglib2. long originalSize = d->header.tagSize(); long paddingSize = originalSize - (tagData.size() - Header::size()); if(paddingSize <= 0) { paddingSize = MinPaddingSize; } else { // Padding won't increase beyond 1% of the file size or 1MB. long threshold = d->file ? d->file->length() / 100 : 0; threshold = std::max(threshold, MinPaddingSize); threshold = std::min(threshold, MaxPaddingSize); if(paddingSize > threshold) paddingSize = MinPaddingSize; } tagData.resize(static_cast<unsigned int>(tagData.size() + paddingSize), '\0'); // Set the version and data size. d->header.setMajorVersion(version); d->header.setTagSize(tagData.size() - Header::size()); // TODO: This should eventually include d->footer->render(). const ByteVector headerData = d->header.render(); std::copy(headerData.begin(), headerData.end(), tagData.begin()); return tagData; }
Frame *FrameFactory::createFrame(const ByteVector &origData, Header *tagHeader) const { ByteVector data = origData; uint version = tagHeader->majorVersion(); Frame::Header *header = new Frame::Header(data, version); ByteVector frameID = header->frameID(); // A quick sanity check -- make sure that the frameID is 4 uppercase Latin1 // characters. Also make sure that there is data in the frame. if(!frameID.size() == (version < 3 ? 3 : 4) || header->frameSize() <= uint(header->dataLengthIndicator() ? 4 : 0) || header->frameSize() > data.size()) { delete header; return 0; } for(ByteVector::ConstIterator it = frameID.begin(); it != frameID.end(); it++) { if( (*it < 'A' || *it > 'Z') && (*it < '1' || *it > '9') ) { delete header; return 0; } } if(version > 3 && (tagHeader->unsynchronisation() || header->unsynchronisation())) { // Data lengths are not part of the encoded data, but since they are synch-safe // integers they will be never actually encoded. ByteVector frameData = data.mid(Frame::Header::size(version), header->frameSize()); frameData = SynchData::decode(frameData); data = data.mid(0, Frame::Header::size(version)) + frameData; } // TagLib doesn't mess with encrypted frames, so just treat them // as unknown frames. #if HAVE_ZLIB == 0 if(header->compression()) { debug("Compressed frames are currently not supported."); return new UnknownFrame(data, header); } #endif if(header->encryption()) { debug("Encrypted frames are currently not supported."); return new UnknownFrame(data, header); } if(!updateFrame(header)) { header->setTagAlterPreservation(true); return new UnknownFrame(data, header); } // updateFrame() might have updated the frame ID. frameID = header->frameID(); // This is where things get necissarily nasty. Here we determine which // Frame subclass (or if none is found simply an Frame) based // on the frame ID. Since there are a lot of possibilities, that means // a lot of if blocks. // Text Identification (frames 4.2) if(frameID.startsWith("T")) { TextIdentificationFrame *f = frameID != "TXXX" ? new TextIdentificationFrame(data, header) : new UserTextIdentificationFrame(data, header); d->setTextEncoding(f); if(frameID == "TCON") updateGenre(f); return f; } // Comments (frames 4.10) if(frameID == "COMM") { CommentsFrame *f = new CommentsFrame(data, header); d->setTextEncoding(f); return f; } // Attached Picture (frames 4.14) if(frameID == "APIC") { AttachedPictureFrame *f = new AttachedPictureFrame(data, header); d->setTextEncoding(f); return f; } // ID3v2.2 Attached Picture if(frameID == "PIC") { AttachedPictureFrame *f = new AttachedPictureFrameV22(data, header); d->setTextEncoding(f); return f; } // Relative Volume Adjustment (frames 4.11) if(frameID == "RVA2") return new RelativeVolumeFrame(data, header); // Unique File Identifier (frames 4.1) if(frameID == "UFID") return new UniqueFileIdentifierFrame(data, header); // General Encapsulated Object (frames 4.15) if(frameID == "GEOB") { GeneralEncapsulatedObjectFrame *f = new GeneralEncapsulatedObjectFrame(data, header); d->setTextEncoding(f); return f; } // URL link (frames 4.3) if(frameID.startsWith("W")) { if(frameID != "WXXX") { return new UrlLinkFrame(data, header); } else { UserUrlLinkFrame *f = new UserUrlLinkFrame(data, header); d->setTextEncoding(f); return f; } } // Unsynchronized lyric/text transcription (frames 4.8) if(frameID == "USLT") { UnsynchronizedLyricsFrame *f = new UnsynchronizedLyricsFrame(data, header); if(d->useDefaultEncoding) f->setTextEncoding(d->defaultEncoding); return f; } // Popularimeter (frames 4.17) if(frameID == "POPM") return new PopularimeterFrame(data, header); // Private (frames 4.27) if(frameID == "PRIV") return new PrivateFrame(data, header); return new UnknownFrame(data, header); }
List<Ogg::Page *> Ogg::Page::paginate(const ByteVectorList &packets, PaginationStrategy strategy, uint streamSerialNumber, int firstPage, bool firstPacketContinued, bool lastPacketCompleted, bool containsLastPacket) { List<Page *> l; int totalSize = 0; for(ByteVectorList::ConstIterator it = packets.begin(); it != packets.end(); ++it) totalSize += (*it).size(); // Handle creation of multiple pages with appropriate pagination. if(strategy == Repaginate || totalSize + packets.size() > 255 * 255) { // SPLITSIZE must be a multiple of 255 in order to get the lacing values right // create pages of about 8KB each #define SPLITSIZE (32*255) int pageIndex = 0; for(ByteVectorList::ConstIterator it = packets.begin(); it != packets.end(); ++it) { bool continued = false; // mark very first packet? if(firstPacketContinued && it==packets.begin()) { continued = true; } // append to buf ByteVector packetBuf; packetBuf.append(*it); while(packetBuf.size() > SPLITSIZE) { // output a Page ByteVector packetForOnePage; packetForOnePage.resize(SPLITSIZE); std::copy(packetBuf.begin(), packetBuf.begin() + SPLITSIZE, packetForOnePage.begin()); ByteVectorList packetList; packetList.append(packetForOnePage); Page *p = new Page(packetList, streamSerialNumber, firstPage+pageIndex, continued, false, false); l.append(p); pageIndex++; continued = true; packetBuf = packetBuf.mid(SPLITSIZE); } ByteVectorList::ConstIterator jt = it; ++jt; bool lastPacketInList = (jt == packets.end()); // output a page for the rest (we output one packet per page, so this one should be completed) ByteVectorList packetList; packetList.append(packetBuf); bool isVeryLastPacket = false; if(containsLastPacket) { // mark the very last output page as last of stream ByteVectorList::ConstIterator jt = it; ++jt; if(jt == packets.end()) { isVeryLastPacket = true; } } Page *p = new Page(packetList, streamSerialNumber, firstPage+pageIndex, continued, lastPacketInList ? lastPacketCompleted : true, isVeryLastPacket); pageIndex++; l.append(p); } } else { Page *p = new Page(packets, streamSerialNumber, firstPage, firstPacketContinued, lastPacketCompleted, containsLastPacket); l.append(p); } return l; }
Frame *FrameFactory::createFrame(const ByteVector &data, uint version) const { Frame::Header *header = new Frame::Header(data, version); ByteVector frameID = header->frameID(); // A quick sanity check -- make sure that the frameID is 4 uppercase Latin1 // characters. Also make sure that there is data in the frame. if(!frameID.size() == (version < 3 ? 3 : 4) || header->frameSize() <= 0 || header->frameSize() > data.size()) { delete header; return 0; } for(ByteVector::ConstIterator it = frameID.begin(); it != frameID.end(); it++) { if( (*it < 'A' || *it > 'Z') && (*it < '1' || *it > '9') ) { delete header; return 0; } } // TagLib doesn't mess with encrypted frames, so just treat them // as unknown frames. #if HAVE_ZLIB == 0 if(header->compression()) { debug("Compressed frames are currently not supported."); return new UnknownFrame(data, header); } #endif if(header->encryption()) { debug("Encrypted frames are currently not supported."); return new UnknownFrame(data, header); } if(!updateFrame(header)) { header->setTagAlterPreservation(true); return new UnknownFrame(data, header); } // updateFrame() might have updated the frame ID. frameID = header->frameID(); // This is where things get necissarily nasty. Here we determine which // Frame subclass (or if none is found simply an Frame) based // on the frame ID. Since there are a lot of possibilities, that means // a lot of if blocks. // Text Identification (frames 4.2) if(frameID.startsWith("T")) { TextIdentificationFrame *f = frameID != "TXXX" ? new TextIdentificationFrame(data, header) : new UserTextIdentificationFrame(data, header); if(d->useDefaultEncoding) f->setTextEncoding(d->defaultEncoding); if(frameID == "TCON") updateGenre(f); return f; } // Comments (frames 4.10) if(frameID == "COMM") { CommentsFrame *f = new CommentsFrame(data, header); if(d->useDefaultEncoding) f->setTextEncoding(d->defaultEncoding); return f; } // Attached Picture (frames 4.14) if(frameID == "APIC") { AttachedPictureFrame *f = new AttachedPictureFrame(data, header); if(d->useDefaultEncoding) f->setTextEncoding(d->defaultEncoding); return f; } // Relative Volume Adjustment (frames 4.11) if(frameID == "RVA2") return new RelativeVolumeFrame(data, header); // Unique File Identifier (frames 4.1) if(frameID == "UFID") return new UniqueFileIdentifierFrame(data, header); // General Encapsulated Object (frames 4.15) if(frameID == "GEOB") return new GeneralEncapsulatedObjectFrame(data, header); return new UnknownFrame(data, header); }
bool Registry::StringToValue(const std::string& str, ByteVector& value) { value.resize(str.size()); copy(str.begin(), str.end(), value.begin()); return true; }
/** * Runs the operation. */ void ReadWriteThread::run() throw () { try { if (m_card.getType() != MemoryCard::TMemoryCard) { m_exception = new ReadWriteException(QObject::tr("There's no memory card in your " "reader.\nUse the test function in the configuration\ndialog to set up your " "reader properly."), ReadWriteException::CSmartcardError); return; } if (m_write && !m_pin.isNull()) { // try to unlock qDebug() << CURRENT_FUNCTION << "Trying to unlock the card ..."; m_card.verify(m_pin); } if (!m_card.selectFile()) { m_exception = new ReadWriteException(QObject::tr("<qt>It was not possible to select the " "file on the smartcard</qt>"), ReadWriteException::CSmartcardError); return; } if (m_write) { // write the random number ByteVector byteVector(1); byteVector[0] = m_randomNumber; qDebug() << CURRENT_FUNCTION << "Writing random =" << byteVector[0]; m_card.write(0, byteVector); // write the password hash and include a length information ByteVector pwHash = PasswordHash::generateHash(m_password); pwHash.insert(pwHash.begin(), pwHash.size()); m_card.write(1, pwHash); qDebug() << CURRENT_FUNCTION << "Password hash length = " << (pwHash.size()-1); // then write the number of bytes int numberOfBytes = m_bytes.size(); byteVector.resize(3); byteVector[0] = (numberOfBytes & 0xFF00) >> 8; byteVector[1] = numberOfBytes & 0xFF; byteVector[2] = 0; // fillbyte m_card.write(PasswordHash::MAX_HASH_LENGTH+2, byteVector); // and finally write the data m_card.write(PasswordHash::MAX_HASH_LENGTH+5, m_bytes); } else { // read the random number if (m_card.read(0, 1)[0] != m_randomNumber) { m_exception = new ReadWriteException(QObject::tr("You inserted the wrong smartcard!"), ReadWriteException::CSmartcardError); return; } qDebug() << CURRENT_FUNCTION << "Read randomNumber =" << m_randomNumber; // read the password hash, check the password and throw a exception if necessary unsigned char len = m_card.read(1, 1)[0]; ByteVector pwHash = m_card.read(2, len); qDebug() << CURRENT_FUNCTION << "Password hash length =" << len; if (!PasswordHash::isCorrect(m_password, pwHash)) { m_exception = new ReadWriteException(QObject::tr("The given password was wrong."), ReadWriteException::CWrongPassword); return; } // read the number ByteVector vec = m_card.read(PasswordHash::MAX_HASH_LENGTH + 2, 2); int numberOfBytes = (vec[0] << 8) + (vec[1]); qDebug() << CURRENT_FUNCTION << "Read numberOfBytes =" << numberOfBytes; Q_ASSERT(numberOfBytes >= 0); // read the bytes m_bytes = m_card.read(PasswordHash::MAX_HASH_LENGTH+5, numberOfBytes); } } catch (const CardException& e) {
Frame *FrameFactory::createFrame(const ByteVector &origData, const Header *tagHeader) const { ByteVector data = origData; unsigned int version = tagHeader->majorVersion(); Frame::Header *header = new Frame::Header(data, version); ByteVector frameID = header->frameID(); // A quick sanity check -- make sure that the frameID is 4 uppercase Latin1 // characters. Also make sure that there is data in the frame. if(frameID.size() != (version < 3 ? 3 : 4) || header->frameSize() <= static_cast<unsigned int>(header->dataLengthIndicator() ? 4 : 0) || header->frameSize() > data.size()) { delete header; return 0; } #ifndef NO_ITUNES_HACKS if(version == 3 && frameID.size() == 4 && frameID[3] == '\0') { // iTunes v2.3 tags store v2.2 frames - convert now frameID = frameID.mid(0, 3); header->setFrameID(frameID); header->setVersion(2); updateFrame(header); header->setVersion(3); } #endif for(ByteVector::ConstIterator it = frameID.begin(); it != frameID.end(); it++) { if( (*it < 'A' || *it > 'Z') && (*it < '0' || *it > '9') ) { delete header; return 0; } } if(version > 3 && (tagHeader->unsynchronisation() || header->unsynchronisation())) { // Data lengths are not part of the encoded data, but since they are synch-safe // integers they will be never actually encoded. ByteVector frameData = data.mid(Frame::Header::size(version), header->frameSize()); frameData = SynchData::decode(frameData); data = data.mid(0, Frame::Header::size(version)) + frameData; } // TagLib doesn't mess with encrypted frames, so just treat them // as unknown frames. #if !defined(HAVE_ZLIB) || HAVE_ZLIB == 0 if(header->compression()) { debug("Compressed frames are currently not supported."); return new UnknownFrame(data, header); } #endif if(header->encryption()) { debug("Encrypted frames are currently not supported."); return new UnknownFrame(data, header); } if(!updateFrame(header)) { header->setTagAlterPreservation(true); return new UnknownFrame(data, header); } // updateFrame() might have updated the frame ID. frameID = header->frameID(); // This is where things get necissarily nasty. Here we determine which // Frame subclass (or if none is found simply an Frame) based // on the frame ID. Since there are a lot of possibilities, that means // a lot of if blocks. // Text Identification (frames 4.2) // Apple proprietary WFED (Podcast URL) is in fact a text frame. if(frameID.startsWith("T") || frameID == "WFED") { TextIdentificationFrame *f = frameID != "TXXX" ? new TextIdentificationFrame(data, header) : new UserTextIdentificationFrame(data, header); d->setTextEncoding(f); if(frameID == "TCON") updateGenre(f); return f; } // Comments (frames 4.10) if(frameID == "COMM") { CommentsFrame *f = new CommentsFrame(data, header); d->setTextEncoding(f); return f; } // Attached Picture (frames 4.14) if(frameID == "APIC") { AttachedPictureFrame *f = new AttachedPictureFrame(data, header); d->setTextEncoding(f); return f; } // ID3v2.2 Attached Picture if(frameID == "PIC") { AttachedPictureFrame *f = new AttachedPictureFrameV22(data, header); d->setTextEncoding(f); return f; } // Relative Volume Adjustment (frames 4.11) if(frameID == "RVA2") return new RelativeVolumeFrame(data, header); // Unique File Identifier (frames 4.1) if(frameID == "UFID") return new UniqueFileIdentifierFrame(data, header); // General Encapsulated Object (frames 4.15) if(frameID == "GEOB") { GeneralEncapsulatedObjectFrame *f = new GeneralEncapsulatedObjectFrame(data, header); d->setTextEncoding(f); return f; } // URL link (frames 4.3) if(frameID.startsWith("W")) { if(frameID != "WXXX") { return new UrlLinkFrame(data, header); } else { UserUrlLinkFrame *f = new UserUrlLinkFrame(data, header); d->setTextEncoding(f); return f; } } // Unsynchronized lyric/text transcription (frames 4.8) if(frameID == "USLT") { UnsynchronizedLyricsFrame *f = new UnsynchronizedLyricsFrame(data, header); if(d->useDefaultEncoding) f->setTextEncoding(d->defaultEncoding); return f; } // Synchronised lyrics/text (frames 4.9) if(frameID == "SYLT") { SynchronizedLyricsFrame *f = new SynchronizedLyricsFrame(data, header); if(d->useDefaultEncoding) f->setTextEncoding(d->defaultEncoding); return f; } // Event timing codes (frames 4.5) if(frameID == "ETCO") return new EventTimingCodesFrame(data, header); // Popularimeter (frames 4.17) if(frameID == "POPM") return new PopularimeterFrame(data, header); // Private (frames 4.27) if(frameID == "PRIV") return new PrivateFrame(data, header); // Ownership (frames 4.22) if(frameID == "OWNE") { OwnershipFrame *f = new OwnershipFrame(data, header); d->setTextEncoding(f); return f; } // Chapter (ID3v2 chapters 1.0) if(frameID == "CHAP") return new ChapterFrame(tagHeader, data, header); // Table of contents (ID3v2 chapters 1.0) if(frameID == "CTOC") return new TableOfContentsFrame(tagHeader, data, header); // Apple proprietary PCST (Podcast) if(frameID == "PCST") return new PodcastFrame(data, header); return new UnknownFrame(data, header); }
// Call this to update the PCO for retransmission to the MS. // We cannot just make up a PCO ahead of time and then send it out to // all the MS for two reasons: // o The incoming options have uniquifying transaction identifiers that are // different each time, so we must modify the incoming pcoReq each time while // carefully preserving those modifiers. // o There are two major formats for the PCO options - see below. static void setPco(ByteVector &resultpco, ByteVector &pcoReq, mg_con_t *mgp) { if (mg_dns[0] == 0) { ip_finddns(mg_dns); } // GSM 24.008 10.5.6.3: Procotol Configuration Options. // These are the "negotiated" address params wrapped in PPP, // except they are not very negotiated; we are going to cram them // into the MS and it can accept them or die. // The first byte is the header, followed by any number of: // protocol id (2 octets) // length of contents (1 octet) // I have seen this supplied by the MS in two different ways: // - as two separate 0x8021 requests, each with a single option request // (Blackberry) // - as a single 0x8021 request with two option requests for the two DNS servers. // (Samsung phone) resultpco.clone(pcoReq); unsigned char *pc = resultpco.begin(); unsigned char *end = pc + resultpco.size(); __attribute__((unused)) const char *protname = ""; if (pc == NULL) { MGERROR("SGSN: Empty PCO field") } else if (*pc++ != 0x80) { MGERROR("SGSN: Unrecognized PCO Config Protocol: %d\n",pc[-1]); } else while (pc < end) { unsigned proto = (pc[0] << 8) + pc[1]; pc += 2; unsigned ipcplen = *pc++; if (proto == 0x8021) { // IP Control Protocol. // IPCP looks like this: // 1 byte: command: 1 => configure-request // 1 byte: transaction uniquifying identifier. // 2 bytes: total length of ipcp (even though length above was a byte) // Followed by IPCP options, where each option is: // 1 byte: option code // 1 byte: total option length N (should be 6) // N bytes: data if (pc[0] == 1) { // command = configure-request // pc[1] is the uniquifying identifier, leave it alone. // pc[2]&pc[3] are another length. // Followed by one or more 6 byte option consisting of: // pc[4]: IPCP option code // pc[5]: length (6) // pc[6-9]: data // Note: the 4 byte header length is included in the option_len unsigned ipcp_len = pc[3]; // pc[2] better be 0. unsigned char *op; for (op = &pc[4]; op < pc + ipcp_len; op += op[1]) { const char *what = ""; switch (op[0]) { case 0x03: pc[0] = 2; if (op[1] < 6) { goto bad_ipcp_opt_len; } memcpy(&op[2], &mgp->mg_ip, 4); break; case 0x81: // primary dns. pc[0] = 2; // IPCP command = ACK if (op[1] < 6) { bad_ipcp_opt_len: MGERROR("SGSN: Invalid PCO IPCP Config Option Length: opt=0x%x len=%d\n", op[0], op[1]); goto next_protocol; } memcpy(&op[2], &mg_dns[0], 4); // addr in network order. break; case 0x83: // secondary dns pc[0] = 2; // IPCP command = ACK if (op[1] < 6) { goto bad_ipcp_opt_len; } memcpy(&op[2], &mg_dns[mg_dns[1] ? 1 : 0], 4); // addr in network order. break; case 2: what = "IP Compression Protocol"; goto bad_ipcp; case 0x82: what = "primary NBNS [NetBios Name Service]"; goto bad_ipcp; case 0x84: what = "secondary NBNS [NetBios Name Service]"; goto bad_ipcp; default: bad_ipcp: // It would be nice to send an SMS message that the phone is set up improperly. MGWARN("SGSN: warning: ignoring PDP Context activation IPCP option %d %s\n",pc[4],what); break; } } } } else if (proto == 0xc021) { // LCP: protname = "(LCP [Link Control Protocol] for PPP)"; goto unsupported_protocol; } else if (proto == 0xc223) { // CHAP: protname = "(CHAP [Challenge-Handshake Authentication Protocol] for PPP)"; goto unsupported_protocol; } else if (proto == 0xc023) { // PAP: Password authentication protocol. protname = "(PAP [Password Authentication Protocol] for PPP)"; // 6-12: Remove this message for the 3.0 release because we get // lots of bogus complaints about PAP. //goto unsupported_protocol; goto next_protocol; } else { // If we see any of these options are non-empty, the MS may be configured to use PPP. // It is hopeless; user must reconfigure the MS. unsupported_protocol: if (ipcplen) { MGWARN("SGSN: warning: ignoring PDP Context activation sub-protocol 0x%x %s; MS may require reconfiguration.\n",proto,protname); } } next_protocol: pc += ipcplen; } }
Byte calculateImageBrightnessFactor(const std::string& inImageFilePath) { BrightnessState state; InputFile inputFile; ByteVector brightnessValues; DistanceAndBrightnessVector valuesForAverage; inputFile.OpenFile(inImageFilePath); state.mStream = inputFile.GetInputStream(); InitializeDecodingState(state); StartRead(state); LongBufferSizeType samplesSkipping = 1; // max samples 20 if(state.mJPGState.output_width > 500) samplesSkipping = state.mJPGState.output_width / 50; // max samples - 50 else if(state.mJPGState.output_width > 20) samplesSkipping = 10; // max samples - 50 LongBufferSizeType rowsSkipping = 1; // max samples 20 if(state.mJPGState.output_height > 500) rowsSkipping = state.mJPGState.output_height / 50; // max samples - 50 else if(state.mJPGState.output_height > 20) rowsSkipping = 10; // max samples - 50 LongBufferSizeType rowCounter = 0; // read samples from image, converting to hsb and keeping the "b" component, as a brightness factor while(state.mJPGState.output_scanline < state.mJPGState.output_height) { try { state.mTotalSampleRows = jpeg_read_scanlines(&(state.mJPGState), state.mSamplesBuffer, state.mJPGState.rec_outbuf_height); ++rowCounter; if(rowCounter >= rowsSkipping) rowCounter = 0; else if(rowCounter != 1) continue; } catch(HummusJPGException) { state.mTotalSampleRows = 0; } state.mIndexInRow = 0; state.mCurrentSampleRow = 0; while(state.mCurrentSampleRow < state.mTotalSampleRows) { LongBufferSizeType row_stride = state.mJPGState.output_width * state.mJPGState.output_components; // convert samples to HSB (note that some samples are skipped) for(LongBufferSizeType i=0;i<row_stride;i+=(state.mJPGState.output_components*samplesSkipping)) { // get rgb Byte r = state.mSamplesBuffer[state.mCurrentSampleRow][i]; Byte g = state.mSamplesBuffer[state.mCurrentSampleRow][i+1]; Byte b = state.mSamplesBuffer[state.mCurrentSampleRow][i+2]; // calculate brightness [converting to HSB] brightnessValues.push_back(RGBtoHSVtoBrightness(r,g,b)); } ++state.mCurrentSampleRow; } } FinalizeDecoding(state); // prepare distance data and sort, to remove extremes from calculation ByteVector::const_iterator it = brightnessValues.begin(); for(;it!=brightnessValues.end();++it) valuesForAverage.push_back(DistanceAndBrightness(*it,calculateDistance(*it,brightnessValues))); std::sort(valuesForAverage.begin(),valuesForAverage.end(),DistanceAndBrightnessSort); // now simply calculate the average based on the first 2/3 of the vector, to reduce the effects of extremes double average = 0; DistanceAndBrightnessVector::const_iterator itCurrent = valuesForAverage.begin(); unsigned long interestingItemsCount = floor(valuesForAverage.size()*2.0/3.0); DistanceAndBrightnessVector::const_iterator itEnd = valuesForAverage.begin()+interestingItemsCount; for(itCurrent = valuesForAverage.begin();itCurrent!=itEnd;++itCurrent) average+=(double)(itCurrent->brightness)/interestingItemsCount; return ceil(average); }
void SoftwareBreakpointManager::getOpcode(uint32_t type, ByteVector &opcode) const { #if defined(OS_WIN32) && defined(ARCH_ARM) if (type == 4) { static const uint32_t WinARMBPType = 2; DS2LOG(Warning, "requesting a breakpoint of size %u on Windows ARM, " "adjusting to type %u", type, WinARMBPType); type = WinARMBPType; } #endif opcode.clear(); // TODO: We shouldn't have preprocessor checks for ARCH_ARM vs ARCH_ARM64 // because we might be an ARM64 binary debugging an ARM inferior. switch (type) { #if defined(ARCH_ARM) case 2: // udf #1 opcode.push_back('\xde'); #if defined(OS_POSIX) opcode.push_back('\x01'); #elif defined(OS_WIN32) opcode.push_back('\xfe'); #endif break; case 3: // udf.w #0 opcode.push_back('\xa0'); opcode.push_back('\x00'); opcode.push_back('\xf7'); opcode.push_back('\xf0'); break; case 4: // udf #16 opcode.push_back('\xe7'); opcode.push_back('\xf0'); opcode.push_back('\x01'); opcode.push_back('\xf0'); break; #elif defined(ARCH_ARM64) case 4: opcode.push_back('\xd4'); opcode.push_back('\x20'); opcode.push_back('\x20'); opcode.push_back('\x00'); break; #endif default: DS2LOG(Error, "invalid breakpoint type %d", type); DS2BUG("invalid breakpoint type"); break; } #if !(defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE)) #error "Target not supported." #endif #if defined(ENDIAN_LITTLE) std::reverse(opcode.begin(), opcode.end()); #endif }
bool CHttpServer::receive_request(ByteVector &request) { if (verbose) RAWTRACE("Receiving request..."); ByteVector r; char buf[BUF_SIZE]; int attempts = 0; for(;;) { if (verbose) RAWTRACE("Read portion of data from socket..."); int n = recv(m_sock, &buf[0], sizeof(buf), 0); //RAWTRACE1("RECV: %d", n); if (n == -1) { int e = RHO_NET_ERROR_CODE; if (verbose) RAWTRACE1("RECV ERROR: %d", e); #if !defined(WINDOWS_PLATFORM) if (e == EINTR) continue; #else if (e == WSAEINTR) continue; #endif #if defined(OS_WP8) || (defined(RHODES_QT_PLATFORM) && defined(OS_WINDOWS_DESKTOP)) || defined(OS_WINCE) if (e == EAGAIN || e == WSAEWOULDBLOCK) { #else if (e == EAGAIN) { #endif if (!r.empty()) break; if(++attempts > (HTTP_EAGAIN_TIMEOUT*10)) { if (verbose) RAWLOG_ERROR("Error when receiving data from socket. Client does not send data for " HTTP_EAGAIN_TIMEOUT_STR " sec. Cancel recieve."); return false; } fd_set fds; FD_ZERO(&fds); FD_SET(m_sock, &fds); timeval tv = {0}; tv.tv_usec = 100000;//100 MS select(m_sock + 1, &fds, 0, 0, &tv); continue; } if (verbose) RAWLOG_ERROR1("Error when receiving data from socket: %d", e); return false; } if (n == 0) { if(!r.empty()) { if (verbose) RAWTRACE("Client closed connection gracefully"); break; } else { if (verbose) RAWLOG_ERROR("Connection gracefully closed before we receive any data"); return false; } } else { if (verbose) RAWTRACE1("Actually read %d bytes", n); r.insert(r.end(), &buf[0], &buf[0] + n); } } if (!r.empty()) { request.insert(request.end(), r.begin(), r.end()); if ( !rho_conf_getBool("log_skip_post") ) { String strRequest(request.begin(),request.end()); if (verbose) RAWTRACE1("Received request:\n%s", strRequest.c_str()); } } return true; } bool CHttpServer::send_response_impl(String const &data, bool continuation) { #ifdef OS_MACOSX if ( m_localResponseWriter != 0 ) { m_localResponseWriter->writeResponse( data ); return true; } #endif if (verbose) { if (continuation) if (verbose) RAWTRACE("Send continuation data..."); else if (verbose) RAWTRACE("Sending response..."); } // First of all, make socket blocking #if defined(WINDOWS_PLATFORM) unsigned long optval = 0; if(::ioctlsocket(m_sock, FIONBIO, &optval) == SOCKET_ERROR) { RAWLOG_ERROR1("Can not set blocking socket mode: %d", RHO_NET_ERROR_CODE); return false; } #else int flags = fcntl(m_sock, F_GETFL); if (flags == -1) { if (verbose) RAWLOG_ERROR1("Can not get current socket mode: %d", errno); return false; } if (fcntl(m_sock, F_SETFL, flags & ~O_NONBLOCK) == -1) { if (verbose) RAWLOG_ERROR1("Can not set blocking socket mode: %d", errno); return false; } #endif size_t pos = 0; for(; pos < data.size();) { int n = send(m_sock, data.c_str() + pos, data.size() - pos, 0); if (n == -1) { int e = RHO_NET_ERROR_CODE; #if !defined(WINDOWS_PLATFORM) if (e == EINTR) continue; #endif if (verbose) RAWLOG_ERROR1("Can not send response data: %d", e); return false; } if (n == 0) break; pos += n; } //String dbg_response = response.size() > 100 ? response.substr(0, 100) : response; //RAWTRACE2("Sent response:\n%s%s", dbg_response.c_str(), response.size() > 100 ? "..." : " "); if (continuation) { if (verbose) RAWTRACE1("Sent response body: %d bytes", data.size()); } else if ( !rho_conf_getBool("log_skip_post") ) { if (verbose) RAWTRACE1("Sent response (only headers displayed):\n%s", data.c_str()); } return true; } bool CHttpServer::send_response(String const &response, bool redirect) { #ifdef OS_ANDROID if (redirect) { CAutoPtr<IRhoThreadImpl> ptrThread = rho_get_RhoClassFactory()->createThreadImpl(); ptrThread->sleep(20); } #endif return send_response_impl(response, false); } String CHttpServer::create_response(String const &reason) { return create_response(reason, ""); } String CHttpServer::create_response(String const &reason, HeaderList const &headers) { return create_response(reason, headers, ""); } String CHttpServer::create_response(String const &reason, String const &body) { return create_response(reason, HeaderList(), body); } String CHttpServer::create_response(String const &reason, HeaderList const &hdrs, String const &body) { String response = "HTTP/1.1 "; response += reason; response += "\r\n"; char buf[50]; snprintf(buf, sizeof(buf), "%d", m_port); HeaderList headers; headers.push_back(Header("Host", String("127.0.0.1:") + buf)); headers.push_back(Header("Connection", "close")); headers.push_back(HttpHeader("Access-Control-Allow-Origin", "*")); std::copy(hdrs.begin(), hdrs.end(), std::back_inserter(headers)); for(HeaderList::const_iterator it = headers.begin(), lim = headers.end(); it != lim; ++it) { response += it->name; response += ": "; response += it->value; response += "\r\n"; } response += "\r\n"; response += body; return response; }
int CryptoManager::verify_callback(int preverify_ok, X509_STORE_CTX *ctx) { int err = X509_STORE_CTX_get_error(ctx); SSL* ssl = (SSL*)X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx()); SSLVerifyData* verifyData = (SSLVerifyData*)SSL_get_ex_data(ssl, CryptoManager::idxVerifyData); // TODO: we should make sure that the trusted certificate store never overules KeyPrint, if present, because certificate pinning on an individual certificate is a stronger method of verification. // verifyData is unset only when KeyPrint has been pinned and we are not skipping errors due to incomplete chains // we can fail here f.ex. if the certificate has expired but is still pinned with KeyPrint if (!verifyData) return preverify_ok; bool allowUntrusted = verifyData->first; string keyp = verifyData->second; if (!keyp.empty()) { X509* cert = X509_STORE_CTX_get_current_cert(ctx); if (!cert) return 0; string kp2(keyp); if (kp2.compare(0, 12, "trusted_keyp") == 0) { // Possible follow up errors, after verification of a partial chain if (err == X509_V_ERR_CERT_UNTRUSTED || err == X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE) { X509_STORE_CTX_set_error(ctx, X509_V_OK); return 1; } } else if (kp2.compare(0, 7, "SHA256/") != 0) return allowUntrusted ? 1 : 0; ByteVector kp = ssl::X509_digest(cert, EVP_sha256()); ByteVector kp2v(kp.size()); Encoder::fromBase32(&kp2[7], &kp2v[0], kp2v.size()); if (std::equal(kp.begin(), kp.end(), kp2v.begin())) { // KeyPrint validated, we can get rid of it (to avoid unnecessary passes) SSL_set_ex_data(ssl, CryptoManager::idxVerifyData, NULL); if (err != X509_V_OK) { // This is the right way to get the certificate store, although it is rather roundabout X509_STORE* store = SSL_CTX_get_cert_store(SSL_get_SSL_CTX(ssl)); dcassert(store == ctx->ctx); // Hide the potential library error about trying to add a dupe ERR_set_mark(); if (X509_STORE_add_cert(store, cert)) { X509_STORE_CTX_set_error(ctx, X509_V_OK); X509_verify_cert(ctx); err = X509_STORE_CTX_get_error(ctx); } else ERR_pop_to_mark(); // KeyPrint was not root certificate or we don't have the issuer certificate, the best we can do is trust the pinned KeyPrint if (err == X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN || err == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY || err == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT) { X509_STORE_CTX_set_error(ctx, X509_V_OK); // Set this to allow ignoring any follow up errors caused by the incomplete chain SSL_set_ex_data(ssl, CryptoManager::idxVerifyData, &CryptoManager::trustedKeyprint); return 1; } } return (err == X509_V_OK) ? 1 : 0; } else { if (X509_STORE_CTX_get_error_depth(ctx) > 0) return 1; } } if (allowUntrusted) { /* // We let untrusted certificates through unconditionally, when allowed, but we like to complain if (!preverify_ok && err != X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) { X509* cert = NULL; if ((cert = X509_STORE_CTX_get_current_cert(ctx)) != NULL) { X509_NAME* subject = X509_get_subject_name(cert); string tmp, line; tmp = getNameEntryByNID(subject, NID_commonName); if (!tmp.empty()) { CID certCID(tmp); if (certCID) tmp = Util::listToString(ClientManager::getInstance()->getNicks(certCID)); line += (!line.empty() ? ", " : "") + tmp; } tmp = getNameEntryByNID(subject, NID_organizationName); if (!tmp.empty()) line += (!line.empty() ? ", " : "") + tmp; ByteVector kp = ssl::X509_digest(cert, EVP_sha256()); string keyp = "SHA256/" + Encoder::toBase32(&kp[0], kp.size()); LogManager::getInstance()->message(STRING_F(VERIFY_CERT_FAILED, line % X509_verify_cert_error_string(err) % keyp), LogManager::LOG_INFO); } }*/ return 1; } return preverify_ok; }