Пример #1
0
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
}
Пример #2
0
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;
}
Пример #3
0
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;
}
Пример #4
0
/**
 * 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

}
Пример #5
0
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;
}
Пример #6
0
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;
}
Пример #7
0
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;
}
Пример #8
0
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;
}
Пример #9
0
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;

}
Пример #10
0
/*
 *----------------------------------------------------------------------
 *
 * 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; 
}
Пример #11
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;
}
Пример #12
0
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;
}
Пример #13
0
/*----------------------------------------------------------------------------------------------
	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);
}
Пример #14
0
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;
}
Пример #15
0
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);
	}
Пример #17
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;
    }

}
Пример #18
0
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;
	}
}
Пример #19
0
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;
}
Пример #20
0
 bool FlushPlatformFile(PlatformFile file)
 {
     ThreadRestrictions::AssertIOAllowed();
     return ((file!=kInvalidPlatformFileValue) && FlushFileBuffers(file));
 }
Пример #21
0
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;
}
Пример #22
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;
}
Пример #23
0
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;
}
Пример #24
0
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;
}
Пример #25
0
void OsFile::flush()
{
	ASSERT(nullptr != m_impl);
	FlushFileBuffers(m_impl->m_file);
}
Пример #26
0
/*******************************************************************************
** 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;
}
Пример #27
0
/** 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;
}
Пример #28
0
static void worker_fsync(struct job_fsync *job)
{
  if (!FlushFileBuffers(job->handle))
    job->error_code = GetLastError();
}
Пример #29
0
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
Пример #30
0
void FileOutputStream::flush(){
	FlushFileBuffers(this->file);
}