MPIO_PASS_THROUGH_PATH_DIRECT

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SCSI_PASS_THROUGH_DIRECT
{
    public ushort Length;
    public byte ScsiStatus;
    public byte PathId;
    public byte TargetId;
    public byte Lun;
    public byte CdbLength;
    public byte SenseInfoLength;
    public byte DataIn;
    public uint DataTransferLength;
    public uint TimeOutValue;
    public IntPtr DataBuffer;
    public uint SenseInfoOffset;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public byte[] Cdb;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MPIO_PASS_THROUGH_PATH_DIRECT
{
    public SCSI_PASS_THROUGH_DIRECT PassThrough;
    public uint Version;
    public ushort Length;
    public byte Flags;
    public byte PortNumber;
    public ulong MpioPathId;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SCSI_PASS_THROUGH_DIRECT
    Public Length As UShort
    Public ScsiStatus As Byte
    Public PathId As Byte
    Public TargetId As Byte
    Public Lun As Byte
    Public CdbLength As Byte
    Public SenseInfoLength As Byte
    Public DataIn As Byte
    Public DataTransferLength As UInteger
    Public TimeOutValue As UInteger
    Public DataBuffer As IntPtr
    Public SenseInfoOffset As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=16)> Public Cdb() As Byte
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MPIO_PASS_THROUGH_PATH_DIRECT
    Public PassThrough As SCSI_PASS_THROUGH_DIRECT
    Public Version As UInteger
    Public Length As UShort
    Public Flags As Byte
    Public PortNumber As Byte
    Public MpioPathId As ULong
End Structure

import ctypes
from ctypes import wintypes

class SCSI_PASS_THROUGH_DIRECT(ctypes.Structure):
    _fields_ = [
        ("Length", ctypes.c_ushort),
        ("ScsiStatus", ctypes.c_ubyte),
        ("PathId", ctypes.c_ubyte),
        ("TargetId", ctypes.c_ubyte),
        ("Lun", ctypes.c_ubyte),
        ("CdbLength", ctypes.c_ubyte),
        ("SenseInfoLength", ctypes.c_ubyte),
        ("DataIn", ctypes.c_ubyte),
        ("DataTransferLength", wintypes.DWORD),
        ("TimeOutValue", wintypes.DWORD),
        ("DataBuffer", ctypes.c_void_p),
        ("SenseInfoOffset", wintypes.DWORD),
        ("Cdb", ctypes.c_ubyte * 16),
    ]

class MPIO_PASS_THROUGH_PATH_DIRECT(ctypes.Structure):
    _fields_ = [
        ("PassThrough", SCSI_PASS_THROUGH_DIRECT),
        ("Version", wintypes.DWORD),
        ("Length", ctypes.c_ushort),
        ("Flags", ctypes.c_ubyte),
        ("PortNumber", ctypes.c_ubyte),
        ("MpioPathId", ctypes.c_ulonglong),
    ]

#[repr(C)]
pub struct SCSI_PASS_THROUGH_DIRECT {
    pub Length: u16,
    pub ScsiStatus: u8,
    pub PathId: u8,
    pub TargetId: u8,
    pub Lun: u8,
    pub CdbLength: u8,
    pub SenseInfoLength: u8,
    pub DataIn: u8,
    pub DataTransferLength: u32,
    pub TimeOutValue: u32,
    pub DataBuffer: *mut core::ffi::c_void,
    pub SenseInfoOffset: u32,
    pub Cdb: [u8; 16],
}

#[repr(C)]
pub struct MPIO_PASS_THROUGH_PATH_DIRECT {
    pub PassThrough: SCSI_PASS_THROUGH_DIRECT,
    pub Version: u32,
    pub Length: u16,
    pub Flags: u8,
    pub PortNumber: u8,
    pub MpioPathId: u64,
}

import "golang.org/x/sys/windows"

type SCSI_PASS_THROUGH_DIRECT struct {
	Length uint16
	ScsiStatus byte
	PathId byte
	TargetId byte
	Lun byte
	CdbLength byte
	SenseInfoLength byte
	DataIn byte
	DataTransferLength uint32
	TimeOutValue uint32
	DataBuffer uintptr
	SenseInfoOffset uint32
	Cdb [16]byte
}

type MPIO_PASS_THROUGH_PATH_DIRECT struct {
	PassThrough SCSI_PASS_THROUGH_DIRECT
	Version uint32
	Length uint16
	Flags byte
	PortNumber byte
	MpioPathId uint64
}

type
  SCSI_PASS_THROUGH_DIRECT = record
    Length: Word;
    ScsiStatus: Byte;
    PathId: Byte;
    TargetId: Byte;
    Lun: Byte;
    CdbLength: Byte;
    SenseInfoLength: Byte;
    DataIn: Byte;
    DataTransferLength: DWORD;
    TimeOutValue: DWORD;
    DataBuffer: Pointer;
    SenseInfoOffset: DWORD;
    Cdb: array[0..15] of Byte;
  end;

  MPIO_PASS_THROUGH_PATH_DIRECT = record
    PassThrough: SCSI_PASS_THROUGH_DIRECT;
    Version: DWORD;
    Length: Word;
    Flags: Byte;
    PortNumber: Byte;
    MpioPathId: UInt64;
  end;

const SCSI_PASS_THROUGH_DIRECT = extern struct {
    Length: u16,
    ScsiStatus: u8,
    PathId: u8,
    TargetId: u8,
    Lun: u8,
    CdbLength: u8,
    SenseInfoLength: u8,
    DataIn: u8,
    DataTransferLength: u32,
    TimeOutValue: u32,
    DataBuffer: ?*anyopaque,
    SenseInfoOffset: u32,
    Cdb: [16]u8,
};

const MPIO_PASS_THROUGH_PATH_DIRECT = extern struct {
    PassThrough: SCSI_PASS_THROUGH_DIRECT,
    Version: u32,
    Length: u16,
    Flags: u8,
    PortNumber: u8,
    MpioPathId: u64,
};

type
  SCSI_PASS_THROUGH_DIRECT {.bycopy.} = object
    Length: uint16
    ScsiStatus: uint8
    PathId: uint8
    TargetId: uint8
    Lun: uint8
    CdbLength: uint8
    SenseInfoLength: uint8
    DataIn: uint8
    DataTransferLength: uint32
    TimeOutValue: uint32
    DataBuffer: pointer
    SenseInfoOffset: uint32
    Cdb: array[16, uint8]

  MPIO_PASS_THROUGH_PATH_DIRECT {.bycopy.} = object
    PassThrough: SCSI_PASS_THROUGH_DIRECT
    Version: uint32
    Length: uint16
    Flags: uint8
    PortNumber: uint8
    MpioPathId: uint64

struct SCSI_PASS_THROUGH_DIRECT
{
    ushort Length;
    ubyte ScsiStatus;
    ubyte PathId;
    ubyte TargetId;
    ubyte Lun;
    ubyte CdbLength;
    ubyte SenseInfoLength;
    ubyte DataIn;
    uint DataTransferLength;
    uint TimeOutValue;
    void* DataBuffer;
    uint SenseInfoOffset;
    ubyte[16] Cdb;
}

struct MPIO_PASS_THROUGH_PATH_DIRECT
{
    SCSI_PASS_THROUGH_DIRECT PassThrough;
    uint Version;
    ushort Length;
    ubyte Flags;
    ubyte PortNumber;
    ulong MpioPathId;
}