コード例 #1
0
 // Returns the usable size for a chunk, meaning the amount of bytes from the
 // beginning of the user data to the end of the backend allocated chunk.
 static INLINE uptr getUsableSize(const void *Ptr, UnpackedHeader *Header) {
   const uptr ClassId = Header->ClassId;
   if (ClassId)
     return PrimaryT::ClassIdToSize(ClassId) - getHeaderSize() -
         (Header->Offset << MinAlignmentLog);
   return SecondaryT::GetActuallyAllocatedSize(
       getBackendPtr(Ptr, Header)) - getHeaderSize();
 }
コード例 #2
0
 // Returns the size the user requested when allocating the chunk.
 static INLINE uptr getSize(const void *Ptr, UnpackedHeader *Header) {
   const uptr SizeOrUnusedBytes = Header->SizeOrUnusedBytes;
   if (Header->ClassId)
     return SizeOrUnusedBytes;
   return SecondaryT::GetActuallyAllocatedSize(
       getBackendPtr(Ptr, Header)) - getHeaderSize() - SizeOrUnusedBytes;
 }
コード例 #3
0
ファイル: robot_control.c プロジェクト: k3po/k3po.c
/*
** Classifies the header of the given message into an event
** Returns -1 if the message header is not recognized or error occurs
**
** Arguments:
** evt - event to be set to the classified header
** msg - the message with the header to be classified
*/
int classifyMessage(event * evt, char * msg){
	int size = getHeaderSize(msg);
	if(size == -1){
		return -1;
	}
	char * header = malloc((size + 1) * sizeof(char));
	if(header == NULL){
		perror("malloc");
		return -1;
	}
	memcpy(header, msg, size);
	*(header + size * sizeof(char)) = '\0';
	if(strcmp(header, "PREPARED") == 0){
		*evt = PREPARED;
	}
	else if(strcmp(header, "STARTED") == 0){
		*evt = STARTED;
	}
	else if(strcmp(header, "FINISHED") == 0){
		*evt = FINISHED;
	}
	else if(strcmp(header, "ERROR") == 0){
		*evt = ERROR;
	}
	else{
		fprintf(stderr, "Header in received message not recognized:\n Header: %s\nMessage: %s\n", header, msg);
		free(header);
		return -1;
	}
	free(header);
	return 0;
}
コード例 #4
0
    void resized() override
    {
        auto bounds = getLocalBounds();
        auto headerBounds = bounds.removeFromTop (getHeaderSize());

        if (customHeaderComponent != nullptr)
            customHeaderComponent->setBounds (headerBounds);

        component->setBounds (bounds);
    }
コード例 #5
0
ファイル: midi.cpp プロジェクト: bmahlbrand/midization
int 
MidiFile::setHeaderSize() {
	_fileHeader._size = getHeaderSize();

	fprintf(stderr, "size %lu\n", _fileHeader._size);
	if (_fileHeader._size != 6)
		fprintf(stderr, "%s %lu\n", "Error, bad size", _fileHeader._size);

	assert(_fileHeader._size == 6);
	return 0;
}
コード例 #6
0
//<"LSCH"><CeHeader><CacheKey><ResponseHeader><ResponseBody>
int DirHashCacheEntry::loadCeHeader()
{
    int fd = getFdStore();
    if ( fd == -1 )
    {
        errno = EBADF;
        return -1;
    }
    if ( nio_lseek( fd, getStartOffset(), SEEK_SET ) == -1 )
        return -1;
    char achBuf[4 + sizeof( CeHeader ) ];
    if ( (size_t)nio_read( fd, achBuf, 4 + sizeof( CeHeader ) ) 
                < 4 + sizeof( CeHeader ) )
        return -1;
//  if ( *( uint32_t *)achBuf != CE_ID )
//     return -1;
    if (memcmp(achBuf, CE_ID, 4) != 0)
        return -1;
    
    memmove( &getHeader(), &achBuf[4], sizeof( CeHeader ) );
    int len = getHeader().m_keyLen;
    if ( len > 0 )
    {
        char * p = getKey().prealloc( len+1 );
        if ( !p )   
            return -1;
        if ( nio_read( fd, p, len ) < len )
            return -1;
        *(p+len) = 0;
    }
    
    char tmpBUf[4096];
#ifdef CACHE_RESP_HEADER
    if (getHeader().m_valPart1Len < 4096 ) //< 4K
    {
        if ( nio_read( fd, tmpBUf, getHeader().m_valPart1Len ) < getHeader().m_valPart1Len )
            return -1;
        
        m_sRespHeader.append(tmpBUf, getHeader().m_valPart1Len);
    }
#endif

    //load part3 to buffer
    int part3offset = getHeaderSize() + getContentTotalLen();
    if ( nio_lseek( fd, part3offset, SEEK_SET ) != -1 )
    {
        while((len = nio_read( fd, tmpBUf, 4096 )) > 0)
            m_sPart3Buf.append(tmpBUf, len);
    }
    
    return 0;

}
コード例 #7
0
ZipLocalFileHeader::ZipLocalFileHeader(std::istream& inp, bool assumeHeaderRead, ParseCallback& callback):
    _forceZip64(false),
    _rawHeader(),
    _startPos(inp.tellg()),
    _endPos(-1),
    _fileName(),
    _lastModifiedAt(),
    _extraField(),
    _crc32(0),
    _compressedSize(0),
    _uncompressedSize(0)
{
    poco_assert_dbg( (EXTRA_FIELD_POS+EXTRA_FIELD_LENGTH) == FULLHEADER_SIZE);

    if (assumeHeaderRead)
        _startPos -= ZipCommon::HEADER_SIZE;

    parse(inp, assumeHeaderRead);

    bool ok = callback.handleZipEntry(inp, *this);

    if (ok)
    {
        if (searchCRCAndSizesAfterData())
        {
            char header[ZipCommon::HEADER_SIZE]={'\x00', '\x00', '\x00', '\x00'};
            inp.read(header, ZipCommon::HEADER_SIZE);
            if (std::memcmp(header, ZipDataInfo64::HEADER, sizeof(header)) == 0) 
            {
                ZipDataInfo64 nfo(inp, true);
                setCRC(nfo.getCRC32());
                setCompressedSize(nfo.getCompressedSize());
                setUncompressedSize(nfo.getUncompressedSize());
            } 
            else 
            {
                ZipDataInfo nfo(inp, true);
                setCRC(nfo.getCRC32());
                setCompressedSize(nfo.getCompressedSize());
                setUncompressedSize(nfo.getUncompressedSize());
            }
        }
    }
    else
    {
        poco_assert_dbg(!searchCRCAndSizesAfterData());
        ZipUtil::sync(inp);
    }
    _endPos = _startPos + getHeaderSize() + _compressedSize; // exclude the data block!
}
コード例 #8
0
ファイル: Steg.cpp プロジェクト: Xerxes004/steganographizer
/**
 * Scrubs an image of all secret messages so you can hide your tracks!
 * 
 * @param image the image to scrub
 */
void Steg::scrub(const std::string &image)
{
	std::vector<char> scrubbedBytes;
	read(scrubbedBytes, image);
	auto throwOut = getHeaderSize(scrubbedBytes);

	for (int i = throwOut; i < scrubbedBytes.size(); i++)
	{
		// set all low-order bits to 1
		setBit(scrubbedBytes.at(i), 0, 1);
	}

	write(scrubbedBytes, image);
}
コード例 #9
0
bool ResourceFileWriter::write()
{
    ofstream outputFile(myFilePath.c_str(), ios::out | ios::binary);
    if(!outputFile.is_open()) // make sure the file is open
    {
        return false;
    }

    int headerSize = getHeaderSize(); // calculate how many bytes the header will be

    // write the header information
    writeNumber(outputFile, magicWord);
    writeNumber(outputFile, headerSize);
    writeNumber(outputFile, myEntries.size());

    // write the file table
    int currentOffset = headerSize;
    for(map<string, ResourceFileEntry *>::iterator i = myEntries.begin(); i != myEntries.end(); i++)
    {
        ResourceFileEntry * entry = (*i).second;
        entry->setOffset(currentOffset);

        outputFile << entry->name() << '\0';
        writeNumber(outputFile, entry->fileSize());
        writeNumber(outputFile, currentOffset);

        currentOffset += entry->fileSize();
    }

    // input all source files
    ifstream inputFile;
    for(map<string, ResourceFileEntry *>::iterator i = myEntries.begin(); i != myEntries.end(); i++)
    {
        ResourceFileEntry * entry = (*i).second;

        inputFile.open(entry->filePath().c_str(), ios::in | ios::binary);

        outputFile << inputFile.rdbuf();

        inputFile.close();
    }

    outputFile.close();

    return true;
}
コード例 #10
0
void JpegPayload::marshallHeader()
{
    int header_size = getHeaderSize();
    BOOST_VERIFY(header_size >= 0);

    m_header_buf = new unsigned char[header_size];

    marshallMainHeader();

    if (m_restart_marker_header_is_existed)
    {
        marshallRestartMarkerHeader();
    }
    if (m_quantization_table_header_is_existed)
    {
        marshallQuantizationTableHeader();
    }
}
コード例 #11
0
ファイル: socketTools.c プロジェクト: bravealdus/webclient
/**
 * Prints the IS parsing as browser to the std output
 */
int tcp_pocessServerResponse(int socket) {
	int max = 2000;
	char *buffer = malloc(max);

	FILE *fp = NULL;

	int filetype;

	int nbytes = max;
	while ((nbytes = read(socket, buffer, max)) != 0) {

		if (nbytes == TCP_ERROR && errno == EINTR) {
			tcp_pocessServerResponse(socket);
		}

		char *headerSize = getHeaderSize(buffer, &nbytes);
		if ( headerSize != 0) {
			filetype = getFileType(buffer);
			buffer = headerSize;
		}

		switch (filetype) {
		case text:
			printWbePage(buffer, nbytes);
			break;
		case image:
			fp = saveImage(nbytes, fp, buffer);
			break;

		default:
			break;
		}

		buffer = malloc(max);
	}

	free(buffer);

	if(fp != NULL){
		fclose(fp);
	}

	return EXIT_SUCCESS;
}
コード例 #12
0
ファイル: ctp_plus_proto_node.c プロジェクト: turon/mantis
void app_recv() {
    static comBuf * buffer;
    static uint8_t  headerSize;
    static uint8_t  from_seqNo = 0;
    static uint16_t originator = 0;
   
    while (1) {
        /* receive data frames from base */
        buffer = net_recv(CTP_LISTENING_PORT);

#ifdef KEEP_CTP_HEADER
        /* parse ctp header */
        ctp_dl_data_header_t * dh = (ctp_dl_data_header_t *) buffer->data;
        if((is_base && (dh->type != AM_CTP_DATA)) || ((!is_base) && (dh->type != AM_CTP_DL_DATA)) )
        {
           printf("\nReceived a frame type %C, not %s", dh->type, is_base?"CTP_DATA":"CTP_DL_DATA");
        }
        else 
        {
           originator = (dh->originHigh << 8) | (dh->originLow & 0xff);
           from_seqNo =  dh->originSeqNo;
        }
        headerSize = getHeaderSize(dh->type);
        memcpy(buffer->data, &(buffer->data[headerSize]), buffer->size-headerSize);
        buffer->size -= headerSize;
#endif
        /* parse app layer header. Header format (app_type, seqNo) */
        app_header_t * appHeader = (app_header_t *) buffer->data;
        if(appHeader->type == APP_ACK) { 
           printf(header_info, "APP_ACK", buffer->size, appHeader->seqNo, originator);
        } 
        else if(appHeader->type == APP_DATA) {
           printf(header_info, "APP_DATA", buffer->size, appHeader->seqNo, originator);
        } else {
           printf(header_info1, buffer->size, appHeader->type, originator);
        }  
          
        com_free_buf(buffer);
    }
}
コード例 #13
0
ファイル: Steg.cpp プロジェクト: Xerxes004/steganographizer
/**
 * Extracts a payload from a vector of bytes. The low-order bit of each byte
 * forms part of a character. One lower-order bit from 8 bytes forms a 
 * character.
 * 
 * @param payload the payload extracted from the bytes
 * @param modifiedBytes the bytes that have payload data in them
 */
bool Steg::extractPayload(std::string &payload, 
	 const std::vector<char> &modifiedBytes)
{
	auto dataStart = getHeaderSize(modifiedBytes);
	std::vector<char> payloadBytes;

	for (int i = dataStart; i < modifiedBytes.size(); i += 8)
	{
		char c = char(0);

		for (int j = 0; j < 8; j++)
		{
			// set the j'th bit in char c equal to the lowest-order bit at i + j
			// of the modified bytes. This effectively looks at the next 8 
			// bytes, and reconstructs a character from their lowest-order bits.
			setBit(c, j, getBit(modifiedBytes.at(i + j), 0));
		}

		if (isAscii(c))
		{
			payloadBytes.push_back(c);
		}
		else
		{
			// a non-ascii character was found, so the operation is aborted
			return false;
		}

		// stop at a null char
		if (payloadBytes.back() == '\0')
		{
			break;
		}
	}

	// construct a string from the characters
	payload = std::string(payloadBytes.begin(), payloadBytes.end());

	return true;
}
コード例 #14
0
ファイル: Steg.cpp プロジェクト: Xerxes004/steganographizer
/**
 * Attaches a secret payload to the bytes of a BMP file.
 * 
 * @param modifiedBytes the bytes that have been modified to store the payload
 * @param originalBytes the bytes of the original BMP file
 * @param payload the secret message that will be stored in the modifiedBytes
 */
void Steg::equipPayload(std::vector<char> &modifiedBytes,
 	 const std::vector<char> &originalBytes, const std::string payload)
{
	modifiedBytes = originalBytes;

	std::vector<unsigned short> expansion;
	expandPayload(expansion, payload);

	int throwOut = getHeaderSize(originalBytes);

	if (modifiedBytes.size() - throwOut < expansion.size())
	{
		throw std::runtime_error("Image is not big enough to hold this data!");
	}
	
	int i = throwOut;

	for (unsigned short val : expansion)
	{
		// set the lowest-order bit of this byte to the value of val
		setBit(modifiedBytes.at(i++), 0, val);
	}
}
コード例 #15
0
ファイル: juce_ConcertinaPanel.cpp プロジェクト: AGenews/GUI
 void resized()
 {
     component->setBounds (getLocalBounds().withTop (getHeaderSize()));
 }
コード例 #16
0
 static INLINE
 const AtomicPackedHeader *getConstAtomicHeader(const void *Ptr) {
   return reinterpret_cast<const AtomicPackedHeader *>(
       reinterpret_cast<uptr>(Ptr) - getHeaderSize());
 }
コード例 #17
0
ファイル: Steg.cpp プロジェクト: Xerxes004/steganographizer
/**
 * Analyzes the a BMP file to allow the user to plan their message length
 * appropriately.
 * 
 * @param image the name of the image to analyze
 */
void Steg::analyze(const std::string &image)
{
	std::vector<char> bytes;
	read(bytes, image);

	const unsigned int dWord = 
		bytes.at(0) << 24 | 
		bytes.at(1) << 16 | 
		bytes.at(2) << 8  | 
		bytes.at(3);
	
	auto header = getHeaderSize(bytes);
	
	unsigned short imageType = 0;

	switch (header)
	{
	case 10:
		imageType = 1;
		break;

	case 16:
		imageType = 2;
		break;

	case 54:
		imageType = 3;
		break;

	case 122:
		imageType = 4;
		break;

	default:
		imageType = -1;
		break;
	}

	std::cout << "  Analyzing \"" << image << "\"" << std::endl;
	std::cout << "    Image size : " << bytes.size() << " bytes\n";
	std::cout << "    Header size: " << header << " bytes" << std::endl;
	std::cout << "    BMP type   : " << imageType << std::endl;
	std::cout << "    Max payload: " 
	          << ((bytes.size() - getHeaderSize(bytes)) / 8) - 1
	          << " characters\n";

    bool encrypted = true;

    std::string payload;
	
	if (!extractPayload(payload, bytes))
	{
    	encrypted = false;
    }

    std::cout << "    This image ";
    
    if (encrypted)
    {
    	std::cout << "may be ";
    }
    else
    {
    	std::cout << "is probably not ";
    }

    std::cout << "encrypted.\n";
}
コード例 #18
0
 // We can't use the offset member of the chunk itself, as we would double
 // fetch it without any warranty that it wouldn't have been tampered. To
 // prevent this, we work with a local copy of the header.
 static INLINE void *getBackendPtr(const void *Ptr, UnpackedHeader *Header) {
   return reinterpret_cast<void *>(reinterpret_cast<uptr>(Ptr) -
       getHeaderSize() - (Header->Offset << MinAlignmentLog));
 }
コード例 #19
0
JNIEXPORT jint JNICALL Java_org_theonionphone_protocol_SrtpProtocol_getHeaderSize
	(JNIEnv *env, jobject obj) {

	return getHeaderSize();
}
コード例 #20
0
/**
 * Read the program meta data and the image data from a file, with
 * image validation.
 *
 * @param handle The input file handle.
 *
 * @return A BufferClass instance containing the program data, or OREF_NULL
 *         if the file is not a valid image.
 */
BufferClass *ProgramMetaData::read(RexxString *fileName, FILE *handle)
{
    bool badVersion = false;
    size_t headerSize = getHeaderSize();
    size_t readSize;

    // now read the control info
    readSize = fread((char *)this, 1, headerSize, handle);
    // if we could read the header, validate all of the meta information
    if (readSize < headerSize || !validate(badVersion))
    {
        // if this failed because we couldn't read in the required header, or
        // because of the version signature, we need to raise an error now.
        if (readSize < headerSize || badVersion)
        {
            fclose(handle);
            reportException(Error_Program_unreadable_version, fileName);
        }

        // if it didn't validate, it might be because we have a unix-style "hash bang" line at the
        // beginning of the file.  The first read in bit has a "#!", then we need to read
        // beyond the first linend and try again.
        if (fileTag[0] == '#' && fileTag[1] == '!')
        {
            // back to the start (ok, just past the hash bang)
            fseek(handle, 2, SEEK_SET);

            while (true)
            {
                if (fread(fileTag, 1, 1, handle) <= 0)
                {
                    fclose(handle);
                    return OREF_NULL;
                }
                // if we hit a newline, this is our stopping point.
                // NB:  this works with both \n and \r\n sequences.
                if (fileTag[0] == '\n')
                {
                    break;
                }
                // ok, try to read the control information one more time.
                // if this doesn't work, no point in being pushy about it.
                readSize = fread((char *)this, 1, headerSize, handle);
                // if we could read the header, validate all of the meta information
                if (readSize < headerSize || !validate(badVersion))
                {
                    fclose(handle);                    /* close the file                    */
                    // if because we couldn't read in the required header, or
                    // because of a bad version sig, we can close now
                    if (readSize < headerSize || badVersion)
                    {
                        reportException(Error_Program_unreadable_version, fileName);
                    }
                    return OREF_NULL;
                }
            }
        }
    }
    BufferClass *buffer = new_buffer(imageSize);
    ProtectedObject p(buffer);
    readSize = fread(buffer->getData(), 1, imageSize, handle);
    if (readSize < imageSize)
    {
        fclose(handle);
        reportException(Error_Program_unreadable_version, fileName);
        return OREF_NULL;
    }
    return buffer;
}
コード例 #21
0
ファイル: node.cpp プロジェクト: nicosuarez/orgdatos
unsigned int Node::getFreeSize()const{
	if(size>usedSize+getHeaderSize())
		return (size-usedSize-getHeaderSize());
	return 0;
}
コード例 #22
0
ファイル: hufc.c プロジェクト: brokendragon/PERDICE
void descomprimir(FILE *fpin, FILE *fpout, struct nodo *raiz, struct header *h, int verbose)
{
	BYTE buf_lec[BUF_SZ], buf_esc[BUF_SZ], b;
	int pos_buf_lec, pos_pos=0, nbits, cont=0;
	struct nodo *tmp=raiz;
	float completado=0.0F, inc;
	struct stat statbuf;


	if (verbose)
	{
		fstat(fileno(fpin), &statbuf);
		inc = (BUF_SZ*100.0F) / statbuf.st_size;
		if (inc > 100.0F)
			inc=100.0F;

		printf("Expanding... 0%%");
	}

	fseek(fpin, getHeaderSize(h), SEEK_SET);

	for (;;)
	{
		pos_buf_lec=0;
		nbits=fread(buf_lec, 1, BUF_SZ, fpin);
		if (ferror(fpin))
		{
			perror("fread: descomprimir()");
			exit(1);
		}

		nbits<<=3;	// nbits*=8;
		if (feof(fpin))
		{
			nbits-=h->padding_bits;
			if (h->deterr != DONT_USE_ERR_DET)
				nbits-=16;
		}

		while (nbits != 0)
		{
			/*
			 * Esta comprobacion es necesaria por si se
			 * comprimio un fichero en el que todos los
			 * caracteres son el mismo, ya que el arbol
			 * solo tendra un nodo, la raiz
			 */
			if (tmp->hizq != NULL)
			{
				readBits(buf_lec, &pos_buf_lec, &pos_pos, &b, 1);
				if (b == 0)
					tmp=tmp->hizq;
				else
					tmp=tmp->hdch;
			}

			if (tmp->hizq == NULL)	// Hoja
			{
				buf_esc[cont]=tmp->c;
				cont++;
				if (cont == BUF_SZ)
				{
					cont=0;
					fwrite(buf_esc, 1, BUF_SZ, fpout);
					if (ferror(fpout))
					{
						perror("fwrite: descomprimir()");
						exit(1);
					}
				}

				tmp=raiz;
			}

			nbits--;
		}

		if (verbose)
		{
			if ((int)completado == 100)
				printf("\b\b");
			else if ((int)completado >= 10)
				printf("\b");

			completado+=inc;
			if ((int)completado > 100)
				completado=100.0F;
			printf("\b\b%d%%", (int)completado);
		}

		if (feof(fpin))
		{
			fwrite(buf_esc, 1, cont, fpout);
			if (ferror(fpout))
			{
				perror("fwrite: descomprimir()");
				exit(1);
			}

			if (verbose)
			{
				if ((int)completado < 100)
					printf("\b\b\b100%%");
				printf("\n");
			}

			break;	// Salimos del for(;;)
		}
	}
}
コード例 #23
0
/**
 * Write the metadata to a file.
 *
 * @param handle  The handle of the output file.
 * @param program The program buffer data (also written out).
 */
void ProgramMetaData::write(FILE *handle, BufferClass *program)
{
    fwrite(this, 1, getHeaderSize(), handle);
    /* and finally the flattened method  */
    fwrite(program->getData(), 1, program->getDataLength(), handle);
}