yincheng01

vc实现用文件系统过滤驱动实现文件隐藏的类

调用一个开源的文件过滤驱动，

头文件

typedef struct _ATTACH_EXTENSION {

  CHAR   VolumeLetter;
  PDEVICE_OBJECT VolumeDevice;

} ATTACH_EXTENSION, *PATTACH_EXTENSION;

PDRIVER_OBJECT g_DriverObject;

源文件
#include <ntifs.h>
#include "HideDirFile.h"

//-------------------------------------------------
// F A S T I / O
//-------------------------------------------------

BOOLEAN
FilemonFastIoCheckifPossible(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN ULONG Length,
  IN BOOLEAN Wait,
  IN ULONG LockKey,
  IN BOOLEAN CheckForReadOperation,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoRead(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN ULONG Length,
  IN BOOLEAN Wait,
  IN ULONG LockKey,
  OUT PVOID Buffer,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoWrite(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN ULONG Length,
  IN BOOLEAN Wait,
  IN ULONG LockKey,
  IN PVOID Buffer,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoQueryBasicInfo(
  IN PFILE_OBJECT FileObject,
  IN BOOLEAN Wait,
  OUT PFILE_BASIC_INFORMATION Buffer,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoQueryStandardInfo(
  IN PFILE_OBJECT FileObject,
  IN BOOLEAN Wait,
  OUT PFILE_STANDARD_INFORMATION Buffer,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoLock(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN PLARGE_INTEGER Length,
  PEPROCESS ProcessId,
  ULONG Key,
  BOOLEAN FailImmediately,
  BOOLEAN ExclusiveLock,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoUnlockSingle(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN PLARGE_INTEGER Length,
  PEPROCESS ProcessId,
  ULONG Key,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoUnlockAll(
  IN PFILE_OBJECT FileObject,
  PEPROCESS ProcessId,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoUnlockAllByKey(
  IN PFILE_OBJECT FileObject,
  PEPROCESS ProcessId, ULONG Key,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoDeviceControl(
  IN PFILE_OBJECT FileObject,
  IN BOOLEAN Wait,
  IN PVOID InputBuffer,
  IN ULONG InputBufferLength,
  OUT PVOID OutbufBuffer,
  IN ULONG OutputBufferLength,
  IN ULONG IoControlCode,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

VOID
FilemonFastIoAcquireFile(
  PFILE_OBJECT FileObject
  );

VOID
FilemonFastIoReleaseFile(
  PFILE_OBJECT FileObject
  );

VOID
FilemonFastIoDetachDevice(
  PDEVICE_OBJECT SourceDevice,
  PDEVICE_OBJECT TargetDevice
  );

//
// These are new NT 4.0 Fast I/O calls
//
BOOLEAN
FilemonFastIoQueryNetworkOpenInfo(
  IN PFILE_OBJECT FileObject,
  IN BOOLEAN Wait,
  OUT struct _FILE_NETWORK_OPEN_INFORMATION *Buffer,
  OUT struct _IO_STATUS_BLOCK *IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

NTSTATUS
FilemonFastIoAcquireForModWrite(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER EndingOffset,
  OUT struct _ERESOURCE **ResourceToRelease,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoMdlRead(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN ULONG Length,
  IN ULONG LockKey,
  OUT PMDL *MdlChain,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoMdlReadComplete(
  IN PFILE_OBJECT FileObject,
  IN PMDL MdlChain,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoPrepareMdlWrite(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN ULONG Length,
  IN ULONG LockKey,
  OUT PMDL *MdlChain,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoMdlWriteComplete(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN PMDL MdlChain,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoReadCompressed(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN ULONG Length,
  IN ULONG LockKey,
  OUT PVOID Buffer,
  OUT PMDL *MdlChain,
  OUT PIO_STATUS_BLOCK IoStatus,
  OUT struct _COMPRESSED_DATA_INFO *CompressedDataInfo,
  IN ULONG CompressedDataInfoLength,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoWriteCompressed(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN ULONG Length,
  IN ULONG LockKey,
  IN PVOID Buffer,
  OUT PMDL *MdlChain,
  OUT PIO_STATUS_BLOCK IoStatus,
  IN struct _COMPRESSED_DATA_INFO *CompressedDataInfo,
  IN ULONG CompressedDataInfoLength,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoMdlReadCompleteCompressed(
  IN PFILE_OBJECT FileObject,
  IN PMDL MdlChain,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoMdlWriteCompleteCompressed(
  IN PFILE_OBJECT FileObject,
  IN PLARGE_INTEGER FileOffset,
  IN PMDL MdlChain,
  IN PDEVICE_OBJECT DeviceObject
  );

BOOLEAN
FilemonFastIoQueryOpen(
  IN struct _IRP *Irp,
  OUT PFILE_NETWORK_OPEN_INFORMATION NetworkInformation,
  IN PDEVICE_OBJECT DeviceObject
  );

NTSTATUS
FilemonFastIoReleaseForModWrite(
  IN PFILE_OBJECT FileObject,
  IN struct _ERESOURCE *ResourceToRelease,
  IN PDEVICE_OBJECT DeviceObject
  );

NTSTATUS
FilemonFastIoAcquireForCcFlush(
  IN PFILE_OBJECT FileObject,
  IN PDEVICE_OBJECT DeviceObject
  );

NTSTATUS
FilemonFastIoReleaseForCcFlush(
  IN PFILE_OBJECT FileObject,
  IN PDEVICE_OBJECT DeviceObject
  );

//-------------------------------------------------
// C U S T O M F U N C T I O N
//-------------------------------------------------

NTSTATUS
GetVolumesToAttach(
OUT PULONG VolumesToAttach
);

NTSTATUS
AttachAllVolume(
IN PDRIVER_OBJECT DriverObject
);

NTSTATUS
AttachOneVolume(
  IN ULONG   Volume,
  IN PDRIVER_OBJECT DriverObject
  );

NTSTATUS
FilterDispatch(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP   Irp
  );

NTSTATUS
CompletionRoutine(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP   Irp,
  IN PVOID   Context
  );

BOOLEAN
HideOrNot(
  IN PWCHAR FileName,
  IN ULONG FileNameLength
  );

VOID
HideHandler(
  IN ULONG      Index,
  IN PFILE_BOTH_DIR_INFORMATION CurrEntry,
  IN PFILE_BOTH_DIR_INFORMATION LastEntry,
  IN PIRP      Irp
  );

//-------------------------------------------------
// N A T I V E A P I F U N C T I O N
//-------------------------------------------------

#define ProcessDeviceMap 23

#define  DRIVE_UNKNOWN  0
#define  DRIVE_NO_ROOT_DIR 1
#define  DRIVE_REMOVABLE  2
#define  DRIVE_CDROM   5

NTSTATUS
ZwQueryInformationProcess(
  IN HANDLE  ProcessHandle,
  IN ULONG  ProcessInformationClass,
  OUT PVOID  ProcessInformation,
  IN ULONG  ProcessInformationLength,
  OUT PULONG  ReturnLength
  );

FAST_IO_DISPATCH FastIOHook = {

  sizeof(FAST_IO_DISPATCH),
  FilemonFastIoCheckifPossible,
  FilemonFastIoRead,
  FilemonFastIoWrite,
  FilemonFastIoQueryBasicInfo,
  FilemonFastIoQueryStandardInfo,
  FilemonFastIoLock,
  FilemonFastIoUnlockSingle,
  FilemonFastIoUnlockAll,
  FilemonFastIoUnlockAllByKey,
  FilemonFastIoDeviceControl,
  FilemonFastIoAcquireFile,
  FilemonFastIoReleaseFile,
  FilemonFastIoDetachDevice,

  //
  // new for NT 4.0
  //
  FilemonFastIoQueryNetworkOpenInfo,
  FilemonFastIoAcquireForModWrite,
  FilemonFastIoMdlRead,
  FilemonFastIoMdlReadComplete,
  FilemonFastIoPrepareMdlWrite,
  FilemonFastIoMdlWriteComplete,
  FilemonFastIoReadCompressed,
  FilemonFastIoWriteCompressed,
  FilemonFastIoMdlReadCompleteCompressed,
  FilemonFastIoMdlWriteCompleteCompressed,
  FilemonFastIoQueryOpen,
  FilemonFastIoReleaseForModWrite,
  FilemonFastIoAcquireForCcFlush,
  FilemonFastIoReleaseForCcFlush
};

NTSTATUS
DriverEntry(
  IN PDRIVER_OBJECT DriverObject,
  IN PUNICODE_STRING RegistryPath
  )
{
  ULONG i;

  g_DriverObject = DriverObject;

  //
  // Dispatch Routine
  //

for ( i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++ ) {

    DriverObject->MajorFunction[i] = FilterDispatch;
  }

  //
  // Fast I/O Calls
  //

DriverObject->FastIoDispatch = &FastIOHook;

return AttachAllVolume( DriverObject );
}

NTSTATUS GetVolumesToAttach(OUT PULONG VolumesToAttach)
{
  NTSTATUS      status;
  PROCESS_DEVICEMAP_INFORMATION DeviceMapInfo;
  ULONG       MaxVolumeSet;
  ULONG       CurVolumeSet;
  ULONG       i;

  status = ZwQueryInformationProcess(
         (HANDLE) 0xffffffff,
         ProcessDeviceMap,
         &DeviceMapInfo,
         sizeof(DeviceMapInfo),
         NULL
         );

if ( !NT_SUCCESS(status) )
return status;

  MaxVolumeSet = DeviceMapInfo.Query.DriveMap;
  CurVolumeSet = MaxVolumeSet;

  //
  // 排除以下指定的类型
  //

for ( i = 0; i < 26; i++ ) {

if ( MaxVolumeSet & (1 << i) ) {

switch ( DeviceMapInfo.Query.DriveType[i] ) {

      case DRIVE_UNKNOWN:
      case DRIVE_NO_ROOT_DIR:
      case DRIVE_REMOVABLE:
      case DRIVE_CDROM:

        CurVolumeSet &= ~(1 << i);
        break;
      }
    }
  }

*VolumesToAttach = CurVolumeSet;
return STATUS_SUCCESS;
}

NTSTATUS
AttachOneVolume(
  IN ULONG   Volume,
  IN PDRIVER_OBJECT DriverObject
  )
{
  WCHAR    RootDirectory[] = L"//DosDevices//A://";
  UNICODE_STRING  ustrRootDirectory;
  OBJECT_ATTRIBUTES ObjectAttributes;
  HANDLE    FileHandle;
  IO_STATUS_BLOCK  IoStatus;
  PFILE_OBJECT  FileObject;
  PDEVICE_OBJECT  VolumeDevice;
  PDEVICE_OBJECT  AttachDevice;
  PATTACH_EXTENSION AttachExtension;
  NTSTATUS   status;

RootDirectory[12] = (CHAR) ('A' + Volume);

  RtlInitUnicodeString( &ustrRootDirectory, RootDirectory );

  InitializeObjectAttributes(
       &ObjectAttributes,
       &ustrRootDirectory,
       OBJ_CASE_INSENSITIVE,
       NULL,
       NULL
       );

  status = ZwCreateFile(
       &FileHandle,
       SYNCHRONIZE | FILE_ANY_ACCESS,
       &ObjectAttributes,
       &IoStatus,
       NULL,
       0,
       FILE_SHARE_READ | FILE_SHARE_WRITE,
       FILE_OPEN,
       FILE_SYNCHRONOUS_IO_NONALERT | FILE_DIRECTORY_FILE,
       NULL,
       0
       );

  if ( !NT_SUCCESS(status) ) return status;

  status = ObReferenceObjectByHandle(
       FileHandle,
       FILE_READ_DATA,
       NULL,
       KernelMode,
       &FileObject,
       NULL
       );

if ( !NT_SUCCESS(status) ) {

    ZwClose( FileHandle );
    return status;
  }

VolumeDevice = IoGetRelatedDeviceObject( FileObject );

  if ( !VolumeDevice ) {

    ObDereferenceObject( FileObject );
    ZwClose( FileHandle );
    return STATUS_UNSUCCESSFUL;
  }

  status = IoCreateDevice(
       DriverObject,
       sizeof(ATTACH_EXTENSION),
       NULL,
       VolumeDevice->DeviceType,
       VolumeDevice->Characteristics,
       FALSE,
       &AttachDevice
       );

if ( !NT_SUCCESS(status) ) {

    ObDereferenceObject( FileObject );
    ZwClose( FileHandle );
    return status;
  }

AttachDevice->Flags &= ~DO_DEVICE_INITIALIZING;
AttachDevice->Flags |= ( VolumeDevice->Flags & (DO_BUFFERED_IO | DO_DIRECT_IO) );

AttachExtension = (PATTACH_EXTENSION) AttachDevice->DeviceExtension;

AttachExtension->VolumeLetter = (CHAR) ('A' + Volume);
AttachExtension->VolumeDevice = VolumeDevice;

  if ( !IoAttachDeviceToDeviceStack(
         AttachDevice,
         VolumeDevice) ) {

    IoDeleteDevice( AttachDevice );
    ObDereferenceObject( FileObject );
    ZwClose( FileHandle );
    return STATUS_UNSUCCESSFUL;
  }

return STATUS_SUCCESS;
}

NTSTATUS AttachAllVolume(IN PDRIVER_OBJECT DriverObject)
{
  NTSTATUS status;
  ULONG  VolumesToAttach;
  ULONG  i;

status = GetVolumesToAttach( &VolumesToAttach );

if ( !NT_SUCCESS(status) )
return status;

for ( i = 0; i < 26; i++ ) {

if ( VolumesToAttach & (1 << i) ) {

status = AttachOneVolume( i, DriverObject );

if ( !NT_SUCCESS(status) ) {

        return status;
      }
    }
  }

return STATUS_SUCCESS;
}

NTSTATUS
FilterDispatch(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP   Irp
  )
{
  PATTACH_EXTENSION AttachExtension;

AttachExtension = (PATTACH_EXTENSION) DeviceObject->DeviceExtension;

IoCopyCurrentIrpStackLocationToNext( Irp );

  IoSetCompletionRoutine(
       Irp,
       CompletionRoutine,
       NULL,
       TRUE,
       TRUE,
       FALSE
       );

  return IoCallDriver( AttachExtension->VolumeDevice, Irp );
}

NTSTATUS
CompletionRoutine(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP   Irp,
  IN PVOID   Context
  )
{
  PFILE_BOTH_DIR_INFORMATION volatile CurrEntry;
  PFILE_BOTH_DIR_INFORMATION volatile LastEntry;

  ULONG     BufferLength;
  ULONG     Index;
  PIO_STACK_LOCATION  IrpSp;

IrpSp = IoGetCurrentIrpStackLocation( Irp );

  if ( IrpSp->MajorFunction == IRP_MJ_DIRECTORY_CONTROL
   && IrpSp->MinorFunction == IRP_MN_QUERY_DIRECTORY
   && KeGetCurrentIrql() == PASSIVE_LEVEL
   && IrpSp->Parameters.QueryDirectory.FileInformationClass == FileBothDirectoryInformation
  ) {

    Index   = -1;
    LastEntry  = NULL;
    CurrEntry  = (PFILE_BOTH_DIR_INFORMATION) Irp->UserBuffer;
    BufferLength = Irp->IoStatus.Information;

if ( BufferLength > 0 ) {

     do {

       if ( LastEntry != NULL ) {

         CurrEntry = (PFILE_BOTH_DIR_INFORMATION) /
            ((PCHAR) CurrEntry + CurrEntry->NextEntryOffset);
       }

Index++;

if ( HideOrNot( CurrEntry->FileName, CurrEntry->FileNameLength ) ) {

         HideHandler( Index, CurrEntry, LastEntry, Irp );

         break;
       }

LastEntry = CurrEntry;

} while ( CurrEntry->NextEntryOffset != 0 );

}
}

if ( Irp->PendingReturned ) {

IoMarkIrpPending( Irp );
}

return Irp->IoStatus.Status;
}

BOOLEAN
HideOrNot(
  IN PWCHAR FileName,
  IN ULONG FileNameLength
  )
{
  LONG   ret;
  UNICODE_STRING ustr1;
  UNICODE_STRING ustr2;

RtlInitUnicodeString( &ustr1, FileName );
ustr1.Length = (USHORT) FileNameLength;

RtlInitUnicodeString( &ustr2, L"dream_8.txt" );

  ret = RtlCompareUnicodeString(
        &ustr1,
        &ustr2,
        TRUE
        );

  if ( ret == 0 ) return TRUE;

  else   return FALSE;
}

VOID
HideHandler(
  IN ULONG      Index,
  IN PFILE_BOTH_DIR_INFORMATION CurrEntry,
  IN PFILE_BOTH_DIR_INFORMATION LastEntry,
  IN PIRP      Irp
  )
{
  PVOID temp;

if ( Index == 0 && CurrEntry->NextEntryOffset == 0 ) {

    RtlZeroMemory( CurrEntry, Irp->IoStatus.Information );
    Irp->IoStatus.Information = 0;
    Irp->UserBuffer = NULL;

  } else if ( Index == 0 && CurrEntry->NextEntryOffset != 0 ) {

    temp = ExAllocatePool(
        NonPagedPool,
        Irp->IoStatus.Information - CurrEntry->NextEntryOffset
        );

if ( temp ) {

      RtlCopyMemory(
        temp,
        (PCHAR) CurrEntry + CurrEntry->NextEntryOffset,
        Irp->IoStatus.Information - CurrEntry->NextEntryOffset
        );

      RtlZeroMemory(
        CurrEntry,
        Irp->IoStatus.Information
        );

      RtlCopyMemory(
        CurrEntry,
        temp,
        Irp->IoStatus.Information - CurrEntry->NextEntryOffset
        );

Irp->IoStatus.Information -= CurrEntry->NextEntryOffset;

ExFreePool( temp );
}

} else if ( Index > 0 && CurrEntry->NextEntryOffset != 0 ) {

    temp = ExAllocatePool(
        NonPagedPool,
        ((PCHAR) Irp->UserBuffer + Irp->IoStatus.Information) - /
        ((PCHAR) CurrEntry + CurrEntry->NextEntryOffset)
        );

    if ( temp ) {

      RtlCopyMemory(
        temp,
        (PCHAR) CurrEntry + CurrEntry->NextEntryOffset,
        ((PCHAR) Irp->UserBuffer + Irp->IoStatus.Information) - /
        ((PCHAR) CurrEntry + CurrEntry->NextEntryOffset)
        );

      RtlZeroMemory(
        CurrEntry,
        ((PCHAR) Irp->UserBuffer + Irp->IoStatus.Information) - /
        (PCHAR) CurrEntry
        );

      RtlCopyMemory(
        CurrEntry,
        temp,
        ((PCHAR) Irp->UserBuffer + Irp->IoStatus.Information) - /
        ((PCHAR) CurrEntry + CurrEntry->NextEntryOffset)
        );

Irp->IoStatus.Information -= CurrEntry->NextEntryOffset;

ExFreePool( temp );
}

} else if ( Index > 0 && CurrEntry->NextEntryOffset == 0 ) {

    RtlZeroMemory(
      CurrEntry,
      ((PCHAR) Irp->UserBuffer + Irp->IoStatus.Information) - /
      (PCHAR) CurrEntry
      );

LastEntry->NextEntryOffset = 0;

Irp->IoStatus.Information = (PCHAR) CurrEntry - (PCHAR) Irp->UserBuffer;
}
}

//----------------------------------------------------------------------
// F A S T I O R O U T I N E S
//----------------------------------------------------------------------

BOOLEAN
FilemonFastIoCheckifPossible(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN ULONG Length,
    IN BOOLEAN Wait,
    IN ULONG LockKey,
    IN BOOLEAN CheckForReadOperation,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoRead(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN ULONG Length,
    IN BOOLEAN Wait,
    IN ULONG LockKey,
    OUT PVOID Buffer,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoWrite(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN ULONG Length,
    IN BOOLEAN Wait,
    IN ULONG LockKey,
    IN PVOID Buffer,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoQueryBasicInfo(
    IN PFILE_OBJECT FileObject,
    IN BOOLEAN Wait,
    OUT PFILE_BASIC_INFORMATION Buffer,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoQueryStandardInfo(
    IN PFILE_OBJECT FileObject,
    IN BOOLEAN Wait,
    OUT PFILE_STANDARD_INFORMATION Buffer,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoLock(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN PLARGE_INTEGER Length,
    PEPROCESS ProcessId,
    ULONG Key,
    BOOLEAN FailImmediately,
    BOOLEAN ExclusiveLock,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoUnlockSingle(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN PLARGE_INTEGER Length,
    PEPROCESS ProcessId,
    ULONG Key,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoUnlockAll(
    IN PFILE_OBJECT FileObject,
    PEPROCESS ProcessId,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoUnlockAllByKey(
    IN PFILE_OBJECT FileObject,
    PEPROCESS ProcessId,
    ULONG Key,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoQueryNetworkOpenInfo(
    IN PFILE_OBJECT FileObject,
    IN BOOLEAN Wait,
    OUT struct _FILE_NETWORK_OPEN_INFORMATION *Buffer,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

NTSTATUS
FilemonFastIoAcquireForModWrite(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER EndingOffset,
    OUT struct _ERESOURCE **ResourceToRelease,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoMdlRead(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN ULONG Length,
    IN ULONG LockKey,
    OUT PMDL *MdlChain,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoMdlReadComplete(
    IN PFILE_OBJECT FileObject,
    IN PMDL MdlChain,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoPrepareMdlWrite(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN ULONG Length,
    IN ULONG LockKey,
    OUT PMDL *MdlChain,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoMdlWriteComplete(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN PMDL MdlChain,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoReadCompressed(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN ULONG Length,
    IN ULONG LockKey,
    OUT PVOID Buffer,
    OUT PMDL *MdlChain,
    OUT PIO_STATUS_BLOCK IoStatus,
    OUT struct _COMPRESSED_DATA_INFO *CompressedDataInfo,
    IN ULONG CompressedDataInfoLength,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoWriteCompressed(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN ULONG Length,
    IN ULONG LockKey,
    OUT PVOID Buffer,
    OUT PMDL *MdlChain,
    OUT PIO_STATUS_BLOCK IoStatus,
    OUT struct _COMPRESSED_DATA_INFO *CompressedDataInfo,
    IN ULONG CompressedDataInfoLength,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoMdlReadCompleteCompressed(
    IN PFILE_OBJECT FileObject,
    IN PMDL MdlChain,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoMdlWriteCompleteCompressed(
    IN PFILE_OBJECT FileObject,
    IN PLARGE_INTEGER FileOffset,
    IN PMDL MdlChain,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

BOOLEAN
FilemonFastIoQueryOpen(
    IN PIRP Irp,
    OUT PFILE_NETWORK_OPEN_INFORMATION NetworkInformation,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

NTSTATUS
FilemonFastIoReleaseForModWrite(
    IN PFILE_OBJECT FileObject,
    IN struct _ERESOURCE *ResourceToRelease,
    IN PDEVICE_OBJECT DeviceObject
    )
{

  return STATUS_NOT_IMPLEMENTED;
}

NTSTATUS
FilemonFastIoAcquireForCcFlush(
    IN PFILE_OBJECT FileObject,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return STATUS_NOT_IMPLEMENTED;
}

NTSTATUS
FilemonFastIoReleaseForCcFlush(
    IN PFILE_OBJECT FileObject,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return STATUS_NOT_IMPLEMENTED;
}

BOOLEAN
FilemonFastIoDeviceControl(
    IN PFILE_OBJECT FileObject,
    IN BOOLEAN Wait,
    IN PVOID InputBuffer,
    IN ULONG InputBufferLength,
    OUT PVOID OutputBuffer,
    IN ULONG OutputBufferLength,
    IN ULONG IoControlCode,
    OUT PIO_STATUS_BLOCK IoStatus,
    IN PDEVICE_OBJECT DeviceObject
    )
{
  return FALSE;
}

VOID
FilemonFastIoAcquireFile(
PFILE_OBJECT FileObject
)
{

}

VOID
FilemonFastIoReleaseFile(
PFILE_OBJECT FileObject
)
{

}

VOID
FilemonFastIoDetachDevice(
    PDEVICE_OBJECT SourceDevice,
    PDEVICE_OBJECT TargetDevice
    )
{

}

调用时创建一个结构体，就可以隐藏自己的文件

你可能感兴趣的:(struct,object,null,Integer,buffer,extension)

android系统selinux中添加新属性property 辉色投像
1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
每日一题——第八十四题互联网打工人no1 C语言程序设计每日一练 c语言
题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
使用LLaVa和Ollama实现多模态RAG示例 llzwxh888 python 人工智能开发语言
本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
ARM驱动学习之4小结 JT灬新一嵌入式 C++arm开发学习 linux
ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
ARM V8 base instruction -- Debug instructions xiaozhiwise Assembly arm
/**Debuginstructions*/BRK#imm16进入monitormodedebug，那里有on-chipdebugmonitorcodeHLT#imm16进入haltmodedebug，连接有外部调试硬件
Armv8.3 体系结构扩展--原文版代码改变世界ctw ARM-TEE-Android armv8 嵌入式 arm架构安全架构芯片 Trustzone Secureboot
快速链接:.ARMv8/ARMv9架构入门到精通-[目录]付费专栏-付费课程【购买须知】:个人博客笔记导读目录(全部)TheArmv8.3architectureextensionTheArmv8.3architectureextensionisanextensiontoArmv8.2.Itaddsmandatoryandoptionalarchitecturalfeatures.Somefeat
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】汉子萌萌哒 CCF noi 算法数据结构 c++
一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
iOS内存管理简单理解烧烤有点辣
什么是引用计数引用计数（ReferenceCount）是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候，它的引用计数为1，当有一个新的指针指向这个对象时，我们将其引用计数加1，当某个指针不再指向这个对象是，我们将其引用计数减1，当对象的引用计数变为0时，说明这个对象不再被任何指针指向了，这个时候我们就可以将对象销毁，回收内存。由于引用计数简单有效，除了Objective-C和S
粒子群优化 (PSO) 在三维正弦波函数中的应用 subject625Ruben 机器学习人工智能 matlab 算法
在这篇博客中，我们将展示如何使用粒子群优化（PSO）算法求解三维正弦波函数，并通过增加正弦波扰动，使优化过程更加复杂和有趣。本文将介绍目标函数的定义、PSO参数设置以及算法执行的详细过程，并展示搜索空间中的动态过程和收敛曲线。1.目标函数定义我们使用的目标函数是一个三维正弦波函数，定义如下：objectiveFunc=@(x)sin(sqrt(x(1).^2+x(2).^2))+0.5*sin(5
自定义队列 junjun2018
队列：像排队吃饭一样，先到的先点菜，后来的后点菜。以下代码展示使用单向列表实现的队列。//链表是以节点为单位的，对于单向链表，每个节点中包含一个值和指向下一个对象的引用publicclassNode{Objectvalue;Nodenext;publicNode(Objectvalue){this.value=value;}publicObjectgetValue(){returnvalue;}p
leetcode-617. 合并二叉树 manba_ leetcode hot100 leetcode 算法
题目描述给你两棵二叉树：root1和root2。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为null的节点将直接作为新二叉树的节点。返回合并后的二叉树。注意:合并过程必须从两个树的根节点开始。示例1：输入：root1=[1,3,2,
使用由 Python 编写的 lxml 实现高性能 XML 解析 hunyxv python 笔记 python xml
转载自：文章lxml简介Python从来不出现XML库短缺的情况。从2.0版本开始，它就附带了xml.dom.minidom和相关的pulldom以及SimpleAPIforXML(SAX)模块。从2.4开始，它附带了流行的ElementTreeAPI。此外，很多第三方库可以提供更高级别的或更具有python风格的接口。尽管任何XML库都足够处理简单的DocumentObjectModel(DOM
Golang语言基础知识点总结最帅猪猪侠 golang 开发语言后端
Golang语言基础知识点小总结1.go语言有两大类型：值类型：数值类型，bool，string，数组，struct结构体变量直接存储值，内存通常在栈中分配,修改值,不会对源对象产生影响引用类型：指针，slice切片，管道chan，map，interface变量存储的是一个地址，这个地址对应的空间才真正存储数据值，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾
C++常见知识掌握 nfgo c++开发语言
1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
golang获取用户输入的几种方式余生逆风飞翔 golang 开发语言后端
一、定义结构体typeUserInfostruct{Namestring`json:"name"`Ageint`json:"age"`Addstring`json:"add"`}typeReturnDatastruct{Messagestring`json:"message"`Statusstring`json:"status"`DataUserInfo`json:"data"`}二、get请求的
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your †徐先森® Oracle数据库 Web相关错误集
createtablestudents(idintunsignedprimarykeyauto_increment,namevarchar(50)notnull,ageintunsigned,highdecimal(3,2),genderenum('男','女','中性','保密','妖')default'保密',cls_idintunsigned);在对数据库插入如上带有中文带有默认值的字段的时
metaRTC5.0 API编程指南(一) metaRTC metaRTC c++c语言 webrtc
概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
LeetCode 673. Number of Longest Increasing Subsequence (Java版; Meidum) littlehaes 字符串动态规划算法 leetcode 数据结构
welcometomyblogLeetCode673.NumberofLongestIncreasingSubsequence(Java版;Meidum)题目描述Givenanunsortedarrayofintegers,findthenumberoflongestincreasingsubsequence.Example1:Input:[1,3,5,4,7]Output:2Explanatio
自定义分区我的K8409 Hadoop hdfs hadoop 大数据
通过简单例子了解partition分区类的重写方法分区是在MR的过程中进行的，属于Shuffle阶段但是在Job端不要忘记进行调用：job.setPartitionerClass(xxx.class)按照年龄分区：classAgePartitionerextendsPartitioner{@OverridepublicintgetPartition(MyComparablekey,NullWrit
【Golang】 Golang 的 GORM 库中的 Rows 函数不爱洗脚的小滕 golang 开发语言后端
文章目录前言一、Rows函数解释二、代码实现三、总结前言在使用Go语言进行数据库操作时，GORM（GoObject-RelationalMapping）库是一个常用的工具。它提供了一种简洁和强大的方式来处理数据库操作。本文将介绍GORM库中的Rows函数，这是一个用于执行原生SQL查询并返回结果的函数。一、Rows函数解释在GORM库中，Rows函数用于执行原生SQL查询并返回*sql.Rows结
leetcode021-合并两个有序链表陆阳226
问题描述将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。示例：输入：1->2->4,1->3->4输出：1->1->2->3->4->4解答递归法：每一层减去一个较小的节点，直到某个链表为null递归结束。publicstaticListNodesolution(ListNodel1,ListNodel2){if(l1==null){returnl2;}
tcp线程进程多并发 @莫福瑞算法
tcp线程多并发#include#defineSERPORT8888#defineSERIP"192.168.0.118"#defineBACKLOG20typedefstruct{intnewfd;structsockaddr_incin;}BMH;void*fun1(void*sss){intnewfd=accept((BMH*)sss)->newfd;structsockaddr_incin
Ubuntu Juju 与 Ansible的区别 xidianjiapei001 #Kubernetes ubuntu ansible linux 云原生 Juju
JujuandAnsiblearebothpowerfultoolsusedformanagingandorchestratingITinfrastructureandapplications,buttheyhavedifferentapproachesandusecases.Here’sabreakdownofthekeydifferencesbetweenthem:1.ConceptualFo
每日一题《leetcode--LCR 022.环形链表||》 Peace & Love487 题目分享 leetcode 链表算法笔记数据结构
https://leetcode.cn/problems/c32eOV/我们使用两个指针，fast与slow。它们起始都位于链表的头部。随后slow指针每次向后移动一个位置，而fast指针向后移动两个位置。如果链表中存在环，则fast指针最终将再次与slow指针在环中相遇。structListNode*detectCycle(structListNode*head){structListNode*
华南农业大学C语言oj第八章黑兔子撒 C语言 C语言华南农业大学编程程序
18058一年的第几天时间限制:1000MS内存限制:65535K提交次数:0通过次数:0题型:填空题语言:G++;GCC;VCDescription定义一个结构体类型表示日期类型（包括年、月、日）。程序中定义一个日期类型的变量，输入该日期的年、月、日，计算并输出该日期是一年的第几天。#include struct DATE { _______________________ }; int da
MySQl篇（SQL - 基本介绍）（持续更新迭代） wclass-zhengge mysql sql 数据库
目录一、简介二、SQL方言（分页查询为例）1.简介2.SQL方言大比拼2.1.Oracle2.1.1.使用ROWNUM实现分页查询2.1.2.使用ROW_NUMBER()实现分页查询2.2.MySQL2.3.PostgreSQL三、语法规范四、注释五、MySQL脚本中的标点符号一、简介1、SQL是结构化查询语言（StructureQueryLanguage），专门用来操作/访问关系型数据库的通用语
跟着黑马学mysql（5）小杜不吃糖 mysql 数据库
17.DQL-聚合函数DQL-聚合函数介绍将一列数据作为一个整体，进行纵向计算。常见聚合函数函数功能count统计数量max最大值min最小值avg平均值sum求和语法SELECT聚合函数(字段列表)FROM表名;注意：所有的null值不参与聚合函数的运算18.DQL-分组查询语法SELECT字段列表FROM表名[WHERE条件]GROUPBY分组字段名[HAVING分组后的过滤条件];where
Spring4.1新特性——Spring MVC增强 jinnianshilongnian spring 4.1
目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
mysql 性能查询优化 annan211 java sql 优化 mysql 应用服务器
1 时间到底花在哪了？ mysql在执行查询的时候需要执行一系列的子任务，这些子任务包含了整个查询周期最重要的阶段，这其中包含了大量为了检索数据列到存储引擎的调用以及调用后的数据处理，包括排序、分组等。在完成这些任务的时候，查询需要在不同的地方花费时间，包括网络、cpu计算、生成统计信息和执行计划、锁等待等。尤其是向底层存储引擎检索数据的调用操作。这些调用需要在内存操
windows系统配置 cherishLC windows
删除Hiberfil.sys ：使用命令powercfg -h off 关闭休眠功能即可： http://jingyan.baidu.com/article/f3ad7d0fc0992e09c2345b51.html 类似的还有pagefile.sys msconfig 配置启动项 shutdown 定时关机 ipconfig 查看网络配置 ipconfig /flushdns
人体的排毒时间 Array_06 工作
======================== || 人体的排毒时间是什么时候？|| ======================== 转载于： http://zhidao.baidu.com/link?url=ibaGlicVslAQhVdWWVevU4TMjhiKaNBWCpZ1NS6igCQ78EkNJZFsEjCjl3T5EdXU9SaPg04bh8MbY1bR
ZooKeeper cugfy zookeeper
Zookeeper是一个高性能，分布式的，开源分布式应用协调服务。它提供了简单原始的功能，分布式应用可以基于它实现更高级的服务，比如同步，配置管理，集群管理，名空间。它被设计为易于编程，使用文件系统目录树作为数据模型。服务端跑在java上，提供java和C的客户端API。 Zookeeper是Google的Chubby一个开源的实现，是高有效和可靠的协同工作系统，Zookeeper能够用来lea
网络爬虫的乱码处理随意而生爬虫网络
下边简单总结下关于网络爬虫的乱码处理。注意，这里不仅是中文乱码，还包括一些如日文、韩文、俄文、藏文之类的乱码处理，因为他们的解决方式是一致的，故在此统一说明。网络爬虫，有两种选择，一是选择nutch、hetriex，二是自写爬虫，两者在处理乱码时，原理是一致的，但前者处理乱码时，要看懂源码后进行修改才可以，所以要废劲一些；而后者更自由方便，可以在编码处理
Xcode常用快捷键张亚雄 xcode
一、总结的常用命令：隐藏xcode command+h 退出xcode command+q 关闭窗口 command+w 关闭所有窗口 command+option+w 关闭当前
mongoDB索引操作 adminjun mongodb 索引
一、索引基础： MongoDB的索引几乎与传统的关系型数据库一模一样，这其中也包括一些基本的优化技巧。下面是创建索引的命令： > db.test.ensureIndex({"username":1}) 可以通过下面的名称查看索引是否已经成功建立： &nbs
成都软件园实习那些话 aijuans 成都软件园实习
无聊之中，翻了一下日志，发现上一篇经历是很久以前的事了，悔过~~ 　　断断续续离开了学校快一年了，习惯了那里一天天的幼稚、成长的环境，到这里有点与世隔绝的感觉。不过还好，那是刚到这里时的想法，现在感觉在这挺好，不管怎么样，最要感谢的还是老师能给这么好的一次催化成长的机会，在这里确实看到了好多好多能想到或想不到的东西。　　都说在外面和学校相比最明显的差距就是与人相处比较困难，因为在外面每个人都
Linux下FTP服务器安装及配置 ayaoxinchao linux FTP服务器 vsftp
检测是否安装了FTP [root@localhost ~]# rpm -q vsftpd 如果未安装：package vsftpd is not installed 安装了则显示：vsftpd-2.0.5-28.el5累死的版本信息安装FTP 运行yum install vsftpd命令，如[root@localhost ~]# yum install vsf
使用mongo-java-driver获取文档id和查找文档 BigBird2012 driver
注：本文所有代码都使用的mongo-java-driver实现。在MongoDB中，一个集合（collection）在概念上就类似我们SQL数据库中的表（Table），这个集合包含了一系列文档（document）。一个DBObject对象表示我们想添加到集合（collection）中的一个文档（document），MongoDB会自动为我们创建的每个文档添加一个id，这个id在
JSONObject以及json串 bijian1013 json JSONObject
一.JAR包简介要使程序可以运行必须引入JSON-lib包，JSON-lib包同时依赖于以下的JAR包： 1.commons-lang-2.0.jar 2.commons-beanutils-1.7.0.jar 3.commons-collections-3.1.jar &n
[Zookeeper学习笔记之三]Zookeeper实例创建和会话建立的异步特性 bit1129 zookeeper
为了说明问题，看个简单的代码， import org.apache.zookeeper.*; import java.io.IOException; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ThreadLocal
【Scala十二】Scala核心六：Trait bit1129 scala
Traits are a fundamental unit of code reuse in Scala. A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each c
weblogic version 10.3破解 ronin47 weblogic
版本：WebLogic Server 10.3 说明：%DOMAIN_HOME%：指WebLogic Server 域(Domain）目录例如我的做测试的域的根目录 DOMAIN_HOME=D:/Weblogic/Middleware/user_projects/domains/base_domain 1.为了保证操作安全，备份%DOMAIN_HOME%/security/Defa
求第n个斐波那契数 BrokenDreams
今天看到群友发的一个问题：写一个小程序打印第n个斐波那契数。自己试了下，搞了好久。。。基础要加强了。 &nbs
读《研磨设计模式》-代码笔记-访问者模式-Visitor bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; interface IVisitor { //第二次分派，Visitor调用Element void visitConcret
MatConvNet的excise 3改为网络配置文件形式 cherishLC matlab
MatConvNet为vlFeat作者写的matlab下的卷积神经网络工具包，可以使用GPU。主页： http://www.vlfeat.org/matconvnet/ 教程： http://www.robots.ox.ac.uk/~vgg/practicals/cnn/index.html 注意：需要下载新版的MatConvNet替换掉教程中工具包中的matconvnet： http
ZK Timeout再讨论 chenchao051 zookeeper timeout hbase
http://crazyjvm.iteye.com/blog/1693757 文中提到相关超时问题，但是又出现了一个问题，我把min和max都设置成了180000，但是仍然出现了以下的异常信息： Client session timed out, have not heard from server in 154339ms for sessionid 0x13a3f7732340003
CASE WHEN 用法介绍 daizj sql group by case when
CASE WHEN 用法介绍 1. CASE WHEN 表达式有两种形式 --简单Case函数 CASE sex WHEN '1' THEN '男' WHEN '2' THEN '女' ELSE '其他' END --Case搜索函数 CASE WHEN sex = '1' THEN
PHP技巧汇总:提高PHP性能的53个技巧 dcj3sjt126com PHP
PHP技巧汇总:提高PHP性能的53个技巧　　用单引号代替双引号来包含字符串，这样做会更快一些。因为PHP会在双引号包围的字符串中搜寻变量，　　单引号则不会，注意：只有echo能这么做，它是一种可以把多个字符串当作参数的函数译注：　　PHP手册中说echo是语言结构，不是真正的函数，故把函数加上了双引号)。　　1、如果能将类的方法定义成static，就尽量定义成static，它的速度会提升将近4倍
Yii框架中CGridView的使用方法以及详细示例 dcj3sjt126com yii
CGridView显示一个数据项的列表中的一个表。表中的每一行代表一个数据项的数据,和一个列通常代表一个属性的物品(一些列可能对应于复杂的表达式的属性或静态文本)。　　CGridView既支持排序和分页的数据项。排序和分页可以在AJAX模式或正常的页面请求。使用CGridView的一个好处是,当用户浏览器禁用JavaScript,排序和分页自动退化普通页面请求和仍然正常运行。实例代码如下：
Maven项目打包成可执行Jar文件 dyy_gusi assembly
Maven项目打包成可执行Jar文件在使用Maven完成项目以后，如果是需要打包成可执行的Jar文件，我们通过eclipse的导出很麻烦，还得指定入口文件的位置，还得说明依赖的jar包，既然都使用Maven了，很重要的一个目的就是让这些繁琐的操作简单。我们可以通过插件完成这项工作，使用assembly插件。具体使用方式如下： 1、在项目中加入插件的依赖： <plugin>
php常见错误 geeksun PHP
1. kevent() reported that connect() failed (61: Connection refused) while connecting to upstream, client: 127.0.0.1, server: localhost, request: "GET / HTTP/1.1", upstream: "fastc
修改linux的用户名 hongtoushizi linux change password
Change Linux Username 更改Linux用户名，需要修改4个系统的文件： /etc/passwd /etc/shadow /etc/group /etc/gshadow 古老/传统的方法是使用vi去直接修改，但是这有安全隐患（具体可自己搜一下），所以后来改成使用这些命令去代替： vipw vipw -s vigr vigr -s 具体的操作顺
第五章常用Lua开发库1-redis、mysql、http客户端 jinnianshilongnian nginx lua
对于开发来说需要有好的生态开发库来辅助我们快速开发，而Lua中也有大多数我们需要的第三方开发库如Redis、Memcached、Mysql、Http客户端、JSON、模板引擎等。一些常见的Lua库可以在github上搜索，https://github.com/search?utf8=%E2%9C%93&q=lua+resty。 Redis客户端 lua-resty-r
zkClient 监控机制实现 liyonghui160com zkClient 监控机制实现
直接使用zk的api实现业务功能比较繁琐。因为要处理session loss，session expire等异常，在发生这些异常后进行重连。又因为ZK的watcher是一次性的，如果要基于wather实现发布/订阅模式，还要自己包装一下，将一次性订阅包装成持久订阅。另外如果要使用抽象级别更高的功能，比如分布式锁，leader选举
在Mysql 众多表中查找一个表名或者字段名的 SQL 语句 pda158 mysql
在Mysql 众多表中查找一个表名或者字段名的 SQL 语句：　　方法一：SELECT table_name, column_name from information_schema.columns WHERE column_name LIKE 'Name'; 　　方法二：SELECT column_name from information_schema.colum
程序员对英语的依赖 Smile.zeng 英语程序猿
1、程序员最基本的技能，至少要能写得出代码，当我们还在为建立类的时候思考用什么单词发牢骚的时候，英语与别人的差距就直接表现出来咯。 2、程序员最起码能认识开发工具里的英语单词，不然怎么知道使用这些开发工具。 3、进阶一点，就是能读懂别人的代码，有利于我们学习人家的思路和技术。 4、写的程序至少能有一定的可读性，至少要人别人能懂吧... 以上一些问题，充分说明了英语对程序猿的重要性。骚年
Oracle学习笔记(8) 使用PLSQL编写触发器 vipbooks oracle sql 编程活动 Access
时间过得真快啊，转眼就到了Oracle学习笔记的最后个章节了，通过前面七章的学习大家应该对Oracle编程有了一定了了解了吧，这东东如果一段时间不用很快就会忘记了，所以我会把自己学习过的东西做好详细的笔记，用到的时候可以随时查找，马上上手！希望这些笔记能对大家有些帮助！这是第八章的学习笔记，学习完第七章的子程序和包之后