void bt_mgrclose (BtMgr *mgr) { BtPool *pool; uint slot; // release mapped pages // note that slot zero is never used for( slot = 1; slot < mgr->poolmax; slot++ ) { pool = mgr->pool + slot; if( pool->slot ) #ifdef unix munmap (pool->map, (mgr->poolmask+1) << mgr->page_bits); #else { FlushViewOfFile(pool->map, 0); UnmapViewOfFile(pool->map); CloseHandle(pool->hmap); } #endif } #ifdef unix close (mgr->idx); free (mgr->pool); free (mgr->hash); free (mgr->latch); free (mgr->pooladvise); free (mgr); #else FlushFileBuffers(mgr->idx); CloseHandle(mgr->idx); GlobalFree (mgr->pool); GlobalFree (mgr->hash); GlobalFree (mgr->latch); GlobalFree (mgr); #endif }
bool FileSystem::FlushDirBuffers(const char* filename, CString& errmsg) { #ifdef WIN32 FILE* file = _wfopen(UtfPathToWidePath(filename), WString(FOPEN_RBP)); #else BString<1024> parentPath = filename; char* p = (char*)strrchr(parentPath, PATH_SEPARATOR); if (p) { *p = '\0'; } FILE* file = fopen(parentPath, FOPEN_RB); #endif if (!file) { errmsg = GetLastErrorMessage(); return false; } bool ok = FlushFileBuffers(fileno(file), errmsg); fclose(file); return ok; }
bool SendAck(HANDLE pipe) { DWORD written, ack = 0; if (!WriteFile(pipe, &ack, sizeof(DWORD), &written, NULL) && written != sizeof(DWORD)) { #ifdef DEBUG_IPC CUtils::Log(_T("SendAck: WriteFile failed. (%d)"), GetLastError()); #endif return false; } if (!FlushFileBuffers(pipe)) { #ifdef DEBUG_IPC CUtils::Log(_T("SendAck: FlushFileBuffers failed. (%d)"), GetLastError()); #endif return false; } if (!DisconnectNamedPipe(pipe)) { #ifdef DEBUG_IPC CUtils::Log(_T("SendAck: DisconnectNamedPipe failed. (%d)"), GetLastError()); #endif return false; } return true; }
/** * Flushes the file buffers, writing all data immediately. * @return Returns 1 on success, 0 on error. */ short LbFileFlush(TbFileHandle handle) { #if defined(WIN32) int result; // Crappy Windows has its own result = FlushFileBuffers((HANDLE)handle); // It returns 'invalid handle' error sometimes for no reason.. so disabling this error if (result != 0) return 1; result = GetLastError(); return ((result == 0) || (result == 6)); #else #if defined(DOS)||defined(GO32) // No idea how to do this on old systems return 1; #else // For normal POSIX systems // (should also work on Win, as its IEEE standard... but it currently isn't) return (ioctl(handle,I_FLUSH,FLUSHRW) != -1); #endif #endif }
bool PipeReader::CheckATR() { //SectionLocker lock(dataSection); if (pipe==NULL) return false; DWORD read=0; DWORD command=1; if (!WriteFile(pipe,&command,sizeof(DWORD),&read,NULL)) { return false; } FlushFileBuffers(pipe); DWORD size=0; if (!ReadFile(pipe,&size,sizeof(DWORD),&read,NULL)) { return false; } if (size==0) return false; BYTE ATR[100]; if (!ReadFile(pipe,ATR,size,&read,NULL)) { return false; } return true; }
bool EtfArduinoService::SendMessage(LPVOID lpvMessage, DWORD bufferSize) { if (hPipe == 0) if (!OpenPipeConnection()) return false; DWORD cbToWrite = bufferSize * sizeof(message_t); DWORD cbWritten = 0; BOOL fSuccess = WriteFile( hPipe, // pipe handle lpvMessage, // message cbToWrite, // message length &cbWritten, // bytes written NULL); // not overlapped // Make sure the message got through the pipe before returning. FlushFileBuffers(hPipe); if (!fSuccess) { _tprintf(TEXT("WriteFile to pipe failed. GLE=%d\n"), GetLastError()); return false; } if (cbWritten != cbToWrite) { return false; } return true; }
RS232_LIB unsigned int rs232_flush(struct rs232_port_t *p) { struct rs232_windows_t *wx = p->pt; DBG("p=%p p->pt=%p\n", (void *)p, p->pt); if (!rs232_port_open(p)) return RS232_ERR_PORT_CLOSED; if (!FlushFileBuffers(wx->fd)) { DBG("FlushFileBuffers() %s\n", last_error()); return RS232_ERR_FLUSH; } if (!PurgeComm(wx->fd, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR)) { DBG("PurgeComm() %s\n", last_error()); return RS232_ERR_FLUSH; } return RS232_ERR_NOERROR; }
void ADIOI_NTFS_Flush(ADIO_File fd, int *error_code) { int err; static char myname[] = "ADIOI_NTFS_Flush"; err = (fd->access_mode & ADIO_RDONLY) ? TRUE : FlushFileBuffers(fd->fd_sys); /* --BEGIN ERROR HANDLING-- */ if (err == FALSE) { char errMsg[ADIOI_NTFS_ERR_MSG_MAX]; err = GetLastError(); ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX); *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", errMsg); return; } /* --END ERROR HANDLING-- */ *error_code = MPI_SUCCESS; }
int CTreeHandler::Dbg_DumpTree() { HANDLE hfile; int ret = 0; CTreeElem* rootelem = 0; int errcnt = 0; hfile = CreateFile( (LPCTSTR)"dbgdump.txt", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_SEQUENTIAL_SCAN, NULL ); if( hfile == INVALID_HANDLE_VALUE ){ return 1; } rootelem = (*this)( 0 ); if( rootelem ){ rootelem->Dbg_DumpReq( hfile, errcnt ); _ASSERT( !errcnt ); if( errcnt ){ DbgOut( "CTreeHandler : Dbg_DumpTree : Dbg_DumpReq error !!!\n" ); return 1; } }else{ DbgOut( "CTreeHandler : Dbg_DumpTree : rootelem error !!!\n" ); return 1; } FlushFileBuffers( hfile ); CloseHandle( hfile ); DbgOut( "CTreeHandler : DumpTree : CloseHandle\n" ); return ret; }
/* *---------------------------------------------------------------------- * * OS_IpcClose * * OS IPC routine to close an IPC connection. * * Results: * * * Side effects: * IPC connection is closed. * *---------------------------------------------------------------------- */ int OS_IpcClose(int ipcFd, int shutdown) { if (ipcFd == -1) return 0; /* * Catch it if fd is a bogus value */ ASSERT((ipcFd >= 0) && (ipcFd < WIN32_OPEN_MAX)); ASSERT(fdTable[ipcFd].type != FD_UNUSED); switch (listenType) { case FD_PIPE_SYNC: /* * Make sure that the client (ie. a Web Server in this case) has * read all data from the pipe before we disconnect. */ if (! FlushFileBuffers(fdTable[ipcFd].fid.fileHandle)) return -1; if (! DisconnectNamedPipe(fdTable[ipcFd].fid.fileHandle)) return -1; /* fall through */ case FD_SOCKET_SYNC: OS_Close(ipcFd, shutdown); break; case FD_UNUSED: default: exit(106); break; } return 0; }
DWORD APIENTRY BasepCrossVolumeMoveHelper( LARGE_INTEGER TotalFileSize, LARGE_INTEGER TotalBytesTransferred, LARGE_INTEGER StreamSize, LARGE_INTEGER StreamBytesTransferred, DWORD dwStreamNumber, DWORD dwCallbackReason, HANDLE SourceFile, HANDLE DestinationFile, LPVOID lpData OPTIONAL ) { PHELPER_CONTEXT Context = (PHELPER_CONTEXT)lpData; if ( dwCallbackReason == CALLBACK_STREAM_SWITCH ) { #ifdef _CAIRO_ OBJECTID *poid; if ( poid = Context->pObjectId ) { RtlSetObjectId(DestinationFile, poid); Context->pObjectId = NULL; } #endif if ( !(Context->dwFlags & MOVEFILE_WRITE_THROUGH) ) { return PROGRESS_QUIET; } } else if ( dwCallbackReason == CALLBACK_CHUNK_FINISHED ) { if ( StreamBytesTransferred.QuadPart == StreamSize.QuadPart ) { FlushFileBuffers(DestinationFile); } } return PROGRESS_CONTINUE; }
void PackFile::closePakFile(void) { //清空所有打开的文件 while(!m_listStream.empty()) { (*m_listStream.begin())->close(); } //remove edit flag if(m_fileHead.nEditFlag != 0) { m_fileHead.nEditFlag = 0; writeFileHead(); } //Close handle if(m_hPakFile) { FlushFileBuffers(m_hPakFile); CloseHandle(m_hPakFile); m_hPakFile = 0; } //清空Stream打开的文件句柄 FileHandleMap::iterator it; for(it=m_mapFileHandle.begin(); it!=m_mapFileHandle.end(); it++) { ::CloseHandle(it->second); } m_mapFileHandle.clear(); //清空表 memset(&m_fileHead, 0, sizeof(FILE_HEAD)); memset(m_hashTable, 0, sizeof(FILE_HASHNODE)*HASH_TABLE_SIZE); m_blockTable.clear(); m_mapFreeBlock.clear(); m_bConst = true; }
/*---------------------------------------------------------------------------------------------- Flush the file's buffer. Since we are dealing with a file opened in director mode, we just flush the buffer and ignore the grfCommitFlags. ----------------------------------------------------------------------------------------------*/ STDMETHODIMP FileStream::Commit(DWORD grfCommitFlags) { BEGIN_COM_METHOD; #if WIN32 // FlushFileBuffers may return an error if m_hfile doesn't have GENERIC_WRITE access. if (!(m_grfstgm & (kfstgmReadWrite | kfstgmWrite))) ThrowHr(WarnHr(STG_E_INVALIDFUNCTION)); if (!FlushFileBuffers(m_hfile)) { // REVIEW JohnL: Should we check for medium full before returning this code? ThrowHr(WarnHr(STG_E_MEDIUMFULL)); } #else // FlushFileBuffers may return an error if m_hfile doesn't have GENERIC_WRITE access. if (!(m_flags & (O_RDWR | O_WRONLY))) ThrowHr(WarnHr(STG_E_INVALIDFUNCTION)); if (fsync(m_file)) return S_OK; #endif END_COM_METHOD(g_fact, IID_IStream); }
bool SerialPort::openPort(const char *device, int baudrate, bool bXonXoff, int DTRtime) { close(); d->m_time = DTRtime; d->m_baudrate = baudrate; d->m_bXonXoff = bXonXoff; string port; // = "\\\\.\\"; port += device; port += ":"; d->hPort = CreateFileA(port.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL); if (d->hPort == INVALID_HANDLE_VALUE){ close(); log(L_WARN, "Can' open %s", port.c_str()); return false; } FlushFileBuffers(d->hPort); if (!EscapeCommFunction(d->hPort, CLRDTR)){ close(); log(L_WARN, "Clear DTR error"); return false; } d->m_timer->start(d->m_time, true); return true; }
ssize_t diag_tty_write(struct diag_l0_device *dl0d, const void *buf, const size_t count) { DWORD byteswritten; OVERLAPPED *pOverlap; struct tty_int *wti = (struct tty_int *)dl0d->tty_int; pOverlap=NULL; //note : if overlap is eventually enabled, the CreateFile flags should be adjusted if (wti->fd == INVALID_HANDLE_VALUE) { fprintf(stderr, FLFMT "Error. Is the port open ?\n", FL); return diag_iseterr(DIAG_ERR_GENERAL); } if (count <= 0) return diag_iseterr(DIAG_ERR_BADLEN); if (! WriteFile(wti->fd, buf, count, &byteswritten, pOverlap)) { fprintf(stderr, FLFMT "WriteFile error:%s. %u bytes written, %u requested\n", FL, diag_os_geterr(0), (unsigned int) byteswritten, count); return diag_iseterr(DIAG_ERR_GENERAL); } if (!FlushFileBuffers(wti->fd)) { fprintf(stderr, FLFMT "tty_write : could not flush buffers, %s\n", FL, diag_os_geterr(0)); return diag_iseterr(DIAG_ERR_GENERAL); } return byteswritten; } //diag_tty_write
int Open_ProIn() { char com_str[10]; sprintf(com_str,"%s:",DeviceNameIN); LPSTR lpszPortName = _T(com_str); com_handle_IN = CreateFile( lpszPortName, GENERIC_READ | GENERIC_WRITE, 0, // DWORD dwShareMode, NULL, // LPSECURITY_ATTRIBUTES lpSecurityAttributes, OPEN_EXISTING, // DWORD dwCreationDispostion, 0, //FILE_FLAG_OVERLAPPED, // DWORD dwFlagsAndAttributes, NULL // HANDLE hTemplateFile ); int iRetIn = (int)(com_handle_IN ); if (iRetIn<0) { com_handle_IN = NULL; sprintf(string_display_dmx_params,"Impossible to open interface, is it PLUGGED ?"); return(0); } else {sprintf(string_display_dmx_params,"Enttec Pro IN %s is now Open",DeviceNameIN);} // SetCommState & Timeout Enttec_Pro_SetCommParamsIN(); // flush rx & tx buffers resIn = FlushFileBuffers(com_handle_IN); if (!resIn) { sprintf(string_display_dmx_params,"\ENTTEC PRO IN %s: Flush file buffers failed...",DeviceNameIN); CloseHandle(com_handle_IN); com_handle_IN = NULL; return(0); }
void Channel::Destroy() { if (m_creator) { FlushFileBuffers(m_pipe); DisconnectNamedPipe(m_pipe); m_creator = false; } if (m_doneEvent != INVALID_HANDLE_VALUE) { // Signal the done event so that if we're currently blocked reading, // we'll stop. SetEvent(m_doneEvent); CloseHandle(m_doneEvent); m_doneEvent = INVALID_HANDLE_VALUE; } if (m_readEvent != INVALID_HANDLE_VALUE) { CloseHandle(m_readEvent); m_readEvent = INVALID_HANDLE_VALUE; } if (m_pipe != INVALID_HANDLE_VALUE) { CloseHandle(m_pipe); m_pipe = INVALID_HANDLE_VALUE; } }
int32_t omrfile_sync(struct OMRPortLibrary *portLibrary, intptr_t fd) { HANDLE handle = toHandle(portLibrary, fd); Trc_PRT_file_sync_Entry(fd); /* * According to MSDN: * 1) If hFile is a handle to the server end of a named pipe, the function does not return until the client has read all buffered data from the pipe. * 2) The function fails if hFile is a handle to the console output. That is because the console output is not buffered. The function returns FALSE, and GetLastError returns ERROR_INVALID_HANDLE. * * This behaviour caused JAZZ 44899 defect: Test_SimpleTenantLimitXmt would freeze while waiting for process to terminate while child * was waiting for parent to read from STDIN and STDOUT streams of a child. * * Manual testing showed that even if we called System.out.print('X') and System.err.print('Y') a parent process would still get receive 'X' and 'Y' * (with and without flushing) after child process in terminated. * * This check does not modify original behaviour of the port library because we never actually flushed STDIN and STDOUT handles but * some arbitrary handles 1 & 2. */ if (((HANDLE)OMRPORT_TTY_OUT == (HANDLE)fd) || ((HANDLE)OMRPORT_TTY_ERR == (HANDLE)fd)) { Trc_PRT_file_sync_Exit(0); return 0; } if (FlushFileBuffers(handle)) { Trc_PRT_file_sync_Exit(0); return 0; } else { int32_t error = GetLastError(); error = portLibrary->error_set_last_error(portLibrary, error, findError(error)); Trc_PRT_file_sync_Exit(error); return -1; } }
bool PipeReader::QueryATR(BYTE *ATR,DWORD *ATRsize,bool reset) { if (pipe==NULL) return false; DWORD command=reset ? 0 : 1; DWORD read=0; if (!WriteFile(pipe,&command,sizeof(DWORD),&read,NULL)) { pipe=NULL; return false; } FlushFileBuffers(pipe); DWORD size=0; if (!ReadFile(pipe,&size,sizeof(DWORD),&read,NULL)) { pipe=NULL; return false; } if (size==0) return false; if (!ReadFile(pipe,ATR,size,&read,NULL)) { pipe=NULL; return false; } (*ATRsize)=size; return true; }
bool FlushPlatformFile(PlatformFile file) { ThreadRestrictions::AssertIOAllowed(); return ((file!=kInvalidPlatformFileValue) && FlushFileBuffers(file)); }
int main(int argc, char* argv[]) { BOOL dwResult; DWORD dwRead; DWORD dwWrite; CHAR chBuf[BUFSIZE]; HANDLE inputFile; HANDLE outputFile; BOOL firstRead = TRUE; char* pathVar = argv[1]; char* inFilename = argv[2]; char* outFilename = argv[3]; inputFile = CreateFileA( inFilename, GENERIC_READ, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (inputFile == INVALID_HANDLE_VALUE) { PrintErrorMsg("CreateFile"); return -1; } outputFile = CreateFileA( outFilename, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (outputFile == INVALID_HANDLE_VALUE) { PrintErrorMsg("CreateFile"); return -1; } while (true) { dwResult = ReadFile(inputFile, chBuf, BUFSIZE, &dwRead, NULL); if (!dwResult || dwRead == 0) { break; } if (firstRead) { WriteFile(outputFile, pathVar, (DWORD)strlen(pathVar), &dwWrite, NULL); firstRead = FALSE; } for (size_t i = 0; i < dwRead; i++) { if (chBuf[i] == '/') { chBuf[i] = '\\'; } } WriteFile(outputFile, chBuf, dwRead, &dwWrite, NULL); } FlushFileBuffers(outputFile); CloseHandle(outputFile); return 0; }
static NTSTATUS LogfInitializeExisting(PLOGFILE LogFile, BOOL Backup) { DWORD dwRead; DWORD dwRecordsNumber = 0; DWORD dwRecSize, dwRecSign, dwFilePointer; PDWORD pdwRecSize2; PEVENTLOGRECORD RecBuf; BOOL OvewrWrittenRecords = FALSE; DPRINT("Initializing LogFile %S\n",LogFile->LogName); if (SetFilePointer(LogFile->hFile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { DPRINT1("SetFilePointer failed! %d\n", GetLastError()); return STATUS_EVENTLOG_FILE_CORRUPT; } if (!ReadFile(LogFile->hFile, &LogFile->Header, sizeof(EVENTLOGHEADER), &dwRead, NULL)) { DPRINT1("ReadFile failed! %d\n", GetLastError()); return STATUS_EVENTLOG_FILE_CORRUPT; } if (dwRead != sizeof(EVENTLOGHEADER)) { DPRINT("EventLog: Invalid file %S.\n", LogFile->FileName); return STATUS_EVENTLOG_FILE_CORRUPT; } if (LogFile->Header.HeaderSize != sizeof(EVENTLOGHEADER) || LogFile->Header.EndHeaderSize != sizeof(EVENTLOGHEADER)) { DPRINT("EventLog: Invalid header size in %S.\n", LogFile->FileName); return STATUS_EVENTLOG_FILE_CORRUPT; } if (LogFile->Header.Signature != LOGFILE_SIGNATURE) { DPRINT("EventLog: Invalid signature %x in %S.\n", LogFile->Header.Signature, LogFile->FileName); return STATUS_EVENTLOG_FILE_CORRUPT; } if (LogFile->Header.EndOffset > GetFileSize(LogFile->hFile, NULL) + 1) { DPRINT("EventLog: Invalid eof offset %x in %S.\n", LogFile->Header.EndOffset, LogFile->FileName); return STATUS_EVENTLOG_FILE_CORRUPT; } /* Set the read location to the oldest record */ dwFilePointer = SetFilePointer(LogFile->hFile, LogFile->Header.StartOffset, NULL, FILE_BEGIN); if (dwFilePointer == INVALID_SET_FILE_POINTER) { DPRINT1("SetFilePointer failed! %d\n", GetLastError()); return STATUS_EVENTLOG_FILE_CORRUPT; } for (;;) { dwFilePointer = SetFilePointer(LogFile->hFile, 0, NULL, FILE_CURRENT); if (dwFilePointer == INVALID_SET_FILE_POINTER) { DPRINT1("SetFilePointer failed! %d\n", GetLastError()); return STATUS_EVENTLOG_FILE_CORRUPT; } /* If the EVENTLOGEOF info has been reached and the oldest record was not immediately after the Header */ if ((dwFilePointer == LogFile->Header.EndOffset) && (LogFile->Header.StartOffset != sizeof(EVENTLOGHEADER))) { OvewrWrittenRecords = TRUE; /* The file has records that overwrote old ones so read them */ dwFilePointer = SetFilePointer(LogFile->hFile, sizeof(EVENTLOGHEADER), NULL, FILE_BEGIN); } if (!ReadFile(LogFile->hFile, &dwRecSize, sizeof(dwRecSize), &dwRead, NULL)) { DPRINT1("ReadFile failed! %d\n", GetLastError()); return STATUS_EVENTLOG_FILE_CORRUPT; } if (dwRead != sizeof(dwRecSize)) break; if (!ReadFile(LogFile->hFile, &dwRecSign, sizeof(dwRecSign), &dwRead, NULL)) { DPRINT1("ReadFile() failed! %d\n", GetLastError()); return STATUS_EVENTLOG_FILE_CORRUPT; } if (dwRead != sizeof(dwRecSize)) break; if (dwRecSign != LOGFILE_SIGNATURE || dwRecSize + dwFilePointer > GetFileSize(LogFile->hFile, NULL) + 1 || dwRecSize < sizeof(EVENTLOGRECORD)) { break; } if (SetFilePointer(LogFile->hFile, -((LONG) sizeof(DWORD) * 2), NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER) { DPRINT1("SetFilePointer() failed! %d", GetLastError()); return STATUS_EVENTLOG_FILE_CORRUPT; } RecBuf = (PEVENTLOGRECORD) HeapAlloc(MyHeap, 0, dwRecSize); if (RecBuf == NULL) { DPRINT1("Can't allocate heap!\n"); return STATUS_NO_MEMORY; } if (!ReadFile(LogFile->hFile, RecBuf, dwRecSize, &dwRead, NULL)) { DPRINT1("ReadFile() failed! %d\n", GetLastError()); HeapFree(MyHeap, 0, RecBuf); return STATUS_EVENTLOG_FILE_CORRUPT; } if (dwRead != dwRecSize) { HeapFree(MyHeap, 0, RecBuf); break; } /* if OvewrWrittenRecords is TRUE and this record has already been read */ if ((OvewrWrittenRecords == TRUE) && (RecBuf->RecordNumber == LogFile->Header.OldestRecordNumber)) { HeapFree(MyHeap, 0, RecBuf); break; } pdwRecSize2 = (PDWORD) (((PBYTE) RecBuf) + dwRecSize - 4); if (*pdwRecSize2 != dwRecSize) { DPRINT1("Invalid RecordSizeEnd of record %d (%x) in %S\n", dwRecordsNumber, *pdwRecSize2, LogFile->LogName); HeapFree(MyHeap, 0, RecBuf); break; } dwRecordsNumber++; if (!LogfAddOffsetInformation(LogFile, RecBuf->RecordNumber, dwFilePointer)) { DPRINT1("LogfAddOffsetInformation() failed!\n"); HeapFree(MyHeap, 0, RecBuf); return STATUS_EVENTLOG_FILE_CORRUPT; } HeapFree(MyHeap, 0, RecBuf); } LogFile->Header.CurrentRecordNumber = dwRecordsNumber + LogFile->Header.OldestRecordNumber; if (LogFile->Header.CurrentRecordNumber == 0) LogFile->Header.CurrentRecordNumber = 1; if (!Backup) { if (SetFilePointer(LogFile->hFile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { DPRINT1("SetFilePointer() failed! %d\n", GetLastError()); return STATUS_EVENTLOG_FILE_CORRUPT; } if (!WriteFile(LogFile->hFile, &LogFile->Header, sizeof(EVENTLOGHEADER), &dwRead, NULL)) { DPRINT1("WriteFile failed! %d\n", GetLastError()); return STATUS_EVENTLOG_FILE_CORRUPT; } if (!FlushFileBuffers(LogFile->hFile)) { DPRINT1("FlushFileBuffers failed! %d\n", GetLastError()); return STATUS_EVENTLOG_FILE_CORRUPT; } } return STATUS_SUCCESS; }
BOOL LogfWriteData(PLOGFILE LogFile, DWORD BufSize, PBYTE Buffer) { DWORD dwWritten; DWORD dwRead; SYSTEMTIME st; EVENTLOGEOF EofRec; PEVENTLOGRECORD RecBuf; LARGE_INTEGER logFileSize; ULONG RecOffSet; ULONG WriteOffSet; if (!Buffer) return FALSE; GetSystemTime(&st); SystemTimeToEventTime(&st, &((PEVENTLOGRECORD) Buffer)->TimeWritten); RtlAcquireResourceExclusive(&LogFile->Lock, TRUE); if (!GetFileSizeEx(LogFile->hFile, &logFileSize)) { RtlReleaseResource(&LogFile->Lock); return FALSE; } /* If the size of the file is over MaxSize */ if ((logFileSize.QuadPart + BufSize)> LogFile->Header.MaxSize) { ULONG OverWriteLength = 0; WriteOffSet = LogfOffsetByNumber(LogFile, LogFile->Header.OldestRecordNumber); RecBuf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(EVENTLOGRECORD)); /* Determine how many records need to be overwritten */ while (TRUE) { DPRINT("EventLogFile has reached maximume size\n"); if (!RecBuf) { DPRINT1("Failed to allocate buffer for OldestRecord!\n"); HeapFree(GetProcessHeap(), 0, RecBuf); RtlReleaseResource(&LogFile->Lock); return FALSE; } /* Get the oldest record data */ RecOffSet = LogfOffsetByNumber(LogFile, LogFile->Header.OldestRecordNumber); if (SetFilePointer(LogFile->hFile, RecOffSet, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { DPRINT1("SetFilePointer() failed! %d\n", GetLastError()); HeapFree(GetProcessHeap(), 0, RecBuf); RtlReleaseResource(&LogFile->Lock); return FALSE; } if (!ReadFile(LogFile->hFile, RecBuf, sizeof(EVENTLOGRECORD), &dwRead, NULL)) { DPRINT1("ReadFile() failed!\n"); HeapFree(GetProcessHeap(), 0, RecBuf); RtlReleaseResource(&LogFile->Lock); return FALSE; } if (RecBuf->Reserved != LOGFILE_SIGNATURE) { DPRINT1("LogFile corrupt!\n"); HeapFree(GetProcessHeap(), 0, RecBuf); RtlReleaseResource(&LogFile->Lock); return FALSE; } LogfDeleteOffsetInformation(LogFile,LogFile->Header.OldestRecordNumber); LogFile->Header.OldestRecordNumber++; OverWriteLength += RecBuf->Length; /* Check the size of the record as the record adding may be larger */ if (OverWriteLength >= BufSize) { DPRINT("Record will fit. Length %d, BufSize %d\n", OverWriteLength, BufSize); LogFile->Header.StartOffset = LogfOffsetByNumber(LogFile, LogFile->Header.OldestRecordNumber); break; } } HeapFree(GetProcessHeap(), 0, RecBuf); } else WriteOffSet = LogFile->Header.EndOffset; if (SetFilePointer(LogFile->hFile, WriteOffSet, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { DPRINT1("SetFilePointer() failed! %d\n", GetLastError()); RtlReleaseResource(&LogFile->Lock); return FALSE; } if (!WriteFile(LogFile->hFile, Buffer, BufSize, &dwWritten, NULL)) { DPRINT1("WriteFile() failed! %d\n", GetLastError()); RtlReleaseResource(&LogFile->Lock); return FALSE; } if (!LogfAddOffsetInformation(LogFile, LogFile->Header.CurrentRecordNumber, WriteOffSet)) { RtlReleaseResource(&LogFile->Lock); return FALSE; } LogFile->Header.CurrentRecordNumber++; if (WriteOffSet == LogFile->Header.EndOffset) { LogFile->Header.EndOffset += dwWritten; } if (SetFilePointer(LogFile->hFile, LogFile->Header.EndOffset, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { DPRINT1("SetFilePointer() failed! %d\n", GetLastError()); RtlReleaseResource(&LogFile->Lock); return FALSE; } EofRec.Ones = 0x11111111; EofRec.Twos = 0x22222222; EofRec.Threes = 0x33333333; EofRec.Fours = 0x44444444; EofRec.RecordSizeBeginning = sizeof(EVENTLOGEOF); EofRec.RecordSizeEnd = sizeof(EVENTLOGEOF); EofRec.CurrentRecordNumber = LogFile->Header.CurrentRecordNumber; EofRec.OldestRecordNumber = LogFile->Header.OldestRecordNumber; EofRec.BeginRecord = LogFile->Header.StartOffset; EofRec.EndRecord = LogFile->Header.EndOffset; if (!WriteFile(LogFile->hFile, &EofRec, sizeof(EVENTLOGEOF), &dwWritten, NULL)) { DPRINT1("WriteFile() failed! %d\n", GetLastError()); RtlReleaseResource(&LogFile->Lock); return FALSE; } if (SetFilePointer(LogFile->hFile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { DPRINT1("SetFilePointer() failed! %d\n", GetLastError()); RtlReleaseResource(&LogFile->Lock); return FALSE; } if (!WriteFile(LogFile->hFile, &LogFile->Header, sizeof(EVENTLOGHEADER), &dwWritten, NULL)) { DPRINT1("WriteFile failed! LastError = %d\n", GetLastError()); RtlReleaseResource(&LogFile->Lock); return FALSE; } if (!FlushFileBuffers(LogFile->hFile)) { DPRINT1("FlushFileBuffers() failed! %d\n", GetLastError()); RtlReleaseResource(&LogFile->Lock); return FALSE; } RtlReleaseResource(&LogFile->Lock); return TRUE; }
int TCFormatVolume (volatile FORMAT_VOL_PARAMETERS *volParams) { int nStatus; PCRYPTO_INFO cryptoInfo = NULL; HANDLE dev = INVALID_HANDLE_VALUE; DWORD dwError; char header[TC_VOLUME_HEADER_EFFECTIVE_SIZE]; unsigned __int64 num_sectors, startSector; fatparams ft; FILETIME ftCreationTime; FILETIME ftLastWriteTime; FILETIME ftLastAccessTime; BOOL bTimeStampValid = FALSE; BOOL bInstantRetryOtherFilesys = FALSE; char dosDev[TC_MAX_PATH] = { 0 }; char devName[MAX_PATH] = { 0 }; int driveLetter = -1; WCHAR deviceName[MAX_PATH]; uint64 dataOffset, dataAreaSize; LARGE_INTEGER offset; BOOL bFailedRequiredDASD = FALSE; HWND hwndDlg = volParams->hwndDlg; FormatSectorSize = volParams->sectorSize; if (FormatSectorSize < TC_MIN_VOLUME_SECTOR_SIZE || FormatSectorSize > TC_MAX_VOLUME_SECTOR_SIZE || FormatSectorSize % ENCRYPTION_DATA_UNIT_SIZE != 0) { Error ("SECTOR_SIZE_UNSUPPORTED", hwndDlg); return ERR_DONT_REPORT; } /* WARNING: Note that if Windows fails to format the volume as NTFS and the volume size is less than the maximum FAT size, the user is asked within this function whether he wants to instantly retry FAT format instead (to avoid having to re-create the whole container again). If the user answers yes, some of the input parameters are modified, the code below 'begin_format' is re-executed and some destructive operations that were performed during the first attempt must be (and are) skipped. Therefore, whenever adding or modifying any potentially destructive operations below 'begin_format', determine whether they (or their portions) need to be skipped during such a second attempt; if so, use the 'bInstantRetryOtherFilesys' flag to skip them. */ if (volParams->hiddenVol) { dataOffset = volParams->hiddenVolHostSize - TC_VOLUME_HEADER_GROUP_SIZE - volParams->size; } else { if (volParams->size <= TC_TOTAL_VOLUME_HEADERS_SIZE) return ERR_VOL_SIZE_WRONG; dataOffset = TC_VOLUME_DATA_OFFSET; } dataAreaSize = GetVolumeDataAreaSize (volParams->hiddenVol, volParams->size); num_sectors = dataAreaSize / FormatSectorSize; if (volParams->bDevice) { StringCbCopyA ((char *)deviceName, sizeof(deviceName), volParams->volumePath); ToUNICODE ((char *)deviceName, sizeof(deviceName)); driveLetter = GetDiskDeviceDriveLetter (deviceName); } VirtualLock (header, sizeof (header)); nStatus = CreateVolumeHeaderInMemory (hwndDlg, FALSE, header, volParams->ea, FIRST_MODE_OF_OPERATION_ID, volParams->password, volParams->pkcs5, volParams->pim, NULL, &cryptoInfo, dataAreaSize, volParams->hiddenVol ? dataAreaSize : 0, dataOffset, dataAreaSize, 0, volParams->headerFlags, FormatSectorSize, FALSE); if (nStatus != 0) { burn (header, sizeof (header)); VirtualUnlock (header, sizeof (header)); return nStatus; } begin_format: if (volParams->bDevice) { /* Device-hosted volume */ DWORD dwResult; int nPass; if (FakeDosNameForDevice (volParams->volumePath, dosDev, sizeof(dosDev), devName, sizeof(devName), FALSE) != 0) return ERR_OS_ERROR; if (IsDeviceMounted (devName)) { if ((dev = DismountDrive (devName, volParams->volumePath)) == INVALID_HANDLE_VALUE) { Error ("FORMAT_CANT_DISMOUNT_FILESYS", hwndDlg); nStatus = ERR_DONT_REPORT; goto error; } /* Gain "raw" access to the partition (it contains a live filesystem and the filesystem driver would otherwise prevent us from writing to hidden sectors). */ if (!DeviceIoControl (dev, FSCTL_ALLOW_EXTENDED_DASD_IO, NULL, 0, NULL, 0, &dwResult, NULL)) { bFailedRequiredDASD = TRUE; } } else if (IsOSAtLeast (WIN_VISTA) && driveLetter == -1) { // Windows Vista doesn't allow overwriting sectors belonging to an unformatted partition // to which no drive letter has been assigned under the system. This problem can be worked // around by assigning a drive letter to the partition temporarily. char szDriveLetter[] = { 'A', ':', 0 }; char rootPath[] = { 'A', ':', '\\', 0 }; char uniqVolName[MAX_PATH+1] = { 0 }; int tmpDriveLetter = -1; BOOL bResult = FALSE; tmpDriveLetter = GetFirstAvailableDrive (); if (tmpDriveLetter != -1) { rootPath[0] += (char) tmpDriveLetter; szDriveLetter[0] += (char) tmpDriveLetter; if (DefineDosDevice (DDD_RAW_TARGET_PATH, szDriveLetter, volParams->volumePath)) { bResult = GetVolumeNameForVolumeMountPoint (rootPath, uniqVolName, MAX_PATH); DefineDosDevice (DDD_RAW_TARGET_PATH|DDD_REMOVE_DEFINITION|DDD_EXACT_MATCH_ON_REMOVE, szDriveLetter, volParams->volumePath); if (bResult && SetVolumeMountPoint (rootPath, uniqVolName)) { // The drive letter can be removed now DeleteVolumeMountPoint (rootPath); } } } } // For extra safety, we will try to gain "raw" access to the partition. Note that this should actually be // redundant because if the filesystem was mounted, we already tried to obtain DASD above. If we failed, // bFailedRequiredDASD was set to TRUE and therefore we will perform pseudo "quick format" below. However, // for extra safety, in case IsDeviceMounted() failed to detect a live filesystem, we will blindly // send FSCTL_ALLOW_EXTENDED_DASD_IO (possibly for a second time) without checking the result. DeviceIoControl (dev, FSCTL_ALLOW_EXTENDED_DASD_IO, NULL, 0, NULL, 0, &dwResult, NULL); // If DASD is needed but we failed to obtain it, perform open - 'quick format' - close - open // so that the filesystem driver does not prevent us from formatting hidden sectors. for (nPass = (bFailedRequiredDASD ? 0 : 1); nPass < 2; nPass++) { int retryCount; retryCount = 0; // Try exclusive access mode first // Note that when exclusive access is denied, it is worth retrying (usually succeeds after a few tries). while (dev == INVALID_HANDLE_VALUE && retryCount++ < EXCL_ACCESS_MAX_AUTO_RETRIES) { dev = CreateFile (devName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); if (retryCount > 1) Sleep (EXCL_ACCESS_AUTO_RETRY_DELAY); } if (dev == INVALID_HANDLE_VALUE) { // Exclusive access denied -- retry in shared mode dev = CreateFile (devName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); if (dev != INVALID_HANDLE_VALUE) { if (!volParams->bForceOperation && (Silent || (IDNO == MessageBoxW (volParams->hwndDlg, GetString ("DEVICE_IN_USE_FORMAT"), lpszTitle, MB_YESNO|MB_ICONWARNING|MB_DEFBUTTON2)))) { nStatus = ERR_DONT_REPORT; goto error; } } else { handleWin32Error (volParams->hwndDlg, SRC_POS); Error ("CANT_ACCESS_VOL", hwndDlg); nStatus = ERR_DONT_REPORT; goto error; } } if (volParams->hiddenVol || bInstantRetryOtherFilesys) break; // The following "quick format" operation would damage the outer volume if (nPass == 0) { char buf [2 * TC_MAX_VOLUME_SECTOR_SIZE]; DWORD bw; // Perform pseudo "quick format" so that the filesystem driver does not prevent us from // formatting hidden sectors memset (buf, 0, sizeof (buf)); if (!WriteFile (dev, buf, sizeof (buf), &bw, NULL)) { nStatus = ERR_OS_ERROR; goto error; } FlushFileBuffers (dev); CloseHandle (dev); dev = INVALID_HANDLE_VALUE; } } if (DeviceIoControl (dev, FSCTL_IS_VOLUME_MOUNTED, NULL, 0, NULL, 0, &dwResult, NULL)) { Error ("FORMAT_CANT_DISMOUNT_FILESYS", hwndDlg); nStatus = ERR_DONT_REPORT; goto error; } } else { /* File-hosted volume */ dev = CreateFile (volParams->volumePath, GENERIC_READ | GENERIC_WRITE, (volParams->hiddenVol || bInstantRetryOtherFilesys) ? (FILE_SHARE_READ | FILE_SHARE_WRITE) : 0, NULL, (volParams->hiddenVol || bInstantRetryOtherFilesys) ? OPEN_EXISTING : CREATE_ALWAYS, 0, NULL); if (dev == INVALID_HANDLE_VALUE) { nStatus = ERR_OS_ERROR; goto error; } DisableFileCompression (dev); if (!volParams->hiddenVol && !bInstantRetryOtherFilesys) { LARGE_INTEGER volumeSize; volumeSize.QuadPart = dataAreaSize + TC_VOLUME_HEADER_GROUP_SIZE; if (volParams->sparseFileSwitch && volParams->quickFormat) { // Create as sparse file container DWORD tmp; if (!DeviceIoControl (dev, FSCTL_SET_SPARSE, NULL, 0, NULL, 0, &tmp, NULL)) { nStatus = ERR_OS_ERROR; goto error; } } // Preallocate the file if (!SetFilePointerEx (dev, volumeSize, NULL, FILE_BEGIN) || !SetEndOfFile (dev) || SetFilePointer (dev, 0, NULL, FILE_BEGIN) != 0) { nStatus = ERR_OS_ERROR; goto error; } } } if (volParams->hiddenVol && !volParams->bDevice && bPreserveTimestamp) { if (GetFileTime ((HANDLE) dev, &ftCreationTime, &ftLastAccessTime, &ftLastWriteTime) == 0) bTimeStampValid = FALSE; else bTimeStampValid = TRUE; } if (volParams->hwndDlg && volParams->bGuiMode) KillTimer (volParams->hwndDlg, TIMER_ID_RANDVIEW); /* Volume header */ // Hidden volume setup if (volParams->hiddenVol) { LARGE_INTEGER headerOffset; // Check hidden volume size if (volParams->hiddenVolHostSize < TC_MIN_HIDDEN_VOLUME_HOST_SIZE || volParams->hiddenVolHostSize > TC_MAX_HIDDEN_VOLUME_HOST_SIZE) { nStatus = ERR_VOL_SIZE_WRONG; goto error; } // Seek to hidden volume header location headerOffset.QuadPart = TC_HIDDEN_VOLUME_HEADER_OFFSET; if (!SetFilePointerEx ((HANDLE) dev, headerOffset, NULL, FILE_BEGIN)) { nStatus = ERR_OS_ERROR; goto error; } } else if (bInstantRetryOtherFilesys) { // The previous file system format failed and the user wants to try again with a different file system. // The volume header had been written successfully so we need to seek to the byte after the header. LARGE_INTEGER offset; offset.QuadPart = TC_VOLUME_DATA_OFFSET; if (!SetFilePointerEx ((HANDLE) dev, offset, NULL, FILE_BEGIN)) { nStatus = ERR_OS_ERROR; goto error; } } if (!bInstantRetryOtherFilesys) { // Write the volume header if (!WriteEffectiveVolumeHeader (volParams->bDevice, dev, header)) { nStatus = ERR_OS_ERROR; goto error; } // To prevent fragmentation, write zeroes to reserved header sectors which are going to be filled with random data if (!volParams->bDevice && !volParams->hiddenVol) { byte buf[TC_VOLUME_HEADER_GROUP_SIZE - TC_VOLUME_HEADER_EFFECTIVE_SIZE]; DWORD bytesWritten; ZeroMemory (buf, sizeof (buf)); if (!WriteFile (dev, buf, sizeof (buf), &bytesWritten, NULL)) { nStatus = ERR_OS_ERROR; goto error; } if (bytesWritten != sizeof (buf)) { nStatus = ERR_PARAMETER_INCORRECT; goto error; } } } if (volParams->hiddenVol) { // Calculate data area position of hidden volume cryptoInfo->hiddenVolumeOffset = dataOffset; // Validate the offset if (dataOffset % FormatSectorSize != 0) { nStatus = ERR_VOL_SIZE_WRONG; goto error; } volParams->quickFormat = TRUE; // To entirely format a hidden volume would be redundant } /* Data area */ startSector = dataOffset / FormatSectorSize; // Format filesystem switch (volParams->fileSystem) { case FILESYS_NONE: case FILESYS_NTFS: if (volParams->bDevice && !StartFormatWriteThread()) { nStatus = ERR_OS_ERROR; goto error; } nStatus = FormatNoFs (hwndDlg, startSector, num_sectors, dev, cryptoInfo, volParams->quickFormat); if (volParams->bDevice) StopFormatWriteThread(); break; case FILESYS_FAT: if (num_sectors > 0xFFFFffff) { nStatus = ERR_VOL_SIZE_WRONG; goto error; } // Calculate the fats, root dir etc ft.num_sectors = (unsigned int) (num_sectors); #if TC_MAX_VOLUME_SECTOR_SIZE > 0xFFFF #error TC_MAX_VOLUME_SECTOR_SIZE > 0xFFFF #endif ft.sector_size = (uint16) FormatSectorSize; ft.cluster_size = volParams->clusterSize; memcpy (ft.volume_name, "NO NAME ", 11); GetFatParams (&ft); *(volParams->realClusterSize) = ft.cluster_size * FormatSectorSize; if (volParams->bDevice && !StartFormatWriteThread()) { nStatus = ERR_OS_ERROR; goto error; } nStatus = FormatFat (hwndDlg, startSector, &ft, (void *) dev, cryptoInfo, volParams->quickFormat); if (volParams->bDevice) StopFormatWriteThread(); break; default: nStatus = ERR_PARAMETER_INCORRECT; goto error; } if (nStatus != ERR_SUCCESS) goto error; // Write header backup offset.QuadPart = volParams->hiddenVol ? volParams->hiddenVolHostSize - TC_HIDDEN_VOLUME_HEADER_OFFSET : dataAreaSize + TC_VOLUME_HEADER_GROUP_SIZE; if (!SetFilePointerEx ((HANDLE) dev, offset, NULL, FILE_BEGIN)) { nStatus = ERR_OS_ERROR; goto error; } nStatus = CreateVolumeHeaderInMemory (hwndDlg, FALSE, header, volParams->ea, FIRST_MODE_OF_OPERATION_ID, volParams->password, volParams->pkcs5, volParams->pim, cryptoInfo->master_keydata, &cryptoInfo, dataAreaSize, volParams->hiddenVol ? dataAreaSize : 0, dataOffset, dataAreaSize, 0, volParams->headerFlags, FormatSectorSize, FALSE); if (!WriteEffectiveVolumeHeader (volParams->bDevice, dev, header)) { nStatus = ERR_OS_ERROR; goto error; } // Fill reserved header sectors (including the backup header area) with random data if (!volParams->hiddenVol) { nStatus = WriteRandomDataToReservedHeaderAreas (hwndDlg, dev, cryptoInfo, dataAreaSize, FALSE, FALSE); if (nStatus != ERR_SUCCESS) goto error; } #ifndef DEBUG if (volParams->quickFormat && volParams->fileSystem != FILESYS_NTFS) Sleep (500); // User-friendly GUI #endif error: dwError = GetLastError(); burn (header, sizeof (header)); VirtualUnlock (header, sizeof (header)); if (dev != INVALID_HANDLE_VALUE) { if (!volParams->bDevice && !volParams->hiddenVol && nStatus != 0) { // Remove preallocated part before closing file handle if format failed if (SetFilePointer (dev, 0, NULL, FILE_BEGIN) == 0) SetEndOfFile (dev); } FlushFileBuffers (dev); if (bTimeStampValid) SetFileTime (dev, &ftCreationTime, &ftLastAccessTime, &ftLastWriteTime); CloseHandle (dev); dev = INVALID_HANDLE_VALUE; } if (nStatus != 0) { SetLastError(dwError); goto fv_end; } if (volParams->fileSystem == FILESYS_NTFS) { // Quick-format volume as NTFS int driveNo = GetLastAvailableDrive (); MountOptions mountOptions; int retCode; ZeroMemory (&mountOptions, sizeof (mountOptions)); if (driveNo == -1) { if (!Silent) { MessageBoxW (volParams->hwndDlg, GetString ("NO_FREE_DRIVES"), lpszTitle, ICON_HAND); MessageBoxW (volParams->hwndDlg, GetString ("FORMAT_NTFS_STOP"), lpszTitle, ICON_HAND); } nStatus = ERR_NO_FREE_DRIVES; goto fv_end; } mountOptions.ReadOnly = FALSE; mountOptions.Removable = FALSE; mountOptions.ProtectHiddenVolume = FALSE; mountOptions.PreserveTimestamp = bPreserveTimestamp; mountOptions.PartitionInInactiveSysEncScope = FALSE; mountOptions.UseBackupHeader = FALSE; if (MountVolume (volParams->hwndDlg, driveNo, volParams->volumePath, volParams->password, volParams->pkcs5, volParams->pim, FALSE, FALSE, TRUE, &mountOptions, FALSE, TRUE) < 1) { if (!Silent) { MessageBoxW (volParams->hwndDlg, GetString ("CANT_MOUNT_VOLUME"), lpszTitle, ICON_HAND); MessageBoxW (volParams->hwndDlg, GetString ("FORMAT_NTFS_STOP"), lpszTitle, ICON_HAND); } nStatus = ERR_VOL_MOUNT_FAILED; goto fv_end; } if (!Silent && !IsAdmin () && IsUacSupported ()) retCode = UacFormatNtfs (volParams->hwndDlg, driveNo, volParams->clusterSize); else retCode = FormatNtfs (driveNo, volParams->clusterSize); if (retCode != TRUE) { if (!UnmountVolumeAfterFormatExCall (volParams->hwndDlg, driveNo) && !Silent) MessageBoxW (volParams->hwndDlg, GetString ("CANT_DISMOUNT_VOLUME"), lpszTitle, ICON_HAND); if (dataAreaSize <= TC_MAX_FAT_SECTOR_COUNT * FormatSectorSize) { if (AskErrYesNo ("FORMAT_NTFS_FAILED_ASK_FAT", hwndDlg) == IDYES) { // NTFS format failed and the user wants to try FAT format immediately volParams->fileSystem = FILESYS_FAT; bInstantRetryOtherFilesys = TRUE; volParams->quickFormat = TRUE; // Volume has already been successfully TC-formatted volParams->clusterSize = 0; // Default cluster size goto begin_format; } } else Error ("FORMAT_NTFS_FAILED", hwndDlg); nStatus = ERR_DONT_REPORT; goto fv_end; } if (!UnmountVolumeAfterFormatExCall (volParams->hwndDlg, driveNo) && !Silent) MessageBoxW (volParams->hwndDlg, GetString ("CANT_DISMOUNT_VOLUME"), lpszTitle, ICON_HAND); } fv_end: dwError = GetLastError(); if (dosDev[0]) RemoveFakeDosName (volParams->volumePath, dosDev); crypto_close (cryptoInfo); SetLastError (dwError); return nStatus; }
void OsFile::flush() { ASSERT(nullptr != m_impl); FlushFileBuffers(m_impl->m_file); }
/******************************************************************************* ** Author: Bill Theisen ** Purpose: Opens the serial port. ** Comments: ** Parameter(s): PortNumber - serial port number e.g. 1... 4 ** maxMsgLength - maximum message length ** m_irisNode - pointer to class method called when packet is ** received. Method prototype is: ** Func( char * pPacketBuffer, unsigned long Length ); ** Baudrate - pseudo standard set baudrates, e.g. 300, 1200, ** 2400, 4800, 9600, 19200, 38400, 57600, 115200 ** ** Return type: boolean - TRUE(1) if successful, FALSE(0) otherwise *******************************************************************************/ bool DOIrisSerialPort::OpenPort( unsigned int PortNumber, int maxMsgLength, IRIS_NodeInterface *irisNode, unsigned long Baudrate, bool /* threadSafe */) { DCB PortDCB; this->m_irisNode = irisNode; m_bStopReadThread = FALSE; TCHAR szDeviceName[50]; _stprintf(szDeviceName, _T("COM%d:"), PortNumber); #if defined(_WIN32_WCE) // Open the COM device. if( INVALID_HANDLE_VALUE == (m_hPort = CreateFile( (szDeviceName), GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0) ) ) { #else if( INVALID_HANDLE_VALUE == (m_hPort = CreateFile( (szDeviceName), GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0) ) ) { #endif //m_pRnDLog->LogRnDEvent( IDS_IRISCOMMON_CREATEFILE_FAILED,static_cast<int>(GetLastError()) ); return FALSE; } //delete [] szDeviceName; // Set the port. PortDCB.DCBlength = sizeof(DCB); GetCommState(m_hPort, &PortDCB); PortDCB.BaudRate = Baudrate; PortDCB.fBinary = TRUE; PortDCB.fParity = TRUE; PortDCB.fOutxCtsFlow = FALSE; // ignore possible hangups PortDCB.fOutxDsrFlow = FALSE; // don't wait on the DSR line PortDCB.fDtrControl = DTR_CONTROL_ENABLE; PortDCB.fDsrSensitivity = FALSE; PortDCB.fTXContinueOnXoff = TRUE; PortDCB.fOutX = FALSE; // no XON/XOFF control PortDCB.fInX = FALSE; PortDCB.fErrorChar = FALSE; PortDCB.fNull = FALSE; PortDCB.fRtsControl = RTS_CONTROL_ENABLE; PortDCB.fAbortOnError = FALSE; PortDCB.ByteSize = 8; PortDCB.Parity = NOPARITY; PortDCB.StopBits = ONESTOPBIT; PortDCB.EvtChar = IRIS_PACKET_END_FLAG; if( !SetCommState( m_hPort, &PortDCB ) ) { //m_pRnDLog->LogRnDEvent( IDS_IRISCOMMON_SETCOMMSTATE_FAILED, static_cast<int>(GetLastError()) ); return FALSE; } // Set comm timeouts (nonblocking read, and write waiting for completion). COMMTIMEOUTS CommTimeouts; GetCommTimeouts( m_hPort, &CommTimeouts ); CommTimeouts.ReadIntervalTimeout = MAXDWORD; CommTimeouts.ReadTotalTimeoutMultiplier = 0; CommTimeouts.ReadTotalTimeoutConstant = 0; CommTimeouts.WriteTotalTimeoutMultiplier = 0; CommTimeouts.WriteTotalTimeoutConstant = 0; SetCommTimeouts(m_hPort, &CommTimeouts); m_iInBufferLength = static_cast<unsigned long>(maxMsgLength * IN_BUFFER_MULT); m_iPacketBufferLength = static_cast<unsigned long>(maxMsgLength * PKT_BUFFER_MULT); // Create and start the receiver thread. unsigned long threadID; /* DOThread receiveThread( THREAD_NAME_BASE_IRISRECEIVE, ReadThread, this, DOThread::DO_THREAD_RUN, &threadID ); */ // _beginthread( ReadThread, 0, NULL ); HANDLE hthread = CreateThread(0, 0, ReadThread, (LPVOID)this, 0, 0); m_bReadThreadIsRunning = TRUE; return TRUE; } /******************************************************************************* ** Author: Bill Theisen ** Purpose: Writes the specified byte stream to the serial port. ** Comments: ** Parameter(s): pPacketBuffer - pointer to char buffer contianing packet ** Length - number of chars in packet being written ** ** Return type: None ** *******************************************************************************/ void DOIrisSerialPort::WritePort(char * pPacketBuffer, unsigned long Length) { unsigned long nBytesWritten; //m_critSecWritePort.Lock(); #if defined(_WIN32_WCE) WriteFile( m_hPort, pPacketBuffer, Length, &nBytesWritten, 0 ); #else WriteFile(m_hPort, pPacketBuffer, Length, &nBytesWritten, &m_overlapped); #endif FlushFileBuffers(m_hPort); //m_critSecWritePort.Unlock(); GenSentBytes = GenSentBytes + Length; }
/** Truncates the current log file content so when adding some new text the * file size won't exceed the maximum size specified in init(). * \param[in] iAdd - size of the new string to be added to the log file * \return True if truncate succeeded or false if not. */ bool log_file::truncate(int_t iAdd) const { assert(m_pszPath); if(!m_pszPath) return false; // if we doesn't need to truncate anything if (m_iMaxSize <= 0) return true; // make some checks int_t iSize=size(); if (iSize <= 0 || iSize+iAdd < m_iMaxSize) return false; // establish the new file size (1/3rd of the current size or max_size-add_size) int_t iNewSize=minval((int_t)(iSize*0.66), m_iMaxSize-iAdd) & ~1; #ifdef _WIN32 // win32 does not have the ftruncate function, so we have to make some API calls HANDLE hFile=CreateFile(m_pszPath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile != INVALID_HANDLE_VALUE) { // seek if (SetFilePointer(hFile, iSize-iNewSize, NULL, FILE_BEGIN) != INVALID_SET_FILE_POINTER) { // read the string to the eol DWORD dwRD; tchar_t szBuffer[4096/sizeof(tchar_t)]; if (ReadFile(hFile, szBuffer, 4096, &dwRD, NULL)) { dwRD/=sizeof(tchar_t); szBuffer[(dwRD > 0) ? dwRD-1 : 0]=_t('\0'); // replace the /r and /n in the log to the \0 for (DWORD i=0;i<dwRD;i++) { if (szBuffer[i] == _t('\r') || szBuffer[i] == _t('\n')) { szBuffer[i]=_t('\0'); break; } } iNewSize-=(int_t)(_tcslen(szBuffer)+1)*sizeof(tchar_t); // new size correction if (SetFilePointer(hFile, iSize-iNewSize, NULL, FILE_BEGIN) != INVALID_SET_FILE_POINTER) { long_t lSrc=(long_t)SetFilePointer(hFile, 0, NULL, FILE_CURRENT); long_t lDst=0; DWORD tRD, tWR; do { // seek to src SetFilePointer(hFile, lSrc, NULL, FILE_BEGIN); // read 4k chars from source offset if (ReadFile(hFile, szBuffer, 4096, &tRD, NULL)) { // seek to the dst SetFilePointer(hFile, lDst, NULL, FILE_BEGIN); FlushFileBuffers(hFile); // write the buffer to the dest offset WriteFile(hFile, szBuffer, tRD, &tWR, NULL); lDst+=(long_t)tWR; } lSrc+=(long_t)tRD; } while(tRD != 0); // now truncate the file to the needed size SetEndOfFile(hFile); } } CloseHandle(hFile); return true; } } #else FILE* pFile=fopen(m_pszPath, _t("r+")); if (pFile) { // seek if (fseek(pFile, iSize-iNewSize, SEEK_SET) == 0) { // read the string to the eol tchar_t szBuffer[4096]; fgets(szBuffer, 4096, pFile); iNewSize-=_tcslen(szBuffer); // new size correction int_t iSrc=ftell(pFile); int_t iDst=0; size_t tRD, tWR; do { // seek to src fseek(pFile, iSrc, SEEK_SET); // read 4k chars from source offset tRD=fread(szBuffer, 1, 4096, pFile); if (tRD > 0) { // seek to the dst fseek(pFile, iDst, SEEK_SET); fflush(pFile); // write the buffer to the dest offset tWR=fwrite(szBuffer, 1, tRD, pFile); iDst+=tWR; } iSrc+=tRD; } while(tRD != 0); // now truncate the file to the needed size ftruncate(fileno(pFile), iDst); fclose(pFile); return true; } fclose(pFile); } #endif return false; }
static void worker_fsync(struct job_fsync *job) { if (!FlushFileBuffers(job->handle)) job->error_code = GetLastError(); }
long EdFail_CrashHandler (struct _EXCEPTION_POINTERS *pmExceptionInfo) { static int stInCrashHandler = 0; static FilePath stMyPanicLogName, stMyAltPanicLogName; static HANDLE stMyPanicFile; static DWORD stMyNumBytesWritten; static int stMyFileOpenStatus; static int stMyFileOpenError; stCrashing = TRUE; if (stCrashBuffer == NULL) { return EXCEPTION_EXECUTE_HANDLER; } if (stInCrashHandler > 1) { return EXCEPTION_EXECUTE_HANDLER; } stInCrashHandler++; if (stInCrashHandler == 2) { MyAddToBuffer ("\r\nCrashed in Crash Handler!\r\n"); } else { // Get file name strcpy (stMyPanicLogName, EdProp_GetStartupDirectory ()); MyLoadString (IDS_PANIC_LOG_FILE, &stMyPanicLogName [strlen (stMyPanicLogName)], sizeof (stMyPanicLogName), PANIC_LOG_FILE_REPL); // Try opening the file. stMyPanicFile = CreateFile (stMyPanicLogName, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); // If opening the file failed, then try current directory instead. if (stMyPanicFile != (HANDLE) INVALID_HANDLE_VALUE) { // File opened successfully. Now close it stMyFileOpenStatus = OPEN_SUCCESS; CloseHandle (stMyPanicFile); } else { stMyFileOpenError = GetLastError (); // If the opening failed, try using the current directory. EdFile_GetCurrentDirectory (stMyAltPanicLogName); if (strcmp (stMyAltPanicLogName, EdProp_GetStartupDirectory ()) == 0) { stMyFileOpenStatus = OPEN_FAIL_CURRENT_IS_STARTUP; } else { MyLoadString (IDS_PANIC_LOG_FILE, &stMyAltPanicLogName [strlen (stMyAltPanicLogName)], sizeof (stMyAltPanicLogName), PANIC_LOG_FILE_REPL); // Try opening the file. stMyPanicFile = CreateFile (stMyAltPanicLogName, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (stMyPanicFile != (HANDLE) INVALID_HANDLE_VALUE) { // File opened successfully. Now close it stMyFileOpenStatus = OPEN_SUCCESS; CloseHandle (stMyPanicFile); strcpy (stMyPanicLogName, stMyAltPanicLogName); } else { stMyFileOpenError = GetLastError (); stMyFileOpenStatus = OPEN_FAIL_BOTH_FAILED; } } } // // Display the crash dialog box // stCrashBufferPtr = stCrashBuffer; stCrashBufferLeft = CRASH_BUFFER_SIZE - 10; // Get the window title (e.g. "Turing Internal Error") MyLoadString (IDS_FATALWINDOWTITLE, stWindowTitle, sizeof (stWindowTitle), WINDOW_TITLE_REPL); // Get the preamble (e.g. "An unexpected error... Please record...") MyLoadString (IDS_CRASHPREAMBLE1, stCrashBufferPtr, stCrashBufferLeft, CRASH_PREAMBLE_REPL1); stCrashBufferLeft -= strlen (stCrashBufferPtr); stCrashBufferPtr += strlen (stCrashBufferPtr); MyAddToBuffer (stMyPanicLogName); MyLoadString (IDS_CRASHPREAMBLE2, stCrashBufferPtr, stCrashBufferLeft, CRASH_PREAMBLE_REPL2); stCrashBufferLeft -= strlen (stCrashBufferPtr); stCrashBufferPtr += strlen (stCrashBufferPtr); // Add the reason for the crash MyAddToBuffer ("Cause of Crash: "); EdCrash_GetExceptionName (stCrashBufferPtr, pmExceptionInfo -> ExceptionRecord -> ExceptionCode); stCrashBufferLeft -= strlen (stCrashBufferPtr); stCrashBufferPtr += strlen (stCrashBufferPtr); MyAddToBuffer ("\r\n\r\n"); // Add the register dump EdCrash_RegisterDump (stCrashBufferPtr, pmExceptionInfo -> ContextRecord); stCrashBufferLeft -= strlen (stCrashBufferPtr); stCrashBufferPtr += strlen (stCrashBufferPtr); MyAddToBuffer ("\r\n"); // Add the saving files message MyLoadString (IDS_FAILSAVEFILE, stCrashBufferPtr, stCrashBufferLeft, FAIL_SAVE_FILE_REPL); stCrashBufferLeft -= strlen (stCrashBufferPtr); stCrashBufferPtr += strlen (stCrashBufferPtr); // Display the error message MessageBox (NULL, stCrashBuffer, stWindowTitle, MB_OK | MB_ICONERROR | MB_TASKMODAL); // // Write to panic.log // stCrashBufferPtr = stCrashBuffer; stCrashBufferLeft = CRASH_BUFFER_SIZE - 10; // Title MyAddToBuffer ("*** ENVIRONMENT CRASH ***\r\n\r\n"); // Get environment information MyGetEnvironmentInfo (); // Add the reason for the crash MyAddToBuffer ("\r\n\r\n"); MyAddToBuffer ("Cause of Crash: "); EdCrash_GetExceptionName (stCrashBufferPtr, pmExceptionInfo -> ExceptionRecord -> ExceptionCode); stCrashBufferLeft -= strlen (stCrashBufferPtr); stCrashBufferPtr += strlen (stCrashBufferPtr); // Add previous operations MyAddPreviousCommandsToBuffer (); // Add the register dump EdCrash_RegisterDump (stCrashBufferPtr, pmExceptionInfo -> ContextRecord); stCrashBufferLeft -= strlen (stCrashBufferPtr); stCrashBufferPtr += strlen (stCrashBufferPtr); MyAddToBuffer ("\r\n\r\n"); // Add the stack dump EdCrash_StackDump (stCrashBufferPtr, stCrashBufferLeft, pmExceptionInfo -> ContextRecord); stCrashBufferLeft -= strlen (stCrashBufferPtr); stCrashBufferPtr += strlen (stCrashBufferPtr); MyAddToBuffer (LINE_OF_DASHES); MyAddToBuffer ("\r\n"); } if (stMyFileOpenStatus != OPEN_SUCCESS) { if (stMyFileOpenStatus == OPEN_FAIL_CURRENT_IS_STARTUP) { EdGUI_Message ("Panic log failure", "Unable to open \"%s\" for writing.\nError = %d", stMyPanicLogName, stMyFileOpenError); } else { EdGUI_Message ("Panic log failure", "Unable to open \"%s\" or \"%s\" for writing.\nError = %d", stMyPanicLogName, stMyAltPanicLogName, stMyFileOpenError); } return EXCEPTION_EXECUTE_HANDLER; } stMyPanicFile = CreateFile (stMyPanicLogName, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (stMyPanicFile == (HANDLE) INVALID_HANDLE_VALUE) { EdGUI_Message ("Panic log failure", "Unable to open \"%s\" for writing.\nError = %d", stMyPanicLogName, GetLastError ()); return EXCEPTION_EXECUTE_HANDLER; } // Move to the end of the file SetFilePointer (stMyPanicFile, 0, NULL, FILE_END); if (!WriteFile (stMyPanicFile, stCrashBuffer, strlen (stCrashBuffer), &stMyNumBytesWritten, NULL)) { EdGUI_Message ("Panic log failure", "Unable to write to \"%s\"\nError = %d", stMyPanicLogName, GetLastError ()); return EXCEPTION_EXECUTE_HANDLER; } if (stMyNumBytesWritten != strlen (stCrashBuffer)) { EdGUI_Message ("Panic log failure", "Unable to write to \"%s\"\n%d bytes written instead of %d bytes", stMyPanicLogName, stMyNumBytesWritten, strlen (stCrashBuffer)); return EXCEPTION_EXECUTE_HANDLER; } if (!FlushFileBuffers (stMyPanicFile)) { EdGUI_Message ("Panic log failure", "Unable to flush buffers of \"%s\"\nError = %d", stMyPanicLogName, GetLastError ()); return EXCEPTION_EXECUTE_HANDLER; } if (!CloseHandle (stMyPanicFile)) { EdGUI_Message ("Panic log failure", "Unable to close \"%s\"\nError = %d", stMyPanicLogName, GetLastError ()); return EXCEPTION_EXECUTE_HANDLER; } return EXCEPTION_EXECUTE_HANDLER; } // EdFail_CrashHandler
void FileOutputStream::flush(){ FlushFileBuffers(this->file); }