main.c

winNT技术操作系统,国外开放的原代码和LIUX一样

      }
    else
      {
	Status = TdiBuildNullConnectionInfo
	    ( &ConnInfo, FCB->RemoteAddress->Address[0].AddressType );

	if( !NT_SUCCESS(Status) || !ConnInfo )
	    return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
					   Irp, 0, NULL, TRUE );
      }

    if( DisReq->DisconnectType & AFD_DISCONNECT_SEND )
	Flags |= TDI_DISCONNECT_RELEASE;
    if( DisReq->DisconnectType & AFD_DISCONNECT_RECV ||
	DisReq->DisconnectType & AFD_DISCONNECT_ABORT )
	Flags |= TDI_DISCONNECT_ABORT;

    Status = TdiDisconnect( FCB->Connection.Object,
			    &DisReq->Timeout,
			    Flags,
			    &Iosb,
			    NULL,
			    NULL,
			    FCB->AddressFrom,
			    ConnInfo);

    ExFreePool( ConnInfo );

    return UnlockAndMaybeComplete( FCB, Status, Irp, 0, NULL, TRUE );
}

static NTSTATUS STDCALL
AfdDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS Status = STATUS_SUCCESS;
#ifdef DBG
    PFILE_OBJECT FileObject = IrpSp->FileObject;
#endif

    AFD_DbgPrint(MID_TRACE,("AfdDispatch: %d\n", IrpSp->MajorFunction));
    if( IrpSp->MajorFunction != IRP_MJ_CREATE) {
	AFD_DbgPrint(MID_TRACE,("FO %x, IrpSp->FO %x\n",
				FileObject, IrpSp->FileObject));
	ASSERT(FileObject == IrpSp->FileObject);
    }

    switch(IrpSp->MajorFunction)
    {
	/* opening and closing handles to the device */
    case IRP_MJ_CREATE:
	/* Mostly borrowed from the named pipe file system */
	return AfdCreateSocket(DeviceObject, Irp, IrpSp);

    case IRP_MJ_CLOSE:
	/* Ditto the borrowing */
	return AfdCloseSocket(DeviceObject, Irp, IrpSp);

    /* write data */
    case IRP_MJ_WRITE:
	return AfdConnectedSocketWriteData( DeviceObject, Irp, IrpSp, TRUE );

    /* read data */
    case IRP_MJ_READ:
	return AfdConnectedSocketReadData( DeviceObject, Irp, IrpSp, TRUE );

    case IRP_MJ_DEVICE_CONTROL:
    {
	switch( IrpSp->Parameters.DeviceIoControl.IoControlCode ) {
	case IOCTL_AFD_BIND:
	    return AfdBindSocket( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_CONNECT:
	    return AfdStreamSocketConnect( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_START_LISTEN:
	    return AfdListenSocket( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_RECV:
	    return AfdConnectedSocketReadData( DeviceObject, Irp, IrpSp,
					       FALSE );

	case IOCTL_AFD_SELECT:
	    return AfdSelect( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_EVENT_SELECT:
	    return AfdEventSelect( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_ENUM_NETWORK_EVENTS:
	    return AfdEnumEvents( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_RECV_DATAGRAM:
	    return AfdPacketSocketReadData( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_SEND:
	    return AfdConnectedSocketWriteData( DeviceObject, Irp, IrpSp,
						FALSE );

	case IOCTL_AFD_SEND_DATAGRAM:
	    return AfdPacketSocketWriteData( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_GET_INFO:
	    return AfdGetInfo( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_GET_CONTEXT:
	    return AfdGetContext( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_SET_CONTEXT:
	    return AfdSetContext( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_WAIT_FOR_LISTEN:
	    return AfdWaitForListen( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_ACCEPT:
	    return AfdAccept( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_DISCONNECT:
	    return AfdDisconnect( DeviceObject, Irp, IrpSp );

	case IOCTL_AFD_GET_SOCK_NAME:
	    return AfdGetSockOrPeerName( DeviceObject, Irp, IrpSp, TRUE );

        case IOCTL_AFD_GET_PEER_NAME:
            return AfdGetSockOrPeerName( DeviceObject, Irp, IrpSp, FALSE );

	case IOCTL_AFD_GET_TDI_HANDLES:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_TDI_HANDLES\n"));
	    break;

	case IOCTL_AFD_SET_INFO:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_INFO\n"));
	    break;

	case IOCTL_AFD_SET_CONNECT_DATA:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_CONNECT_DATA\n"));
	    break;

	case IOCTL_AFD_SET_CONNECT_OPTIONS:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_CONNECT_OPTIONS\n"));
	    break;

	case IOCTL_AFD_SET_DISCONNECT_DATA:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_DISCONNECT_DATA\n"));
	    break;

	case IOCTL_AFD_SET_DISCONNECT_OPTIONS:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_DISCONNECT_OPTIONS\n"));
	    break;

	case IOCTL_AFD_GET_CONNECT_DATA:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_CONNECT_DATA\n"));
	    break;

	case IOCTL_AFD_GET_CONNECT_OPTIONS:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_CONNECT_OPTIONS\n"));
	    break;

	case IOCTL_AFD_GET_DISCONNECT_DATA:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_DISCONNECT_DATA\n"));
	    break;

	case IOCTL_AFD_GET_DISCONNECT_OPTIONS:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_DISCONNECT_OPTIONS\n"));
	    break;

	case IOCTL_AFD_SET_CONNECT_DATA_SIZE:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_CONNECT_DATA_SIZE\n"));
	    break;

	case IOCTL_AFD_SET_CONNECT_OPTIONS_SIZE:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_CONNECT_OPTIONS_SIZE\n"));
	    break;

	case IOCTL_AFD_SET_DISCONNECT_DATA_SIZE:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_DISCONNECT_DATA_SIZE\n"));
	    break;

	case IOCTL_AFD_SET_DISCONNECT_OPTIONS_SIZE:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_SET_DISCONNECT_OPTIONS_SIZE\n"));
	    break;

	case IOCTL_AFD_DEFER_ACCEPT:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_DEFER_ACCEPT\n"));
	    break;

	case IOCTL_AFD_GET_PENDING_CONNECT_DATA:
	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_PENDING_CONNECT_DATA\n"));
	    break;

	default:
	    Status = STATUS_NOT_IMPLEMENTED;
	    Irp->IoStatus.Information = 0;
	    AFD_DbgPrint(MIN_TRACE, ("Unknown IOCTL (0x%x)\n",
				     IrpSp->Parameters.DeviceIoControl.
				     IoControlCode));
	    break;
	}
	break;
    }

/* unsupported operations */
    default:
    {
	Status = STATUS_NOT_IMPLEMENTED;
	AFD_DbgPrint(MIN_TRACE,
		     ("Irp: Unknown Major code was %x\n",
		      IrpSp->MajorFunction));
	break;
    }
    }

    AFD_DbgPrint(MID_TRACE, ("Returning %x\n", Status));
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    return (Status);
}

static VOID STDCALL
AfdUnload(PDRIVER_OBJECT DriverObject)
{
}

NTSTATUS STDCALL
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
    PDEVICE_OBJECT DeviceObject;
    UNICODE_STRING wstrDeviceName = RTL_CONSTANT_STRING(L"\\Device\\Afd");
    PAFD_DEVICE_EXTENSION DeviceExt;
    NTSTATUS Status;

    /* register driver routines */
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = AfdDispatch;
    DriverObject->MajorFunction[IRP_MJ_CREATE] = AfdDispatch;
    DriverObject->MajorFunction[IRP_MJ_WRITE] = AfdDispatch;
    DriverObject->MajorFunction[IRP_MJ_READ] = AfdDispatch;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = AfdDispatch;
    DriverObject->DriverUnload = AfdUnload;

    Status = IoCreateDevice
	( DriverObject,
	  sizeof(AFD_DEVICE_EXTENSION),
	  &wstrDeviceName,
	  FILE_DEVICE_NAMED_PIPE,
	  0,
	  FALSE,
	  &DeviceObject );

    /* failure */
    if(!NT_SUCCESS(Status))
    {
	return (Status);
    }

    DeviceExt = DeviceObject->DeviceExtension;
    KeInitializeSpinLock( &DeviceExt->Lock );
    InitializeListHead( &DeviceExt->Polls );

    AFD_DbgPrint(MID_TRACE,("Device created: object %x ext %x\n",
			    DeviceObject, DeviceExt));

    return (Status);
}

/* EOF */