C++ wxFile::Seek方法代码示例

void MakeSaveState(wxFile& f)
{
	const ArrayF<MemoryBlock>& mb = Memory.MemoryBlocks;
	
	state_hdr state;
	memset(&state, 0, sizeof(state_hdr));
	
	state.magic = state_magic;
	state.version = state_version;
	state.mem_count = mb.GetCount();
	//state.hle_count = mb.GetCount();
	
	state.mem_offset = sizeof(state_hdr) + 4;
	
	f.Seek(state.mem_offset);
	for(u32 i=0; i<state.mem_count; ++i)
	{
		state.mem_size += mb[i].GetSize();
		f.Write(mb[i].GetMem(), mb[i].GetSize());
	}

	state.hle_offset = state.mem_offset + state.mem_size + 4;

	f.Seek(0);
	f.Write(&state, sizeof(state_hdr));
}

int ReplayList::replayVersion(wxFile& replay) const
{
	if (replay.Seek(16) == wxInvalidOffset) {
		return 0;
	}
	int version = 0;
	replay.Read(&version, 4);
	return version;
}

Status_e FileText::filePointerAfterHeader(wxFile& file)const
{
    uint8_t sizelg;

    //Lecture de la taille du premier langage.
    if(file.Read(&sizelg, sizeof sizelg) != sizeof sizelg)
        return STATUS_FILE_READ_ERROR;

    //Pointer sur la taille du deuxième langage.
    if(file.Seek(sizelg, wxFromCurrent) ==  wxInvalidOffset)
        return STATUS_FILE_READ_ERROR;

    //Lecture de la taille du deuxième langage.
    if(file.Read(&sizelg, sizeof sizelg) != sizeof sizelg)
        return STATUS_FILE_READ_ERROR;

    //Pointer sur la taille du premier texte ou la fin du fichier
    file.Seek(sizelg, wxFromCurrent);

    return STATUS_SUCCESS;
}

// Unpacking.
bool LoadEntries(wxFile& dec_pkg_f, PKGHeader* m_header, PKGEntry *m_entries)
{
	dec_pkg_f.Seek(0);
	dec_pkg_f.Read(m_entries, sizeof(PKGEntry) * m_header->file_count);
	
	if (m_entries->name_offset / sizeof(PKGEntry) != m_header->file_count) {
		ConLog.Error("PKG: Entries are damaged!");
		return false;
	}

	return true;
}

void ReplayList::GetHeaderInfo(wxFile& replay, StoredGame& rep, const int version) const
{
	const int seek = 72 + (version < 5 ? 0 : 240);
	if (replay.Seek(seek) == wxInvalidOffset) {
		return;
	}
	int gametime = 0;
	replay.Read(&gametime, 4);
	rep.duration = gametime;
	rep.size = replay.Length();
	//! \todo don't use long long? (pedantic)
	wxLongLong_t unixtime = 0;
	if (replay.Seek(56) == wxInvalidOffset) {
		return;
	}
	replay.Read(&unixtime, 8);
	wxDateTime dt;
	dt.Set((time_t)unixtime);
	// todo: add 2 strings one for date other for time?
	rep.date_string = STD_STRING(dt.FormatISODate() + _T(" ") + dt.FormatISOTime());
	//  rep.date = (time_t) unixtime ;
}

bool LoadHeader(wxFile& pkg_f, PKGHeader* m_header)
{
	pkg_f.Seek(0);
	
	if (pkg_f.Read(m_header, sizeof(PKGHeader)) != sizeof(PKGHeader)) {
		ConLog.Error("PKG: Package file is too short!");
		return false;
	}

	if (!CheckHeader(pkg_f, m_header))
		return false;

	return true;
}

wxString ReplayList::GetScriptFromReplay(wxFile& replay, const int version) const
{

	wxString script;
	if ( !replay.IsOpened() ) return script;
	if(replay.Seek(20)==wxInvalidOffset) {
		return script;
	}
	int headerSize=0 ;
	replay.Read( &headerSize, 4);
	const int seek = 64 + (version < 5 ? 0 : 240);
	if(replay.Seek(seek)==wxInvalidOffset) {
		return script;
	}
	wxFileOffset scriptSize=0;
	replay.Read( &scriptSize, 4);
	scriptSize = LSL::Util::Clamp( wxFileOffset(scriptSize), wxFileOffset(0), replay.Length() );
	if(replay.Seek(headerSize) == wxInvalidOffset)return script;
	std::string script_a(scriptSize,0);
	replay.Read( &script_a[0], scriptSize );
	script = TowxString( script_a ) ;//(script_a,scriptSize);
	return script;
}

bool UnpackEntry(wxFile& dec_pkg_f, const PKGEntry& entry, std::string dir)
{
	u8 buf[BUF_SIZE];

	dec_pkg_f.Seek(entry.name_offset);
	dec_pkg_f.Read(buf, entry.name_size);
	buf[entry.name_size] = 0;
	
	switch (entry.type & (0xff))
	{
		case PKG_FILE_ENTRY_NPDRM:
		case PKG_FILE_ENTRY_NPDRMEDAT:
		case PKG_FILE_ENTRY_SDAT:
		case PKG_FILE_ENTRY_REGULAR:
		{
			wxFile out;
			out.Create(dir + buf);
			dec_pkg_f.Seek(entry.file_offset);

			for (u64 size = 0; size < entry.file_size; ) {
				size += dec_pkg_f.Read(buf, BUF_SIZE);
				if (size > entry.file_size)
					out.Write(buf, BUF_SIZE - (size - entry.file_size));
				else
					out.Write(buf, BUF_SIZE);
			}
			out.Close();
		}
		break;
			
		case PKG_FILE_ENTRY_FOLDER:
			wxMkdir(dir + buf);
		break;
	}
	return true;
}

static uint GetFileSizeImpl(wxFile& file, const wxString& name)
{
    if (file.IsOpened())
    {
        wxFileOffset pos = file.Tell();
        file.SeekEnd();
        wxFileOffset size = file.Tell();
        file.Seek(pos);
        return size;
    }
    else
    {
        wxFile file2(name, wxFile::read);
        if (!file2.IsOpened())
            return 0;
        file2.SeekEnd();
        return file2.Tell();
    }
}

DWORD CNWCFile::LoadCompressed(wxFile& in, FILE* out, FILELOAD fl)
{
#define HEADER_SIZE	6

	long lSize = in.Length();
	if ( lSize <= HEADER_SIZE )
		return ERROR_INVALID_DATA;

	wxString strTmpName = wxFileName::CreateTempFileName(_T("N2X"));

	DWORD dwResult = ERROR_GEN_FAILURE;
	// save compressed file content without [NWZ]\0
	{
		TByteArray dtCompressed;
		dtCompressed.SetCount(lSize - HEADER_SIZE);
		in.Seek(HEADER_SIZE, wxFromStart);
		in.Read(&dtCompressed[0], lSize-HEADER_SIZE);
		in.Close();

		dwResult = UncompressNSave(strTmpName, &dtCompressed[0], dtCompressed.GetCount());
		if ( ERROR_SUCCESS != dwResult )
		{
			wxRemoveFile(strTmpName);
			return dwResult;
		}
	}

	wxFile file;
	if ( file.Open(strTmpName) )
	{
		dwResult = Load(file, out, fl);

		file.Close();
	}

	wxRemoveFile(strTmpName);

	return dwResult;
#undef	HEADER_SIZE
}

int Decrypt(wxFile& pkg_f, wxFile& dec_pkg_f, PKGHeader* m_header)
{
	if (!LoadHeader(pkg_f, m_header))
		return -1;

	aes_context c;
	u8 iv[HASH_LEN];
	u8 buf[BUF_SIZE];
	u8 ctr[BUF_SIZE];
	
	// Debug key
	u8 key[0x40];
	memset(key, 0, 0x40);
	memcpy(key+0x00, &m_header->qa_digest[0], 8); // &data[0x60]
	memcpy(key+0x08, &m_header->qa_digest[0], 8); // &data[0x60]
	memcpy(key+0x10, &m_header->qa_digest[8], 8); // &data[0x68]
	memcpy(key+0x18, &m_header->qa_digest[8], 8); // &data[0x68]

	pkg_f.Seek(m_header->data_offset);
	u32 parts = (m_header->data_size + BUF_SIZE - 1) / BUF_SIZE;

	wxProgressDialog pdlg("PKG Decrypter / Installer", "Please wait, decrypting...", parts, 0, wxPD_AUTO_HIDE | wxPD_APP_MODAL);

	memcpy(iv, m_header->klicensee, sizeof(iv));
	aes_setkey_enc(&c, PKG_AES_KEY, 128);
	
	for (u32 i=0; i<parts; i++)
	{
		memset(buf, 0, sizeof(buf));
		u32 length = pkg_f.Read(buf, BUF_SIZE);
		u32 bits = (length + HASH_LEN - 1) / HASH_LEN;
		
		if (m_header->pkg_type == PKG_RELEASE_TYPE_DEBUG)
		{
			for (u32 j=0; j<bits; j++)
			{
				u8 hash[0x14];
				sha1(key, 0x40, hash);
				*(u64*)&buf[j*HASH_LEN + 0] ^= *(u64*)&hash[0];
				*(u64*)&buf[j*HASH_LEN + 8] ^= *(u64*)&hash[8];
				*(be_t<u64>*)&key[0x38] += 1;
			}
		}

		if (m_header->pkg_type == PKG_RELEASE_TYPE_RELEASE)
		{
			for (u32 j=0; j<bits; j++)
			{
				aes_crypt_ecb(&c, AES_ENCRYPT, iv, ctr+j*HASH_LEN);

				be_t<u64> hi = *(be_t<u64>*)&iv[0];
				be_t<u64> lo = *(be_t<u64>*)&iv[8] + 1;

				if (lo == 0)
					hi += 1;

				*(be_t<u64>*)&iv[0] = hi;
				*(be_t<u64>*)&iv[8] = lo;
			}
		
			for (u32 j=0; j<length; j++) {
				buf[j] ^= ctr[j];
			}
		}		
		dec_pkg_f.Write(buf, length);
		pdlg.Update(i);
	}
	pdlg.Update(parts);
	return 0;
}

// -------------------------------------------------------------------------------- //
wxString guGetNextXMLChunk( wxFile &xmlfile, wxFileOffset &CurPos, const char * startstr, const char * endstr, const wxMBConv &conv )
{
    #define XMLREAD_BUFFER_SIZE         10240
    wxString RetVal;
    //wxFileOffset CurPos = xmlfile.Tell();
    CurPos = xmlfile.Tell();
    wxFileOffset StartPos = wxNOT_FOUND;
    wxFileOffset EndPos = wxNOT_FOUND;
    int endstrlen = strlen( endstr );
    char * Buffer = ( char * ) malloc( XMLREAD_BUFFER_SIZE + 1 );
    if( Buffer )
    {
        while( StartPos == wxNOT_FOUND )
        {
            int ReadCount = xmlfile.Read( Buffer, XMLREAD_BUFFER_SIZE );
            if( ReadCount != wxInvalidOffset && ReadCount > 0 )
            {
                Buffer[ ReadCount ] = 0;
            }
            else
            {
                break;
            }
            char * StartString = strstr( Buffer, startstr );
            if( StartString )
            {
                StartPos = CurPos + ( StartString - Buffer );
                break;
            }
            else
            {
                CurPos += ReadCount;
            }
        }

        if( StartPos != wxNOT_FOUND )
        {
            xmlfile.Seek( StartPos );
            CurPos = StartPos;
            while( EndPos == wxNOT_FOUND )
            {
                int ReadCount = xmlfile.Read( Buffer, XMLREAD_BUFFER_SIZE );
                if( ReadCount != wxInvalidOffset && ReadCount > 0 )
                {
                    Buffer[ ReadCount ] = 0;
                }
                else
                {
                    break;
                }
                char * EndString = strstr( Buffer, endstr );
                if( EndString )
                {
                    EndPos = CurPos + ( EndString - Buffer ) + endstrlen;
                    break;
                }
                else
                {
                    // Prevent that </artist was partially included
                    CurPos += ReadCount - endstrlen;
                    xmlfile.Seek( -endstrlen, wxFromCurrent );
                }
            }

            if( EndPos != wxNOT_FOUND )
            {
                //guLogMessage( wxT( "Found From %lli => %lli  (%lli)" ), StartPos, EndPos, EndPos - StartPos );
                int BufferSize = EndPos - StartPos;
                if( BufferSize )
                {
                    char * BufferString = ( char * ) malloc( BufferSize + 1 );
                    if( BufferString )
                    {
                        xmlfile.Seek( StartPos );
                        int ReadCount = xmlfile.Read( BufferString, BufferSize );
                        if( ReadCount != wxInvalidOffset )
                        {
                            BufferString[ ReadCount ] = 0;
                            RetVal = wxString( BufferString, conv );
                            //guLogMessage( wxT( "%i %i" ), BufferSize, ReadCount );
                        }

                        free( BufferString );
                    }
                }
            }
        }

        free( Buffer );
    }


    return RetVal;
}

bool ButcherMetadataFile::ReadMetadata(wxFile &file, ButcherMetadataStorage *storage)
{
    butchermetadata_dataheader_t dataheader, dataitemendheader;
    butchermetadata_dataitemheader_t dataitemheader;
    ButcherMetadataDataItem *newitem;
    ButcherMetadataData *curmd=NULL;
    //auto_ptr<char> itemdata;
    size_t n;
    bool started=false, readitemend;

    while (true)
    {
        // data header
        n=file.Read(&dataheader, sizeof(dataheader));

        if (n==0) return false; // no more data
        if (n!=sizeof(dataheader)) do_invalidfile(_("Could not read data header"));

        if (strncmp(dataheader.sig, BUTCHERMETADATA_SIG_METADATA, BUTCHERMETADATA_SIG_SIZE)!=0)
            do_invalidfile(_("Invalid data header signature"));

        switch (dataheader.kind)
        {
        case BUTCHERMETADATA_KIND_METADATABEGIN:
            if (started) // cannot start before ending
                do_invalidfile(_("Metadata error: cannot start before ending"));

            started=true;

            // add metadata to list
            curmd=storage->Get(dataheader.id, true).Add();
            break;
        case BUTCHERMETADATA_KIND_METADATAEND:
            if (!started)
                do_invalidfile(_("Metadata error: cannot end before starting"));
            // metadata was read
            started=false;
            curmd=NULL;
            break;
        case BUTCHERMETADATA_KIND_ITEMBEGIN:
            if (!started)
                do_invalidfile(_("Metadata error: cannot have item outside metadata"));

            // read item
            n=file.Read(&dataitemheader, sizeof(dataitemheader));

            if (n==0) do_invalidfile(_("End of data without metadata end")); // no more data, but not metadataend found
            if (n!=sizeof(dataitemheader)) do_invalidfile(_("Could not read item header"));

            // item header
            if (strncmp(dataitemheader.sig, BUTCHERMETADATA_SIG_METADATAITEM, BUTCHERMETADATA_SIG_SIZE)!=0)
                do_invalidfile(_("Invalid item header"));

            newitem=NULL;
            switch (dataitemheader.datatype)
            {
            case ButcherMetadataDataItem::DT_METADATA:
                newitem=new ButcherMetadataDataItem_Metadata(curmd, dataheader.id, file.Tell(), 0);
                break;
            case ButcherMetadataDataItem::DT_STRING:
                newitem=new ButcherMetadataDataItem_String(curmd, dataheader.id, wxEmptyString, file.Tell(), dataitemheader.datasize);
                break;
            case ButcherMetadataDataItem::DT_INTEGER:
                newitem=new ButcherMetadataDataItem_Integer(curmd, dataheader.id, 0, file.Tell(), dataitemheader.datasize);
                break;
            case ButcherMetadataDataItem::DT_BINARY:
                newitem=new ButcherMetadataDataItem_Binary(curmd, dataheader.id, NULL, file.Tell(), dataitemheader.datasize);
                break;
            default:
                do_invalidfile(_("Invalid item data type"));
                break;
            }
            // read item data
            readitemend=true;
            curmd->Add(newitem);
            if (dataitemheader.datasize>0)
            {
                if (newitem->ReadData())
                {
                    //itemdata=auto_ptr<char>(new char[dataitemheader.datasize]);
#ifndef _MSC_VER
					char itemdata[dataitemheader.datasize];
#else
					auto_ptr<char> itemdata_auto(new char[dataitemheader.datasize]);
					char *itemdata=itemdata_auto.get();
#endif
                    n=file.Read(&*itemdata, dataitemheader.datasize);

                    if (n==0) do_invalidfile(_("End of data while reading item data"));
                    if (n!=dataitemheader.datasize) do_invalidfile(_("Could not read item data"));

                    //newitem->SetData(&*itemdata, dataitemheader.datasize);
                    newitem->SetData(itemdata, dataitemheader.datasize);

                }
                else
                {
                    // skip data
                    file.Seek((wxFileOffset)dataitemheader.datasize, wxFromCurrent);
                }
//.........这里部分代码省略.........

//.........这里部分代码省略.........
		ReadBytes(in, bAllowLayering);
		wxFprintf(out, _T("group visibility:"));
		CObj::DumpBinary(out, nGroupVisibility, sizeof(nGroupVisibility), false);
		wxFprintf(out, _T("\nallowlayering:%d\n"), bAllowLayering);
	}
	nPos = in.Tell();
	if ( nVersion >= NWC_Version200 )
	{
		strNotationTypeface = LoadStringNULTerminated(in);
		wxFprintf(out, _T("notationtypeface:%s\n"), strNotationTypeface.c_str());
	}
	ReadLEShort(in, nStaffHeight);
	wxFprintf(out, _T("staffheight=%d\n"), nStaffHeight);

	nPos = in.Tell();

	int nFontCount = 0;
	if ( nVersion > NWC_Version130 )
		nFontCount = ( nVersion <= NWC_Version170 ? 10 : 12 );
	mFontInfos.SetCount(nFontCount);
	int i;
	for ( i=0; i<nFontCount; i++ )
	{
		mFontInfos[i].Load(in);
	}

	// some 1.70 version have 12 fontinfo
	if ( nVersion == NWC_Version170 )
	{
		nPos = in.Tell();
		unsigned char ch;
		if ( in.Read(&ch, 1) != 1 )
			return ERROR_INVALID_DATA;
		in.Seek(nPos, wxFromStart);

		if ( ch == 0 || ch == 0xFF )
		{
		}
		else
		{
			nFontCount += 2;
			mFontInfos.SetCount(nFontCount);
			for ( ; i<nFontCount; i++ )
			{
				mFontInfos[i].Load(in);
			}
		}
	}

	wxFprintf(out, _T("#font=%d\n"), nFontCount);
	for ( i=0; i<nFontCount; i++ )
	{
		mFontInfos[i].Dump(out, i);
	}

	ReadBytes(in, btTitlePageInfo);
	ReadBytes(in, btStaffLabels);	// index of [None, First Systems, Top Systems, All Systems]
	ReadLEShort(in, nStartPageNo);
	if ( nVersion >= NWC_Version200 )
	{
		unsigned char ch;
		if ( in.Read(&ch, 1) != 1 )
			return ERROR_INVALID_DATA;

		if ( ch != 0xFF )
			in.Seek(-1, wxFromCurrent);