VOID NTAPI ConDrvInitConsoleSupport(VOID) { DPRINT("CONSRV: ConDrvInitConsoleSupport()\n"); /* Initialize the console list and its lock */ InitializeListHead(&ConsoleList); RtlInitializeResource(&ListLock); }
static void rwlock_real_init(pthread_rwlock_t *rwlock) { RTL_RWLOCK *lock = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(RTL_RWLOCK)); RtlInitializeResource(lock); if (interlocked_cmpxchg_ptr((void**)&(((wine_rwlock)rwlock)->lock),lock,NULL) != NULL) { /* too late, some other thread already did it */ RtlDeleteResource(lock); RtlFreeHeap(GetProcessHeap(), 0, lock); } }
NTSTATUS LsapAuInitializeContextMgr( VOID ) /*++ Routine Description: This routine initializes the global components of the client context management services. This includes a initializing a database lock and a list of client contexts. Arguments: None. Return Value: Only STATUS_SUCCESS is expected. But, if we encounter an error initializing then the error we hit will be returned. --*/ { // // Initialize the database lock // RtlInitializeResource(&LsapAuClientContextLock); // // Initialize the context list to be empty. // InitializeListHead( &LsapAuClientContextListHead ); return(STATUS_SUCCESS); }
NTSTATUS LogfCreate(PLOGFILE *LogFile, WCHAR *LogName, PUNICODE_STRING FileName, ULONG ulMaxSize, ULONG ulRetention, BOOL Permanent, BOOL Backup) { OBJECT_ATTRIBUTES ObjectAttributes; IO_STATUS_BLOCK IoStatusBlock; PLOGFILE pLogFile; BOOL bCreateNew = FALSE; NTSTATUS Status = STATUS_SUCCESS; pLogFile = (LOGFILE *) HeapAlloc(MyHeap, HEAP_ZERO_MEMORY, sizeof(LOGFILE)); if (!pLogFile) { DPRINT1("Can't allocate heap!\n"); return STATUS_NO_MEMORY; } InitializeObjectAttributes(&ObjectAttributes, FileName, OBJ_CASE_INSENSITIVE, NULL, NULL); Status = NtCreateFile(&pLogFile->hFile, Backup ? (GENERIC_READ | SYNCHRONIZE) : (GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE), &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, Backup ? FILE_OPEN : FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0); if (!NT_SUCCESS(Status)) { DPRINT1("Can't create file %wZ (Status: 0x%08lx)\n", FileName, Status); goto fail; } bCreateNew = (IoStatusBlock.Information == FILE_CREATED) ? TRUE: FALSE; pLogFile->LogName = (WCHAR *) HeapAlloc(MyHeap, HEAP_ZERO_MEMORY, (lstrlenW(LogName) + 1) * sizeof(WCHAR)); if (pLogFile->LogName == NULL) { DPRINT1("Can't allocate heap\n"); Status = STATUS_NO_MEMORY; goto fail; } if (LogName) StringCchCopy(pLogFile->LogName,lstrlenW(LogName) + 1, LogName); pLogFile->FileName = (WCHAR *) HeapAlloc(MyHeap, HEAP_ZERO_MEMORY, (lstrlenW(FileName->Buffer) + 1) * sizeof(WCHAR)); if (pLogFile->FileName == NULL) { DPRINT1("Can't allocate heap\n"); Status = STATUS_NO_MEMORY; goto fail; } StringCchCopy(pLogFile->FileName, lstrlenW(FileName->Buffer) + 1, FileName->Buffer); pLogFile->OffsetInfo = (PEVENT_OFFSET_INFO) HeapAlloc(MyHeap, HEAP_ZERO_MEMORY, sizeof(EVENT_OFFSET_INFO) * 64); if (pLogFile->OffsetInfo == NULL) { DPRINT1("Can't allocate heap\n"); Status = STATUS_NO_MEMORY; goto fail; } pLogFile->OffsetInfoSize = 64; pLogFile->Permanent = Permanent; if (bCreateNew) Status = LogfInitializeNew(pLogFile, ulMaxSize, ulRetention); else Status = LogfInitializeExisting(pLogFile, Backup); if (!NT_SUCCESS(Status)) goto fail; RtlInitializeResource(&pLogFile->Lock); LogfListAddItem(pLogFile); fail: if (!NT_SUCCESS(Status)) { if ((pLogFile->hFile != NULL) && (pLogFile->hFile != INVALID_HANDLE_VALUE)) CloseHandle(pLogFile->hFile); if (pLogFile->OffsetInfo) HeapFree(MyHeap, 0, pLogFile->OffsetInfo); if (pLogFile->FileName) HeapFree(MyHeap, 0, pLogFile->FileName); if (pLogFile->LogName) HeapFree(MyHeap, 0, pLogFile->LogName); HeapFree(MyHeap, 0, pLogFile); } else { *LogFile = pLogFile; } return Status; }
NET_API_STATUS BrCreateNetwork( PUNICODE_STRING TransportName, IN BOOLEAN Wannish, IN BOOLEAN Ras, IN PUNICODE_STRING AlternateTransportName OPTIONAL ) /*++ Routine Description: This routine allocates memory to hold a network structure, and initializes all of its associated data structures. Arguments: TransportName - The name of the transport to add. Return Value: Status of operation (mostly status of allocations). --*/ { NET_API_STATUS Status; PNETWORK Network; BOOLEAN NetworkLockInitialized = FALSE; BOOLEAN MasterFlagsInitialized = FALSE; BOOLEAN BackupBrowserTimerCreated = FALSE; BOOLEAN MasterBrowserTimerCreated =FALSE; BOOLEAN AnnouncementTimerCreated = FALSE; BOOLEAN ResponseCacheLockInitialized = FALSE; // // Check to see if the transport already exists. // if ((Network = BrFindNetwork(TransportName)) != NULL) { return NERR_AlreadyExists; } // // If this transport is explicitly on our list of transports to unbind, // simply ignore the transport. // if (BrInfo.UnboundBindings != NULL) { LPTSTR_ARRAY TStrArray = BrInfo.UnboundBindings; while (!NetpIsTStrArrayEmpty(TStrArray)) { LPWSTR NewTransportName; #define NAME_PREFIX L"\\Device\\" #define NAME_PREFIX_LENGTH 8 // // The transport name in the registry is only optionally prefixed with \device\ // if ( _wcsnicmp( NAME_PREFIX, TStrArray, NAME_PREFIX_LENGTH) == 0 ) { NewTransportName = TransportName->Buffer; } else { NewTransportName = TransportName->Buffer + NAME_PREFIX_LENGTH; } if ( _wcsicmp( TStrArray, NewTransportName ) == 0 ) { dprintf(INIT, ("Binding is marked as unbound: %s (Silently ignoring)\n", TransportName->Buffer )); return NERR_Success; } TStrArray = NetpNextTStrArrayEntry(TStrArray); } } // // If this transport isn't bound to the SMB server, // don't create the transport here. // we do announcments through the SMB server. // Status = I_NetServerSetServiceBits(NULL, TransportName->Buffer, 0, TRUE); if (Status == ERROR_PATH_NOT_FOUND ) { dprintf(INIT, ("SMB Server doesn't have this transport: %s (Silently unbinding)\n", TransportName->Buffer )); return NERR_Success; } // // Create the transport. // try { Network = MIDL_user_allocate(sizeof(NETWORK)); if (Network == NULL) { try_return(Status = ERROR_NOT_ENOUGH_MEMORY); } RtlInitializeResource(&Network->Lock); NetworkLockInitialized = TRUE; Network->LockCount = 0; Network->ReferenceCount = 1; Network->Role = BrDefaultRole; Network->NumberOfFailedBackupTimers = 0; Network->NumberOfFailedPromotions = 0; Network->NumberOfPromotionEventsLogged = 0; Network->LastBackupBrowserReturned = 0; Network->LastDomainControllerBrowserReturned = 0; Network->TimeStoppedBackup = 0; Network->BackupServerList = NULL; Network->BackupDomainList = NULL; Network->TotalBackupServerListEntries = 0; Network->TotalBackupDomainListEntries = 0; Network->NetworkName.Buffer = MIDL_user_allocate(TransportName->MaximumLength); if (Network->NetworkName.Buffer == NULL) { try_return(Status = ERROR_NOT_ENOUGH_MEMORY); } Network->NetworkName.MaximumLength = TransportName->MaximumLength; RtlCopyUnicodeString(&Network->NetworkName, TransportName); Network->Flags = 0; if (ARGUMENT_PRESENT(AlternateTransportName)) { PNETWORK AlternateNetwork = BrFindNetwork(AlternateTransportName); // // If we didn't find an alternate network, or if that network // already has an alternate network, return an error. // if (AlternateNetwork == NULL || AlternateNetwork->AlternateNetwork != NULL) { try_return(Status = NERR_InternalError); } Network->Flags |= NETWORK_IPX; // // Link the two networks together. // Network->AlternateNetwork = AlternateNetwork; AlternateNetwork->AlternateNetwork = Network; } else { Network->AlternateNetwork = NULL; } // // Null terminate the network name buffer. // Network->NetworkName.Buffer[Network->NetworkName.Length/sizeof(WCHAR)] = UNICODE_NULL; RtlInitUnicodeString(&Network->MasterBrowserName, NULL); if (Wannish) { Network->Flags |= NETWORK_WANNISH; } if (Ras) { Network->Flags |= NETWORK_RAS; } Network->LastBowserServerQueried = 0; RtlInitializeCriticalSection(&Network->MasterFlagsLock); MasterFlagsInitialized = TRUE; Network->MasterFlags = 0; InitializeInterimServerList(&Network->BrowseTable, BrBrowseTableInsertRoutine, BrBrowseTableUpdateRoutine, BrBrowseTableDeleteRoutine, BrBrowseTableAgeRoutine); Network->LastBowserDomainQueried = 0; InitializeInterimServerList(&Network->DomainList, BrDomainTableInsertRoutine, BrDomainTableUpdateRoutine, BrDomainTableDeleteRoutine, BrDomainTableAgeRoutine); InitializeListHead(&Network->OtherDomainsList); Status = BrCreateTimer(&Network->BackupBrowserTimer); if (Status != NERR_Success) { try_return(Status); } BackupBrowserTimerCreated = TRUE; Status = BrCreateTimer(&Network->MasterBrowserTimer); if (Status != NERR_Success) { try_return(Status); } MasterBrowserTimerCreated = TRUE; Status = BrCreateTimer(&Network->MasterBrowserAnnouncementTimer); if (Status != NERR_Success) { try_return(Status); } AnnouncementTimerCreated = TRUE; InitializeCriticalSection(&Network->ResponseCacheLock); ResponseCacheLockInitialized = TRUE; InitializeListHead(&Network->ResponseCache); Network->TimeCacheFlushed = 0; Network->NumberOfCachedResponses = 0; Status = RtlEnterCriticalSection(&NetworkLock); if (!NT_SUCCESS(Status)) { try_return(Status = BrMapStatus(Status)); } InsertHeadList(&ServicedNetworks, &Network->NextNet); Status = RtlLeaveCriticalSection(&NetworkLock); if (!NT_SUCCESS(Status)) { InternalError(("Unable to release browser critical section\n")); } try_exit:NOTHING; } finally { if (Status != NERR_Success) { if (Network != NULL) { if (ResponseCacheLockInitialized) { DeleteCriticalSection(&Network->ResponseCacheLock); } if (MasterFlagsInitialized) { RtlDeleteCriticalSection(&Network->MasterFlagsLock); } if (NetworkLockInitialized) { RtlDeleteResource(&Network->Lock); } if (AnnouncementTimerCreated) { BrDestroyTimer(&Network->MasterBrowserAnnouncementTimer); } if (MasterBrowserTimerCreated) { BrDestroyTimer(&Network->MasterBrowserTimer); } if (BackupBrowserTimerCreated) { BrDestroyTimer(&Network->BackupBrowserTimer); } if (Network->NetworkName.Buffer != NULL) { MIDL_user_free(Network->NetworkName.Buffer); } MIDL_user_free(Network); } } } return Status; }
NTSTATUS LogfCreate(PLOGFILE* LogFile, PCWSTR LogName, PUNICODE_STRING FileName, ULONG MaxSize, ULONG Retention, BOOLEAN Permanent, BOOLEAN Backup) { NTSTATUS Status; OBJECT_ATTRIBUTES ObjectAttributes; IO_STATUS_BLOCK IoStatusBlock; FILE_STANDARD_INFORMATION FileStdInfo; PLOGFILE pLogFile; SIZE_T LogNameLen; BOOLEAN CreateNew; pLogFile = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pLogFile)); if (!pLogFile) { DPRINT1("Cannot allocate heap!\n"); return STATUS_NO_MEMORY; } LogNameLen = (LogName ? wcslen(LogName) : 0) + 1; pLogFile->LogName = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, LogNameLen * sizeof(WCHAR)); if (pLogFile->LogName == NULL) { DPRINT1("Cannot allocate heap\n"); Status = STATUS_NO_MEMORY; goto Quit; } if (LogName) StringCchCopyW(pLogFile->LogName, LogNameLen, LogName); InitializeObjectAttributes(&ObjectAttributes, FileName, OBJ_CASE_INSENSITIVE, NULL, NULL); DPRINT1("Going to create or open %wZ\n", FileName); Status = NtCreateFile(&pLogFile->FileHandle, Backup ? (GENERIC_READ | SYNCHRONIZE) : (GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE), &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, Backup ? FILE_OPEN : FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0); if (!NT_SUCCESS(Status)) { DPRINT1("Cannot create file `%wZ' (Status 0x%08lx)\n", FileName, Status); goto Quit; } CreateNew = (IoStatusBlock.Information == FILE_CREATED); DPRINT1("%wZ %s successfully\n", FileName, CreateNew ? "created" : "opened"); /* * Retrieve the log file size and check whether the file is not too large; * this log format only supports files of theoretical size < 0xFFFFFFFF . * * As it happens that, on Windows (and ReactOS), retrieving the End-Of-File * information using NtQueryInformationFile with the FileEndOfFileInformation * class is invalid (who knows why...), use instead the FileStandardInformation * class, and the EndOfFile member of the returned FILE_STANDARD_INFORMATION * structure will give the desired information. */ Status = NtQueryInformationFile(pLogFile->FileHandle, &IoStatusBlock, &FileStdInfo, sizeof(FileStdInfo), FileStandardInformation); if (!NT_SUCCESS(Status)) { DPRINT1("EventLog: NtQueryInformationFile failed (Status 0x%08lx)\n", Status); goto Quit; } if (FileStdInfo.EndOfFile.HighPart != 0) { DPRINT1("EventLog: Log `%wZ' is too large.\n", FileName); Status = STATUS_EVENTLOG_FILE_CORRUPT; // STATUS_FILE_TOO_LARGE; goto Quit; } DPRINT("Initializing LogFile `%S'\n", pLogFile->LogName); Status = ElfCreateFile(&pLogFile->LogFile, FileName, FileStdInfo.EndOfFile.LowPart, MaxSize, Retention, CreateNew, Backup, LogfpAlloc, LogfpFree, LogfpSetFileSize, LogfpWriteFile, LogfpReadFile, LogfpFlushFile); if (!NT_SUCCESS(Status)) goto Quit; pLogFile->Permanent = Permanent; RtlInitializeResource(&pLogFile->Lock); LogfListAddItem(pLogFile); Quit: if (!NT_SUCCESS(Status)) { if (pLogFile->FileHandle != NULL) NtClose(pLogFile->FileHandle); if (pLogFile->LogName) RtlFreeHeap(GetProcessHeap(), 0, pLogFile->LogName); RtlFreeHeap(GetProcessHeap(), 0, pLogFile); } else { *LogFile = pLogFile; } return Status; }