C / C++ / MFC

/*
 *  Members of CDevice that are used to store data concerning the dump to file:
 */
// --- CDevice members for test dump  ---
bool		m_test_dump_file_open;
HANDLE		m_FileHandle;
PRKDPC		m_FileTimeoutDpc;
KTIMER		m_FileTimeoutTimer;
// ------------


/*
 *  Handle_IOCTL_Open opens the file handle and initialises the DPC, 
 *  sets the timer for the first time
 */
CDevice::
Handle_IOCTL_Open(CDevice * pDevice,
                  PIRP Irp, 
                  PIO_STACK_LOCATION pIoStackIrp,
                  UINT *pdwDataWritten)
{
  PAGED_CODE();

  //--- filename
  UNICODE_STRING FileName;
  RtlZeroMemory(&FileName, sizeof(FileName));
  RtlInitUnicodeString(&FileName,  
                       L"\\DosDevices\\C:\\media\\pbda_driver_dump.ts");  
  //---
  OBJECT_ATTRIBUTES FileObject;
  IO_STATUS_BLOCK IoStatus;  
  NTSTATUS Status;

  // initialize file object
  InitializeObjectAttributes(&FileObject,
            &FileName,
            OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
            NULL,
            NULL);

  // init file handle
  Status = ZwCreateFile(&(pDevice->m_FileHandle),
            FILE_APPEND_DATA | SYNCHRONIZE, 
            &FileObject,
            &IoStatus,
            NULL,
            FILE_ATTRIBUTE_NORMAL,
            FILE_SHARE_WRITE,
            FILE_SUPERSEDE, 
            FILE_SYNCHRONOUS_IO_NONALERT,        
            NULL,
            0);

  // --- Initialize TIMER
  PAGED_CODE();

  // init timer
  KeInitializeTimer (&(pDevice->m_FileTimeoutTimer));

  // allocate memory for DPC
  pDevice->m_FileTimeoutDpc = new(NonPagedPool,MS_SAMPLE_TUNER_POOL_TAG) KDPC;

  // init dpc
  KeInitializeDpc (pDevice->m_FileTimeoutDpc, 
		   reinterpret_cast <PKDEFERRED_ROUTINE> CDevice::TimeoutTimerDPC),	 
                   pDevice );

  // set timer
  ResetTimeoutTimer(pDevice);
 
  return Status;
}

/*
 *  ResetTimeoutTimer [re]sets the timer to 10 seconds
 */
CDevice::
ResetTimeoutTimer(CDevice * pDevice)
{
  // lock
  KIRQL             MySpinIrql;
  KeAcquireSpinLock(&(pDevice->m_buffer_queue_lock), &MySpinIrql);

  // timer delay: 10 sec
  LARGE_INTEGER NextDeltaTime;
  NextDeltaTime.QuadPart = (-100000000); // 10s ; expressed in 100-nanosecond intervals		   		   
  // cancel current timer
  KeCancelTimer(&(pDevice->m_FileTimeoutTimer)); // this step might be unnecessary

  // set timer
  KeSetTimer (&(pDevice->m_FileTimeoutTimer), 
              NextDeltaTime, 
              pDevice->m_FileTimeoutDpc);

  // unlock
  KeReleaseSpinLock(&(pDevice->m_buffer_queue_lock), MySpinIrql);
}


/*
 *  TimeoutTimerDPC  gets called when the timer expires, 
 *  and is supposed to close the file handle
 */
//-----
void
CDevice::
TimeoutTimerDPC (
        IN PKDPC Dpc,
        IN CDevice *pDevice,
        IN PVOID SystemArg1,
        IN PVOID SystemArg2
        )
{
  UNREFERENCED_PARAMETER(Dpc);
  UNREFERENCED_PARAMETER(SystemArg1);
  UNREFERENCED_PARAMETER(SystemArg2);

  // lock
  KIRQL             MySpinIrql;
  KeAcquireSpinLock(&(pDevice->m_buffer_queue_lock), &MySpinIrql);
	
  NTSTATUS Status;
  // close file handler
  if(pDevice){
    Status = ZwClose(pDevice->m_FileHandle); // <--- this line causes bluescreen
  }
		
  // unlock
  KeReleaseSpinLock(&(pDevice->m_buffer_queue_lock), MySpinIrql);	 
		 
}

_tfopen_s(&fileptr, File_Path, _T("wb+") );
         fwrite ( buffer1, 25, 1, fileptr );
	fclose(fileptr);

_tfopen_s(&fileptr, File_Path, _T("ab") );
	fwrite ( buffer1, 25, 1, fileptr );
	fclose(fileptr);

Point pntA = new Point(10, 25);
Point pntB = new Point();

unsafe
{
  // Error	4	
  // You cannot use the fixed statement to take 
  // the address of an already fixed expression	
  fixed (Point* ptrA = &pntA, ptrB = &pntB)
  {
    ptrB->X = ptrA->X;
    ptrB->Y = ptrA->Y;
  }
}

Point pntA = new Point(10, 25);
Point pntB = new Point();

unsafe
{
  // Correct
  Point* ptrA = &pntA, ptrB = &pntB;
  ptrB->X = ptrA->X;
  ptrB->Y = ptrA->Y;
}

// /clr
generic <typename T> where T : value struct
T GetValueA(void* ptr)
{
  T val = Activator::CreateInstance<T>();

  pin_ptr<T> valPtr = &val;
  memcpy(valPtr, ptr, sizeof(T));
  return val;
}

generic <typename T> where T : value struct
T GetValueB(void* ptr)
{
  T val = Activator::CreateInstance<T>();

  memcpy(&val, ptr, sizeof(T));
  return val;
}