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

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));
}

/* NodeBuilders::saveBuilderPaths
 * Writes builder paths to [file]
 *******************************************************************/
void NodeBuilders::saveBuilderPaths(wxFile& file)
{
	file.Write("nodebuilder_paths\n{\n");
	for (unsigned a = 0; a < builders.size(); a++)
	{
		string path = builders[a].path;
		path.Replace("\\", "/");
		file.Write(S_FMT("\t%s \"%s\"\n", builders[a].id, path));
	}
	file.Write("}\n");
}

Status_e FileText::writeStringInFile(wxFile& file, wxString const& str)
{
    uint8_t sizeStr = strlen(str.fn_str());

    //Écriture de la taille du texte.
    if(file.Write(&sizeStr, sizeof sizeStr) != sizeof sizeStr)
        return STATUS_FILE_WRITE_ERROR;

    //Écriture du texte.
    if(!file.Write(str))
        return STATUS_FILE_WRITE_ERROR;

    return STATUS_SUCCESS;
}

void cxEnv::WriteEnvToFile(wxFile& file) const {
	wxASSERT(file.IsOpened());

	for (map<wxString, wxString>::const_iterator p = m_env.begin(); p != m_env.end(); ++p) {
		wxString line = p->first;
		line += wxT('=');
		line += p->second;
		line += wxT('\n');

		file.Write(line);
	}

	file.Write(wxT("\n"));
}

/// Opens the file and also adds a standard comment at the start of it.
int SourceOutputStream::OpenFile(const wxString & Filename)
{
   nBytes = 0;
   bool bOk;
   bOk = File.Open( Filename, wxFile::write );
   if( bOk )
   {
      File.Write( wxT("//   ThemeAsCeeCode.h\r\n") );
      File.Write( wxT("//\r\n") );
      File.Write( wxT("//   This file was Auto-Generated.\r\n") );
      File.Write( wxT("//   It is included by Theme.cpp.\r\n") );
      File.Write( wxT("//   Only check this into CVS if you've read and understood the guidelines!\r\n\r\n   ") );
   }
   return bOk;
}

/// This is the 'callback' function called with each write of PNG data
/// to the stream.  This is where we conveet to text and add commas.
size_t SourceOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
{
   wxString Temp;
   for(int i=0;i<(int)bufsize;i++)
   {
      // Write one byte with a comma
      Temp = wxString::Format( wxT("%i,"),(int)(((unsigned char*)buffer)[i]) );
      File.Write( Temp );
      nBytes++;
      // New line if more than 20 bytes written since last time.
      if( (nBytes %20)==0 )
      {
         File.Write( wxT("\r\n   "));
      }
   }
   return bufsize;
}

// Writes a wxString to a file. File must be open. File is closed automatically.
bool cbWrite(wxFile& file, const wxString& buff, wxFontEncoding encoding)
{
    bool result = false;
    if (file.IsOpened())
    {
        wxCSConv conv(encoding);
        result = file.Write(buff,conv);
        if (result)
            file.Flush();
        file.Close();
    }
    return result;
}

bool FileManager::WriteWxStringToFile(wxFile& f, const wxString& data, wxFontEncoding encoding, bool bom)
{
    const char* mark = 0;
    size_t mark_length = 0;
    if (bom)
    {
        switch (encoding)
        {
        case wxFONTENCODING_UTF8:
            mark = "\xEF\xBB\xBF";
            mark_length = 3;
            break;
        case wxFONTENCODING_UTF16BE:
            mark = "\xFE\xFF";
            mark_length = 2;
            break;
        case wxFONTENCODING_UTF16LE:
            mark = "\xFF\xFE";
            mark_length = 2;
            break;
        case wxFONTENCODING_UTF32BE:
            mark = "\x00\x00\xFE\xFF";
            mark_length = 4;
            break;
        case wxFONTENCODING_UTF32LE:
            mark = "\xFF\xFE\x00\x00";
            mark_length = 4;
            break;
        case wxFONTENCODING_SYSTEM:
        default:
            break;
        }

        if(f.Write(mark, mark_length) != mark_length)
            return false;
    }

    if (data.length() == 0)
        return true;

#if defined(UNICODE) || defined(_UNICODE)

    size_t inlen = data.Len(), outlen = 0;
    wxCharBuffer mbBuff;
    if ( encoding == wxFONTENCODING_UTF7 )
    {
        wxMBConvUTF7 conv;
        mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
    }
    else if ( encoding == wxFONTENCODING_UTF8 )
    {
        wxMBConvUTF8 conv;
        mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
    }
    else if ( encoding == wxFONTENCODING_UTF16BE )
    {
        wxMBConvUTF16BE conv;
        mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
    }
    else if ( encoding == wxFONTENCODING_UTF16LE )
    {
        wxMBConvUTF16LE conv;
        mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
    }
    else if ( encoding == wxFONTENCODING_UTF32BE )
    {
        wxMBConvUTF32BE conv;
        mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
    }
    else if ( encoding == wxFONTENCODING_UTF32LE )
    {
        wxMBConvUTF32LE conv;
        mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
    }
    else
    {
        // try wxEncodingConverter first, even it it only works for
        // wxFONTENCODING_ISO8859_1..15, wxFONTENCODING_CP1250..1257 and wxFONTENCODING_KOI8
        // but it's much, much faster than wxCSConv (at least on linux)
        wxEncodingConverter conv;
        // should be long enough
        char* tmp = new char[2*inlen];

        #if wxCHECK_VERSION(2, 9, 0)
        if(conv.Init(wxFONTENCODING_UNICODE, encoding) && conv.Convert(data.wx_str(), tmp))
        #else
        if(conv.Init(wxFONTENCODING_UNICODE, encoding) && conv.Convert(data.c_str(), tmp))
        #endif
        {
            mbBuff = tmp;
            outlen = strlen(mbBuff); // should be correct, because Convert has returned true
        }
        else
    {
            // try wxCSConv, if nothing else works
        wxCSConv conv(encoding);
            mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
        }
        delete[] tmp;
    }
//.........这里部分代码省略.........

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;
}

bool ButcherMetadataFile::WriteMetadata(wxFile &file, ButcherMetadataStorage *storage)
{
    butchermetadata_dataheader_t dataheader;
    butchermetadata_dataitemheader_t dataitemheader;

    ButcherMetadataDataList *curlist;
    ButcherMetadataData *curdata;
    ButcherMetadataData::data_t::const_iterator dataiterator;
    auto_ptr<ButcherMetadataBinary> itembin;

    char buf[BMD_BUF_TEMP_SIZE];
    size_t nRead, nTotal;

    unsigned int listi;
    for (listorder_t::const_iterator i=storage->GetListOrder().begin(); i!=storage->GetListOrder().end(); i++)
    {
        curlist=&storage->Get(*i);

        // items
        for (listi=0; listi<curlist->Count(); listi++)
        {
            // data header begin
            memset(&dataheader, 0, sizeof(dataheader));
            dataheader.kind=BUTCHERMETADATA_KIND_METADATABEGIN;
            strncpy(dataheader.sig, BUTCHERMETADATA_SIG_METADATA, BUTCHERMETADATA_SIG_SIZE);
            dataheader.id=curlist->GetMetadataID();

            file.Write(&dataheader, sizeof(dataheader));

            curdata=&curlist->Get(listi);

            for (dataiterator=curdata->GetData().begin(); dataiterator!=curdata->GetData().end(); dataiterator++)
            {

                // data item header begin
                memset(&dataheader, 0, sizeof(dataheader));
                dataheader.kind=BUTCHERMETADATA_KIND_ITEMBEGIN;
                strncpy(dataheader.sig, BUTCHERMETADATA_SIG_METADATA, BUTCHERMETADATA_SIG_SIZE);
                dataheader.id=dataiterator->first;

                file.Write(&dataheader, sizeof(dataheader));


                // item
                itembin.reset(dataiterator->second->GetData());

                // item header
                memset(&dataitemheader, 0, sizeof(dataitemheader));
                strncpy(dataitemheader.sig, BUTCHERMETADATA_SIG_METADATAITEM, BUTCHERMETADATA_SIG_SIZE);
                dataitemheader.datatype=dataiterator->second->GetDataType();
                if (itembin.get())
                {
                    itembin->SeekI(0, wxFromStart);
                    dataitemheader.datasize=itembin->GetLength();
                }

                file.Write(&dataitemheader, sizeof(dataitemheader));

                // store item position in file
                dataiterator->second->SetPosition(file.Tell(), dataitemheader.datasize);

                // item data
                nTotal=0;
                if (itembin.get())
                {
                    // write item data
                    do
                    {
                        nRead = itembin->Read(buf, WXSIZEOF(buf)).LastRead();
                        if ( nRead )
                        {
                            nTotal+=nRead;
                            file.Write(buf, nRead);
                        }
                    }
                    while ( nRead );
                }
                if (nTotal!=dataitemheader.datasize)
                    throw ButcherException(
                        wxString::Format(_("Data written different than expected (expect: %d - read: %d)."),
                            dataitemheader.datasize, nTotal));

                // free itembin
                itembin.reset(NULL);

                // BINARY item
                if (dataiterator->second->GetDataType()==ButcherMetadataDataItem::DT_BINARY)
                {
/*
                    // set new binary pointing to current file
                    dynamic_cast<ButcherMetadataDataItem_Binary*>(&*(dataiterator->second))->SetBinary(
                        new wxVirtualInputStream(file, dataiterator->second->GetPosition(),
                            dataiterator->second->GetSize())
                    );
*/

                    dynamic_cast<ButcherMetadataDataItem_Binary*>(&*(dataiterator->second))->SetBinary(NULL);
                }

                // METADATA item
//.........这里部分代码省略.........