//--------------------------------------------------------------------------- void TConfiguration::SetStorage(TStorage Value) { if (FStorage != Value) { TStorage StorageBak = FStorage; try { std::unique_ptr<THierarchicalStorage> SourceStorage(CreateStorage(false)); std::unique_ptr<THierarchicalStorage> TargetStorage(CreateStorage(false)); SourceStorage->SetAccessMode(smRead); FStorage = Value; TargetStorage->SetAccessMode(smReadWrite); TargetStorage->SetExplicit(true); // copy before save as it removes the ini file, // when switching from ini to registry CopyData(SourceStorage.get(), TargetStorage.get()); // save all and explicit DoSave(true, true); } catch (...) { // If this fails, do not pretend that storage was switched. // For instance: // - When writing to an IFI file fails (unlikely, as we fallback to user profile) // - When removing INI file fails, when switching to registry // (possible, when the INI file is in Program files folder) FStorage = StorageBak; throw; } } }
//--------------------------------------------------------------------------- void TConfiguration::Load() { TGuard Guard(FCriticalSection); std::unique_ptr<THierarchicalStorage> Storage(CreateStorage(false)); Storage->SetAccessMode(smRead); LoadFrom(Storage.get()); }
//--------------------------------------------------------------------------- void TConfiguration::DoSave(bool All, bool Explicit) { if (FDontSave) { return; } std::unique_ptr<THierarchicalStorage> Storage(CreateStorage(false)); Storage->SetAccessMode(smReadWrite); Storage->SetExplicit(Explicit); if (Storage->OpenSubKey(GetConfigurationSubKey(), true)) { SaveData(Storage.get(), All); } Saved(); if (All) { StoredSessions->Save(true, Explicit); } // clean up as last, so that if it fails (read only INI), the saving can proceed if (GetStorage() == stRegistry) { CleanupIniFile(); } }
int main(int argc, const char **argv) // ignore_convention { IKernel *pKernel = IKernel::Create(); s_pStorage = CreateStorage("Teeworlds", IStorage::STORAGETYPE_BASIC, argc, argv); s_pEngineMap = CreateEngineMap(); bool RegisterFail = !pKernel->RegisterInterface(s_pStorage); RegisterFail |= !pKernel->RegisterInterface(s_pEngineMap); if(RegisterFail) { delete pKernel; return -1; } s_File = s_pStorage->OpenFile("map_version.txt", IOFLAG_WRITE, 1); if(s_File) { io_write(s_File, "static CMapVersion s_aMapVersionList[] = {\n", str_length("static CMapVersion s_aMapVersionList[] = {\n")); s_pStorage->ListDirectory(1, "maps", MaplistCallback, 0); io_write(s_File, "};\n", str_length("};\n")); io_close(s_File); } delete pKernel; return 0; }
void AddressBook::LoadHosts () { if (!m_Storage) m_Storage = CreateStorage (); if (m_Storage->Load (m_Addresses) > 0) { m_IsLoaded = true; return; } // try hosts.txt first std::ifstream f (i2p::util::filesystem::GetFullPath ("hosts.txt").c_str (), std::ofstream::in); // in text mode if (f.is_open ()) { LoadHostsFromStream (f); m_IsLoaded = true; } else { // if not found download it from http://i2p-projekt.i2p/hosts.txt LogPrint (eLogInfo, "hosts.txt not found. Try to download it from default subscription..."); if (!m_IsDownloading) { m_IsDownloading = true; if (!m_DefaultSubscription) m_DefaultSubscription = new AddressBookSubscription (*this, DEFAULT_SUBSCRIPTION_ADDRESS); m_DefaultSubscription->CheckSubscription (); } } }
bool AddressBook::GetAddress (const std::string& address, i2p::data::IdentityEx& identity) { if (!m_Storage) m_Storage = CreateStorage (); i2p::data::IdentHash ident; if (!GetIdentHash (address, ident)) return false; return m_Storage->GetAddress (ident, identity); }
int main(int argc, const char **argv) { if(argc != 2) { printf("wrong arguments, there has to be one and only one and this is the mapfile to extract the images from.\n"); return -1; } IStorage *pStorage = CreateStorage("Teeworlds", argc, argv); CDataFileReader DataFile; if(!pStorage) { printf("Cannot get storage\n"); return -1; } if(!DataFile.Open(pStorage, argv[1], IStorage::TYPE_ALL)) { printf("Cannot read %s\n", argv[1]); return -1; } printf("Loading %s\n", argv[1]); png_init(0, 0); // load images int start, num; DataFile.GetType(MAPITEMTYPE_IMAGE, &start, &num); for(int i = 0; i < num; i++) { CMapItemImage *pImg = (CMapItemImage *)DataFile.GetItem(start+i, 0, 0); char *pName = (char *)DataFile.GetData(pImg->m_ImageName); if(pImg->m_External) { printf("skipping external %s\n", pName); } else { printf("writing %s.png\n", pName); void *pData = DataFile.GetData(pImg->m_ImageData); char buf[255]; #if defined(CONF_FAMILY_WINDOWS) _snprintf(buf, sizeof(buf), "%s.png", pName); #else snprintf(buf, sizeof(buf), "%s.png", pName); #endif png_t png; png_open_file_write(&png, buf); png_set_data(&png, pImg->m_Width, pImg->m_Height, 8, PNG_TRUECOLOR_ALPHA, (unsigned char*) pData); png_close_file(&png); DataFile.UnloadData(pImg->m_ImageData); } } DataFile.Close(); return 0; }
void AddressBook::InsertAddress (const std::string& address, const std::string& base64) { i2p::data::IdentityEx ident; ident.FromBase64 (base64); if (!m_Storage) m_Storage = CreateStorage (); m_Storage->AddAddress (ident); m_Addresses[address] = ident.GetIdentHash (); LogPrint (address,"->", ToAddress(ident.GetIdentHash ()), " added"); }
CStoreSync(const std::wstring& wstrFileName, const ss_format_t* pFormat): KLSTD::KLBaseImpl<IStoreSync>(), m_wstrFileName(wstrFileName) { CreateStorage( m_wstrFileName, CF_OPEN_ALWAYS, AF_READ|AF_WRITE, &m_pStorage, pFormat); };
//--------------------------------------------------------------------------- void TConfiguration::LoadDirectoryChangesCache(const UnicodeString & SessionKey, TRemoteDirectoryChangesCache * DirectoryChangesCache) { std::unique_ptr<THierarchicalStorage> Storage(CreateStorage(false)); Storage->SetAccessMode(smRead); if (Storage->OpenSubKey(GetConfigurationSubKey(), false) && Storage->OpenSubKey(L"CDCache", false) && Storage->ValueExists(SessionKey)) { DirectoryChangesCache->Deserialize(Storage->ReadBinaryData(SessionKey)); } }
//--------------------------------------------------------------------------- void TConfiguration::NeverShowBanner(const UnicodeString & SessionKey, const UnicodeString & Banner) { std::unique_ptr<THierarchicalStorage> Storage(CreateStorage(false)); Storage->SetAccessMode(smReadWrite); if (Storage->OpenSubKey(GetConfigurationSubKey(), true) && Storage->OpenSubKey(L"Banners", true)) { Storage->WriteString(SessionKey, BannerHash(Banner)); } }
NS_IMETHODIMP DOMStorageManager::GetLocalStorageForPrincipal(nsIPrincipal* aPrincipal, const nsAString& aDocumentURI, bool aPrivate, nsIDOMStorage** aRetval) { if (mType != LocalStorage) { return NS_ERROR_UNEXPECTED; } return CreateStorage(aPrincipal, aDocumentURI, aPrivate, aRetval); }
//--------------------------------------------------------------------------- void TConfiguration::SaveDirectoryChangesCache(const UnicodeString & SessionKey, TRemoteDirectoryChangesCache * DirectoryChangesCache) { std::unique_ptr<THierarchicalStorage> Storage(CreateStorage(false)); Storage->SetAccessMode(smReadWrite); if (Storage->OpenSubKey(GetConfigurationSubKey(), true) && Storage->OpenSubKey(L"CDCache", true)) { UnicodeString Data; DirectoryChangesCache->Serialize(Data); Storage->WriteBinaryData(SessionKey, Data); } }
//--------------------------------------------------------------------------- bool TConfiguration::ShowBanner(const UnicodeString & SessionKey, const UnicodeString & Banner) { std::unique_ptr<THierarchicalStorage> Storage(CreateStorage(false)); Storage->SetAccessMode(smRead); bool Result = !Storage->OpenSubKey(GetConfigurationSubKey(), false) || !Storage->OpenSubKey(L"Banners", false) || !Storage->ValueExists(SessionKey) || (Storage->ReadString(SessionKey, L"") != BannerHash(Banner)); return Result; }
int main(int argc, const char **argv) { IStorage *pStorage = CreateStorage("Teeworlds", IStorage::STORAGETYPE_BASIC, argc, argv); int Index, ID = 0, Type = 0, Size; void *pPtr; char aFileName[1024]; CDataFileReader DataFile; CDataFileWriter df; if(!pStorage || argc != 3) return -1; str_format(aFileName, sizeof(aFileName), "%s", argv[2]); if(!DataFile.Open(pStorage, argv[1], IStorage::TYPE_ALL)) return -1; if(!df.Open(pStorage, aFileName)) return -1; // add all items for(Index = 0; Index < DataFile.NumItems(); Index++) { pPtr = DataFile.GetItem(Index, &Type, &ID); Size = DataFile.GetItemSize(Index); df.AddItem(Type, ID, Size, pPtr); } // add all data for(Index = 0; Index < DataFile.NumData(); Index++) { pPtr = DataFile.GetData(Index); Size = DataFile.GetDataSize(Index); df.AddData(Size, pPtr); } DataFile.Close(); df.Finish(); return 0; }
THierarchicalStorage * TConfiguration::CreateConfigStorage() { bool SessionList = false; return CreateStorage(SessionList); }
/** Parse opcodes in the formset IFR binary. @param FormSet Pointer of the FormSet data structure. @retval EFI_SUCCESS Opcode parse success. @retval Other Opcode parse fail. **/ EFI_STATUS ParseOpCodes ( IN FORM_BROWSER_FORMSET *FormSet ) { EFI_STATUS Status; UINT16 Index; FORM_BROWSER_FORM *CurrentForm; FORM_BROWSER_STATEMENT *CurrentStatement; UINT8 Operand; UINT8 Scope; UINTN OpCodeOffset; UINTN OpCodeLength; UINT8 *OpCodeData; UINT8 ScopeOpCode; FORMSET_STORAGE *Storage; FORMSET_DEFAULTSTORE *DefaultStore; QUESTION_DEFAULT *CurrentDefault; QUESTION_OPTION *CurrentOption; CHAR8 *AsciiString; UINT16 NumberOfStatement; UINT16 NumberOfExpression; EFI_IMAGE_ID *ImageId; EFI_HII_VALUE *Value; LIST_ENTRY *OneOfOptinMapEntryListHead; EFI_IFR_GUID_OPTIONKEY *OptionMap; ONE_OF_OPTION_MAP *OneOfOptionMap; ONE_OF_OPTION_MAP_ENTRY *OneOfOptionMapEntry; UINT8 OneOfType; EFI_IFR_ONE_OF *OneOfOpcode; HII_THUNK_CONTEXT *ThunkContext; EFI_IFR_FORM_MAP_METHOD *MapMethod; mInScopeSubtitle = FALSE; mInScopeSuppress = FALSE; mInScopeGrayOut = FALSE; CurrentDefault = NULL; CurrentOption = NULL; MapMethod = NULL; ThunkContext = UefiHiiHandleToThunkContext ((CONST HII_THUNK_PRIVATE_DATA*) mHiiThunkPrivateData, FormSet->HiiHandle); // // Set to a invalid value. // OneOfType = (UINT8) -1; // // Get the number of Statements and Expressions // CountOpCodes (FormSet, &NumberOfStatement, &NumberOfExpression); FormSet->NumberOfStatement = NumberOfStatement; mStatementIndex = 0; FormSet->StatementBuffer = AllocateZeroPool (NumberOfStatement * sizeof (FORM_BROWSER_STATEMENT)); if (FormSet->StatementBuffer == NULL) { return EFI_OUT_OF_RESOURCES; } InitializeListHead (&FormSet->StorageListHead); InitializeListHead (&FormSet->DefaultStoreListHead); InitializeListHead (&FormSet->FormListHead); InitializeListHead (&FormSet->OneOfOptionMapListHead); CurrentForm = NULL; CurrentStatement = NULL; ResetScopeStack (); OpCodeOffset = 0; while (OpCodeOffset < FormSet->IfrBinaryLength) { OpCodeData = FormSet->IfrBinaryData + OpCodeOffset; OpCodeLength = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length; OpCodeOffset += OpCodeLength; Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode; Scope = ((EFI_IFR_OP_HEADER *) OpCodeData)->Scope; // // If scope bit set, push onto scope stack // if (Scope != 0) { PushScope (Operand); } if (IsExpressionOpCode (Operand)) { continue; } // // Parse the Opcode // switch (Operand) { case EFI_IFR_FORM_SET_OP: // // check the formset GUID // if (!CompareGuid ((EFI_GUID *)(VOID *)&FormSet->Guid, (EFI_GUID *)(VOID *)&((EFI_IFR_FORM_SET *) OpCodeData)->Guid)) { return EFI_INVALID_PARAMETER; } CopyMem (&FormSet->FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID)); CopyMem (&FormSet->Help, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID)); break; case EFI_IFR_FORM_OP: // // Create a new Form for this FormSet // CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM)); ASSERT (CurrentForm != NULL); CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE; InitializeListHead (&CurrentForm->StatementListHead); CopyMem (&CurrentForm->FormId, &((EFI_IFR_FORM *) OpCodeData)->FormId, sizeof (UINT16)); CopyMem (&CurrentForm->FormTitle, &((EFI_IFR_FORM *) OpCodeData)->FormTitle, sizeof (EFI_STRING_ID)); // // Insert into Form list of this FormSet // InsertTailList (&FormSet->FormListHead, &CurrentForm->Link); break; case EFI_IFR_FORM_MAP_OP: // // Create a new Form Map for this FormSet // CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM)); ASSERT (CurrentForm != NULL); CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE; InitializeListHead (&CurrentForm->StatementListHead); CopyMem (&CurrentForm->FormId, &((EFI_IFR_FORM *) OpCodeData)->FormId, sizeof (UINT16)); MapMethod = (EFI_IFR_FORM_MAP_METHOD *) (OpCodeData + sizeof (EFI_IFR_FORM_MAP)); // // FormMap Form must contain at least one Map Method. // if (((EFI_IFR_OP_HEADER *) OpCodeData)->Length < ((UINTN) (UINT8 *) (MapMethod + 1) - (UINTN) OpCodeData)) { return EFI_INVALID_PARAMETER; } // // Try to find the standard form map method. // while (((UINTN) (UINT8 *) MapMethod - (UINTN) OpCodeData) < ((EFI_IFR_OP_HEADER *) OpCodeData)->Length) { if (CompareGuid ((EFI_GUID *) (VOID *) &MapMethod->MethodIdentifier, &gEfiHiiStandardFormGuid)) { CopyMem (&CurrentForm->FormTitle, &MapMethod->MethodTitle, sizeof (EFI_STRING_ID)); break; } MapMethod ++; } // // If the standard form map method is not found, the first map method title will be used. // if (CurrentForm->FormTitle == 0) { MapMethod = (EFI_IFR_FORM_MAP_METHOD *) (OpCodeData + sizeof (EFI_IFR_FORM_MAP)); CopyMem (&CurrentForm->FormTitle, &MapMethod->MethodTitle, sizeof (EFI_STRING_ID)); } // // Insert into Form list of this FormSet // InsertTailList (&FormSet->FormListHead, &CurrentForm->Link); break; // // Storage // case EFI_IFR_VARSTORE_OP: // // Create a buffer Storage for this FormSet // Storage = CreateStorage (FormSet); Storage->Type = EFI_HII_VARSTORE_BUFFER; CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID)); CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE *) OpCodeData)->Guid, sizeof (EFI_GUID)); CopyMem (&Storage->Size, &((EFI_IFR_VARSTORE *) OpCodeData)->Size, sizeof (UINT16)); AsciiString = (CHAR8 *) ((EFI_IFR_VARSTORE *) OpCodeData)->Name; Storage->Name = AllocateZeroPool (AsciiStrSize (AsciiString) * 2); ASSERT (Storage->Name != NULL); for (Index = 0; AsciiString[Index] != 0; Index++) { Storage->Name[Index] = (CHAR16) AsciiString[Index]; } break; case EFI_IFR_VARSTORE_NAME_VALUE_OP: // // Framework IFR doesn't support Name/Value VarStore opcode // if (ThunkContext != NULL && ThunkContext->ByFrameworkHiiNewPack) { ASSERT (FALSE); } // // Create a name/value Storage for this FormSet // Storage = CreateStorage (FormSet); Storage->Type = EFI_HII_VARSTORE_NAME_VALUE; CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID)); CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->Guid, sizeof (EFI_GUID)); break; case EFI_IFR_VARSTORE_EFI_OP: // // Create a EFI variable Storage for this FormSet // Storage = CreateStorage (FormSet); Storage->Type = EFI_HII_VARSTORE_EFI_VARIABLE; CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID)); CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Guid, sizeof (EFI_GUID)); CopyMem (&Storage->Attributes, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Attributes, sizeof (UINT32)); break; // // DefaultStore // case EFI_IFR_DEFAULTSTORE_OP: DefaultStore = AllocateZeroPool (sizeof (FORMSET_DEFAULTSTORE)); ASSERT (DefaultStore != NULL); DefaultStore->Signature = FORMSET_DEFAULTSTORE_SIGNATURE; CopyMem (&DefaultStore->DefaultId, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultId, sizeof (UINT16)); CopyMem (&DefaultStore->DefaultName, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultName, sizeof (EFI_STRING_ID)); // // Insert to DefaultStore list of this Formset // InsertTailList (&FormSet->DefaultStoreListHead, &DefaultStore->Link); break; // // Statements // case EFI_IFR_SUBTITLE_OP: CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_SUBTITLE *) OpCodeData)->Flags; if (Scope != 0) { mInScopeSubtitle = TRUE; } break; case EFI_IFR_TEXT_OP: CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CopyMem (&CurrentStatement->TextTwo, &((EFI_IFR_TEXT *) OpCodeData)->TextTwo, sizeof (EFI_STRING_ID)); break; // // Questions // case EFI_IFR_ACTION_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); if (OpCodeLength == sizeof (EFI_IFR_ACTION_1)) { // // No QuestionConfig present, so no configuration string will be processed // CurrentStatement->QuestionConfig = 0; } else { CopyMem (&CurrentStatement->QuestionConfig, &((EFI_IFR_ACTION *) OpCodeData)->QuestionConfig, sizeof (EFI_STRING_ID)); } break; case EFI_IFR_RESET_BUTTON_OP: CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CopyMem (&CurrentStatement->DefaultId, &((EFI_IFR_RESET_BUTTON *) OpCodeData)->DefaultId, sizeof (EFI_DEFAULT_ID)); break; case EFI_IFR_REF_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CopyMem (&CurrentStatement->RefFormId, &((EFI_IFR_REF *) OpCodeData)->FormId, sizeof (EFI_FORM_ID)); if (OpCodeLength >= sizeof (EFI_IFR_REF2)) { CopyMem (&CurrentStatement->RefQuestionId, &((EFI_IFR_REF2 *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID)); if (OpCodeLength >= sizeof (EFI_IFR_REF3)) { CopyMem (&CurrentStatement->RefFormSetId, &((EFI_IFR_REF3 *) OpCodeData)->FormSetId, sizeof (EFI_GUID)); if (OpCodeLength >= sizeof (EFI_IFR_REF4)) { CopyMem (&CurrentStatement->RefDevicePath, &((EFI_IFR_REF4 *) OpCodeData)->DevicePath, sizeof (EFI_STRING_ID)); } } } break; case EFI_IFR_ONE_OF_OP: case EFI_IFR_NUMERIC_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_ONE_OF *) OpCodeData)->Flags; Value = &CurrentStatement->HiiValue; switch (CurrentStatement->Flags & EFI_IFR_NUMERIC_SIZE) { case EFI_IFR_NUMERIC_SIZE_1: CurrentStatement->Minimum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MinValue; CurrentStatement->Maximum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MaxValue; CurrentStatement->Step = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.Step; CurrentStatement->StorageWidth = sizeof (UINT8); Value->Type = EFI_IFR_TYPE_NUM_SIZE_8; break; case EFI_IFR_NUMERIC_SIZE_2: CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MinValue, sizeof (UINT16)); CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MaxValue, sizeof (UINT16)); CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.Step, sizeof (UINT16)); CurrentStatement->StorageWidth = sizeof (UINT16); Value->Type = EFI_IFR_TYPE_NUM_SIZE_16; break; case EFI_IFR_NUMERIC_SIZE_4: CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MinValue, sizeof (UINT32)); CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MaxValue, sizeof (UINT32)); CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.Step, sizeof (UINT32)); CurrentStatement->StorageWidth = sizeof (UINT32); Value->Type = EFI_IFR_TYPE_NUM_SIZE_32; break; case EFI_IFR_NUMERIC_SIZE_8: CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MinValue, sizeof (UINT64)); CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MaxValue, sizeof (UINT64)); CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.Step, sizeof (UINT64)); CurrentStatement->StorageWidth = sizeof (UINT64); Value->Type = EFI_IFR_TYPE_NUM_SIZE_64; break; default: break; } if (Operand == EFI_IFR_ONE_OF_OP) { OneOfOpcode = (EFI_IFR_ONE_OF *) OpCodeData; OneOfType = (UINT8) (OneOfOpcode->Flags & EFI_IFR_NUMERIC_SIZE); } break; case EFI_IFR_ORDERED_LIST_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->Flags; CurrentStatement->MaxContainers = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->MaxContainers; CurrentStatement->StorageWidth = (UINT16)(CurrentStatement->MaxContainers * sizeof (UINT8)); // // No buffer type is defined in EFI_IFR_TYPE_VALUE, so a Configuration Driver // has to use FormBrowser2.Callback() to retrieve the uncommited data for // an interactive orderedlist (i.e. with EFI_IFR_FLAG_CALLBACK flag set). // CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_OTHER; CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth); break; case EFI_IFR_CHECKBOX_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_CHECKBOX *) OpCodeData)->Flags; CurrentStatement->StorageWidth = sizeof (BOOLEAN); CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_BOOLEAN; break; case EFI_IFR_STRING_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); // // MinSize is the minimum number of characters that can be accepted for this opcode, // MaxSize is the maximum number of characters that can be accepted for this opcode. // The characters are stored as Unicode, so the storage width should multiply 2. // CurrentStatement->Minimum = ((EFI_IFR_STRING *) OpCodeData)->MinSize; CurrentStatement->Maximum = ((EFI_IFR_STRING *) OpCodeData)->MaxSize; CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16)); CurrentStatement->Flags = ((EFI_IFR_STRING *) OpCodeData)->Flags; CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING; CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth); break; case EFI_IFR_PASSWORD_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); // // MinSize is the minimum number of characters that can be accepted for this opcode, // MaxSize is the maximum number of characters that can be accepted for this opcode. // The characters are stored as Unicode, so the storage width should multiply 2. // CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_PASSWORD *) OpCodeData)->MinSize, sizeof (UINT16)); CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_PASSWORD *) OpCodeData)->MaxSize, sizeof (UINT16)); CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16)); CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING; CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth); break; case EFI_IFR_DATE_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_DATE *) OpCodeData)->Flags; CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_DATE; break; case EFI_IFR_TIME_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_TIME *) OpCodeData)->Flags; CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_TIME; break; // // Default // case EFI_IFR_DEFAULT_OP: // // EFI_IFR_DEFAULT appear in scope of a Question, // It creates a default value for the current question. // A Question may have more than one Default value which have different default types. // CurrentDefault = AllocateZeroPool (sizeof (QUESTION_DEFAULT)); ASSERT (CurrentDefault != NULL); CurrentDefault->Signature = QUESTION_DEFAULT_SIGNATURE; CurrentDefault->Value.Type = ((EFI_IFR_DEFAULT *) OpCodeData)->Type; CopyMem (&CurrentDefault->DefaultId, &((EFI_IFR_DEFAULT *) OpCodeData)->DefaultId, sizeof (UINT16)); CopyMem (&CurrentDefault->Value.Value, &((EFI_IFR_DEFAULT *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE)); ExtendValueToU64 (&CurrentDefault->Value); // // Insert to Default Value list of current Question // InsertTailList (&CurrentStatement->DefaultListHead, &CurrentDefault->Link); break; // // Option // case EFI_IFR_ONE_OF_OPTION_OP: // // EFI_IFR_ONE_OF_OPTION appear in scope of a Question. // It create a selection for use in current Question. // CurrentOption = AllocateZeroPool (sizeof (QUESTION_OPTION)); ASSERT (CurrentOption != NULL); CurrentOption->Signature = QUESTION_OPTION_SIGNATURE; CurrentOption->Flags = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Flags; CurrentOption->Value.Type = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Type; CopyMem (&CurrentOption->Text, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Option, sizeof (EFI_STRING_ID)); CopyMem (&CurrentOption->Value.Value, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE)); ExtendValueToU64 (&CurrentOption->Value); // // Insert to Option list of current Question // InsertTailList (&CurrentStatement->OptionListHead, &CurrentOption->Link); break; // // Conditional // case EFI_IFR_NO_SUBMIT_IF_OP: case EFI_IFR_INCONSISTENT_IF_OP: break; case EFI_IFR_SUPPRESS_IF_OP: break; case EFI_IFR_GRAY_OUT_IF_OP: break; case EFI_IFR_DISABLE_IF_OP: // // Framework IFR doesn't support DisableIf opcode // if (ThunkContext != NULL && ThunkContext->ByFrameworkHiiNewPack) { ASSERT (FALSE); } // // Expression // case EFI_IFR_VALUE_OP: case EFI_IFR_READ_OP: case EFI_IFR_WRITE_OP: break; case EFI_IFR_RULE_OP: break; // // Image // case EFI_IFR_IMAGE_OP: // // Get ScopeOpcode from top of stack // PopScope (&ScopeOpCode); PushScope (ScopeOpCode); switch (ScopeOpCode) { case EFI_IFR_FORM_SET_OP: ImageId = &FormSet->ImageId; break; case EFI_IFR_FORM_OP: case EFI_IFR_FORM_MAP_OP: ImageId = &CurrentForm->ImageId; break; case EFI_IFR_ONE_OF_OPTION_OP: ImageId = &CurrentOption->ImageId; break; default: // // Make sure CurrentStatement is not NULL. // If it is NULL, 1) ParseOpCodes functions may parse the IFR wrongly. Or 2) the IFR // file is wrongly generated by tools such as VFR Compiler. // ASSERT (CurrentStatement != NULL); ImageId = &CurrentStatement->ImageId; break; } ASSERT (ImageId != NULL); CopyMem (ImageId, &((EFI_IFR_IMAGE *) OpCodeData)->Id, sizeof (EFI_IMAGE_ID)); break; // // Refresh // case EFI_IFR_REFRESH_OP: ASSERT (CurrentStatement != NULL); CurrentStatement->RefreshInterval = ((EFI_IFR_REFRESH *) OpCodeData)->RefreshInterval; break; // // Vendor specific // case EFI_IFR_GUID_OP: OptionMap = (EFI_IFR_GUID_OPTIONKEY *) OpCodeData; if (CompareGuid (&mTianoHiiIfrGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) { // // Tiano specific GUIDed opcodes // switch (((EFI_IFR_GUID_LABEL *) OpCodeData)->ExtendOpCode) { case EFI_IFR_EXTEND_OP_LABEL: // // just ignore label // break; case EFI_IFR_EXTEND_OP_CLASS: CopyMem (&FormSet->Class, &((EFI_IFR_GUID_CLASS *) OpCodeData)->Class, sizeof (UINT16)); break; case EFI_IFR_EXTEND_OP_SUBCLASS: CopyMem (&FormSet->SubClass, &((EFI_IFR_GUID_SUBCLASS *) OpCodeData)->SubClass, sizeof (UINT16)); break; default: break; } } else if (CompareGuid ((EFI_GUID *)(VOID *)&OptionMap->Guid, &mFrameworkHiiCompatibilityGuid)) { if (OptionMap->ExtendOpCode == EFI_IFR_EXTEND_OP_OPTIONKEY) { OneOfOptinMapEntryListHead = GetOneOfOptionMapEntryListHead (FormSet, OptionMap->QuestionId); if (OneOfOptinMapEntryListHead == NULL) { OneOfOptionMap = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP)); ASSERT (OneOfOptionMap != NULL); OneOfOptionMap->Signature = ONE_OF_OPTION_MAP_SIGNATURE; OneOfOptionMap->QuestionId = OptionMap->QuestionId; // // Make sure OneOfType is initialized. // ASSERT (OneOfType != (UINT8) -1); OneOfOptionMap->ValueType = OneOfType; InitializeListHead (&OneOfOptionMap->OneOfOptionMapEntryListHead); OneOfOptinMapEntryListHead = &OneOfOptionMap->OneOfOptionMapEntryListHead; InsertTailList (&FormSet->OneOfOptionMapListHead, &OneOfOptionMap->Link); } OneOfOptionMapEntry = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP_ENTRY)); ASSERT (OneOfOptionMapEntry != NULL); OneOfOptionMapEntry->Signature = ONE_OF_OPTION_MAP_ENTRY_SIGNATURE; OneOfOptionMapEntry->FwKey = OptionMap->KeyValue; CopyMem (&OneOfOptionMapEntry->Value, &OptionMap->OptionValue, sizeof (EFI_IFR_TYPE_VALUE)); InsertTailList (OneOfOptinMapEntryListHead, &OneOfOptionMapEntry->Link); } } break; // // Scope End // case EFI_IFR_END_OP: Status = PopScope (&ScopeOpCode); if (EFI_ERROR (Status)) { ResetScopeStack (); return Status; } switch (ScopeOpCode) { case EFI_IFR_FORM_SET_OP: // // End of FormSet, update FormSet IFR binary length // to stop parsing substantial OpCodes // FormSet->IfrBinaryLength = OpCodeOffset; break; case EFI_IFR_FORM_OP: case EFI_IFR_FORM_MAP_OP: // // End of Form // CurrentForm = NULL; break; case EFI_IFR_ONE_OF_OPTION_OP: // // End of Option // CurrentOption = NULL; break; case EFI_IFR_SUBTITLE_OP: mInScopeSubtitle = FALSE; break; case EFI_IFR_NO_SUBMIT_IF_OP: case EFI_IFR_INCONSISTENT_IF_OP: // // Ignore end of EFI_IFR_NO_SUBMIT_IF and EFI_IFR_INCONSISTENT_IF // break; case EFI_IFR_GRAY_OUT_IF_OP: mInScopeGrayOut = FALSE; break; default: if (IsExpressionOpCode (ScopeOpCode)) { } break; } break; default: break; } } return EFI_SUCCESS; }
int main(int argc, const char **argv) // ignore_convention { int64 LastUpdate = time_get(); dbg_logger_stdout(); net_init(); IKernel *pKernel = IKernel::Create(); IStorage *pStorage = CreateStorage("Teeworlds", argc, argv); // ignore_convention m_pConsole = CreateConsole(CFGFLAG_BANMASTER); m_pConsole->RegisterPrintCallback(StandardOutput, 0); m_pConsole->Register("ban", "s?r", CFGFLAG_BANMASTER, ConBan, 0, "Bans the specified ip", 0); m_pConsole->Register("unban_all", "", CFGFLAG_BANMASTER, ConUnbanAll, 0, "Unbans all ips", 0); m_pConsole->Register("bind", "s", CFGFLAG_BANMASTER, ConSetBindAddr, 0, "Binds to the specified address", 0); { bool RegisterFail = false; RegisterFail = RegisterFail || !pKernel->RegisterInterface(m_pConsole); RegisterFail = RegisterFail || !pKernel->RegisterInterface(pStorage); if(RegisterFail) return -1; } m_pConsole->ExecuteFile(BANMASTER_BANFILE); NETADDR BindAddr; if(m_aBindAddr[0] && net_host_lookup(m_aBindAddr, &BindAddr, NETTYPE_IPV4) == 0) { if(BindAddr.port == 0) BindAddr.port = BANMASTER_PORT; } else { mem_zero(&BindAddr, sizeof(BindAddr)); BindAddr.port = BANMASTER_PORT; } m_Net.Open(BindAddr, 0); // TODO: DDRace: heinrich5991: check socket for errors dbg_msg("banmaster", "started"); while(1) { m_Net.Update(); // process m_aPackets CNetChunk p; while(m_Net.Recv(&p)) { if(p.m_DataSize >= (int)sizeof(BANMASTER_IPCHECK) && !mem_comp(p.m_pData, BANMASTER_IPCHECK, sizeof(BANMASTER_IPCHECK))) { char *pAddr = (char*)p.m_pData + sizeof(BANMASTER_IPCHECK); NETADDR CheckAddr; if(net_addr_from_str(&CheckAddr, pAddr)) { dbg_msg("banmaster", "dropped weird message ip=%d.%d.%d.%d checkaddr='%s'", p.m_Address.ip[0], p.m_Address.ip[1], p.m_Address.ip[2], p.m_Address.ip[3], pAddr); } else { int Banned = SendResponse(&p.m_Address, &CheckAddr); dbg_msg("banmaster", "responded to checkmsg ip=%d.%d.%d.%d checkaddr=%d.%d.%d.%d result=%s", p.m_Address.ip[0], p.m_Address.ip[1], p.m_Address.ip[2], p.m_Address.ip[3], CheckAddr.ip[0], CheckAddr.ip[1], CheckAddr.ip[2], CheckAddr.ip[3], (Banned) ? "ban" : "ok"); } } } if(time_get() - LastUpdate > time_freq() * BAN_REREAD_TIME) { ClearBans(); LastUpdate = time_get(); m_pConsole->ExecuteFile(BANMASTER_BANFILE); } // be nice to the CPU thread_sleep(1); } return 0; }
void AddressBook::InsertAddress (const i2p::data::IdentityEx& address) { if (!m_Storage) m_Storage = CreateStorage (); m_Storage->AddAddress (address); }
int main(int argc, const char **argv) { dbg_logger_stdout(); IStorage *pStorage = CreateStorage("Teeworlds", IStorage::STORAGETYPE_BASIC, argc, argv); if(argc != 5) { dbg_msg("map_replace_image", "Invalid arguments"); dbg_msg("map_replace_image", "Usage: map_replace_image <source map filepath> <dest map filepath> <current image name> <new image filepath>"); dbg_msg("map_replace_image", "Notes: map filepath must be relative to user default teeworlds folder"); dbg_msg("map_replace_image", " new image filepath must be absolute or relative to the current position"); return -1; } if (!pStorage) { dbg_msg("map_replace_image", "error loading storage"); return -1; } const char *pSourceFileName = argv[1]; const char *pDestFileName = argv[2]; const char *pImageName = argv[3]; const char *pImageFile = argv[4]; int ID = 0; int Type = 0; int Size = 0; void *pItem = 0; void *pData = 0; if(!g_DataReader.Open(pStorage, pSourceFileName, IStorage::TYPE_ALL)) { dbg_msg("map_replace_image", "failed to open source map. filename='%s'", pSourceFileName); return -1; } if(!g_DataWriter.Open(pStorage, pDestFileName)) { dbg_msg("map_replace_image", "failed to open destination map. filename='%s'", pDestFileName); return -1; } png_init(0,0); // add all items for(int Index = 0; Index < g_DataReader.NumItems(); Index++) { CMapItemImage NewImageItem; pItem = g_DataReader.GetItem(Index, &Type, &ID); Size = g_DataReader.GetItemSize(Index); pItem = ReplaceImageItem(pItem, Type, pImageName, pImageFile, &NewImageItem); if(!pItem) return -1; g_DataWriter.AddItem(Type, ID, Size, pItem); } if(g_NewDataID == -1) { dbg_msg("map_replace_image", "image '%s' not found on source map '%s'.", pImageName, pSourceFileName); return -1; } // add all data for(int Index = 0; Index < g_DataReader.NumItems(); Index++) { if(Index == g_NewDataID) { pData = g_pNewData; Size = g_NewDataSize; } else if (Index == g_NewNameID) { pData = (void *)g_aNewName; Size = str_length(g_aNewName) + 1; } else { pData = g_DataReader.GetData(Index); Size = g_DataReader.GetDataSize(Index); } g_DataWriter.AddData(Size, pData); } g_DataReader.Close(); g_DataWriter.Finish(); dbg_msg("map_replace_image", "image '%s' replaced", pImageName); return 0; }