MIXERLINE_LINEF_DISCONNECTED = &H8000

        public bool fConnected;

        internal bool fReturnConnected;

     DISCONNECTED    = 0x00008000u,

Without the Structlayout the WNetAddConnection2 does not work !!!

     public int dwConnectionDuration;

     Public dwConnectionDuration As Integer

See docs for RasGetConnectionStatistics

        //  Connection/Session counts

        public int Reconnects;

        public int CoreConnects;

        public int Lanman20Connects;

        public int Lanman21Connects;

        public int LanmanNtConnects;

        public int ServerDisconnects;

    public bool AoAcConnectivitySupported;  // Ignore if earlier than Windows 10 (10.0.10240.0)

    TCP_TABLE_BASIC_CONNECTIONS,

    TCP_TABLE_OWNER_PID_CONNECTIONS,

    TCP_TABLE_OWNER_MODULE_CONNECTIONS,

    TCP_TABLE_BASIC_CONNECTIONS

    TCP_TABLE_OWNER_PID_CONNECTIONS

    TCP_TABLE_OWNER_MODULE_CONNECTIONS

  TCP_TABLE_CLASS = (TCP_TABLE_BASIC_LISTENER,TCP_TABLE_BASIC_CONNECTIONS,

            TCP_TABLE_OWNER_PID_CONNECTIONS,TCP_TABLE_OWNER_PID_ALL,

            TCP_TABLE_OWNER_MODULE_LISTENER,TCP_TABLE_OWNER_MODULE_CONNECTIONS,

TCP_TABLE_BASIC_CONNECTIONS

A MIB_TCPTABLE table that contains all connected TCP endpoints on the machine is returned to the caller.

TCP_TABLE_OWNER_PID_CONNECTIONS

A MIB_TCPTABLE_OWNER_PID or MIB_TCP6TABLE_OWNER_PID that all connected TCP endpoints on the machine is returned to the caller.

TCP_TABLE_OWNER_MODULE_CONNECTIONS

A MIB_TCPTABLE_OWNER_MODULE or MIB_TCP6TABLE_OWNER_MODULE that contains all connected TCP endpoints on the machine is returned to the caller.

   public int ConnectionIndex;

   ULONG ConnectionIndex;

   Request.ConnectionIndex = PortPortNumber;

   if (DeviceIoControl(h, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, ptrRequest, nBytes, ptrRequest, nBytes, out nBytesReturned, IntPtr.Zero))

Is often used as a type inside a USB_NODE_CONNECTION_INFORMATION_EX structure, hence the need for the "Pack=1"

struct USB_NODE_CONNECTION_DRIVERKEY_NAME

   public int ConnectionIndex;

Structure USB_NODE_CONNECTION_DRIVERKEY_NAME

Identical to the USB_NODE_CONNECTION_NAME structure

typedef struct _USB_NODE_CONNECTION_DRIVERKEY_NAME {

   ULONG  ConnectionIndex;

} USB_NODE_CONNECTION_DRIVERKEY_NAME, *PUSB_NODE_CONNECTION_DRIVERKEY_NAME;

   USB_NODE_CONNECTION_DRIVERKEY_NAME DriverKey = new USB_NODE_CONNECTION_DRIVERKEY_NAME();

   DriverKey.ConnectionIndex = PortPortNumber;

   if (DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME, ptrDriverKey, nBytes, ptrDriverKey, nBytes, out nBytesReturned, IntPtr.Zero))

     DriverKey = (USB_NODE_CONNECTION_DRIVERKEY_NAME)Marshal.PtrToStructure(ptrDriverKey, typeof(USB_NODE_CONNECTION_DRIVERKEY_NAME));

struct USB_NODE_CONNECTION_INFORMATION_EX

   public int ConnectionIndex;

   public int ConnectionStatus;

Structure USB_NODE_CONNECTION_INFORMATION_EX

typedef struct _USB_NODE_CONNECTION_INFORMATION_EX {

   ULONG  ConnectionIndex;

   USB_CONNECTION_STATUS  ConnectionStatus;

} USB_NODE_CONNECTION_INFORMATION_EX, *PUSB_NODE_CONNECTION_INFORMATION_EX;

   int nBytes = Marshal.SizeOf(typeof(USB_NODE_CONNECTION_INFORMATION_EX));

   IntPtr ptrNodeConnection = Marshal.AllocHGlobal(nBytes);

     USB_NODE_CONNECTION_INFORMATION_EX NodeConnection = new USB_NODE_CONNECTION_INFORMATION_EX();

     NodeConnection.ConnectionIndex = i;

     Marshal.StructureToPtr(NodeConnection, ptrNodeConnection, true);

     if (DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, ptrNodeConnection, nBytes, ptrNodeConnection, nBytes, out nBytesReturned, IntPtr.Zero))

       NodeConnection = (USB_NODE_CONNECTION_INFORMATION_EX)Marshal.PtrToStructure(ptrNodeConnection, typeof(USB_NODE_CONNECTION_INFORMATION_EX));

   Marshal.FreeHGlobal(ptrNodeConnection);

   USB_NODE_CONNECTION_INFORMATION_EX connection = new USB_NODE_CONNECTION_INFORMATION_EX();

   connection.ConnectionIndex = i;

   size = Marshal.SizeOf(typeof(USB_NODE_CONNECTION_INFORMATION_EX)) + 32 * Marshal.SizeOf(typeof(USB_PIPE_INFO)); // Assuming 32 should be enough, you can make this larger

   IntPtr ptr_connection = Marshal.AllocHGlobal(size);

   Marshal.StructureToPtr(connection, ptr_connection, true);

   if (DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, ptr_connection, size, ptr_connection, size, out bytes_returned, IntPtr.Zero))

     connection = (USB_NODE_CONNECTION_INFORMATION_EX)Marshal.PtrToStructure(ptr_connection, typeof(USB_NODE_CONNECTION_INFORMATION_EX));

     if (bytes_returned != Marshal.SizeOf(typeof(USB_NODE_CONNECTION_INFORMATION_EX)))

       int num = (bytes_returned - Marshal.SizeOf(typeof(USB_NODE_CONNECTION_INFORMATION_EX))) / Marshal.SizeOf(typeof(USB_PIPE_INFO));

     IntPtr ptr_pipeinfo = new IntPtr((byte*)ptr_connection.ToPointer()

                       + Marshal.SizeOf(typeof(USB_NODE_CONNECTION_INFORMATION_EX))

   Marshal.FreeHGlobal(ptr_connection);

struct USB_NODE_CONNECTION_NAME

   public int ConnectionIndex;

Structure USB_NODE_CONNECTION_NAME

typedef struct _USB_NODE_CONNECTION_NAME {

   ULONG  ConnectionIndex;

} USB_NODE_CONNECTION_NAME, *PUSB_NODE_CONNECTION_NAME;

   USB_NODE_CONNECTION_NAME NodeName = new USB_NODE_CONNECTION_NAME();

   NodeName.ConnectionIndex = PortPortNumber;

   if (DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_NAME, ptrNodeName, nBytes, ptrNodeName, nBytes, out nBytesReturned, IntPtr.Zero))

     NodeName = (USB_NODE_CONNECTION_NAME)Marshal.PtrToStructure(ptrNodeName, typeof(USB_NODE_CONNECTION_NAME));

You don't use an IOCTL call directly with a USB_STRING_DESCRIPTOR structure. Instead you use a USB_DESCRIPTOR_REQUEST "request packet" with IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION. The USB_STRING_DESCRIPTOR structure is returned at the very end of the request packet. The whole idea of "writing off the edge" of a structure is counter to the way C#/VB.Net was designed to work, so you'll have to make sure to allocate sufficient amount of memory to handle both the "request packet" and the USB_STRING_DESCRIPTOR structure.

   Request.ConnectionIndex = PortPortNumber;

   if (DeviceIoControl(h, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, ptrRequest, nBytes, ptrRequest, nBytes, out nBytesReturned, IntPtr.Zero))

        Byte[] ConnectState;

        System.Runtime.InteropServices.ComTypes.FILETIME ConnectTime;

        System.Runtime.InteropServices.ComTypes.FILETIME DisconnectTime;

        public struct WLAN_CONNECTION_ATTRIBUTES

        /// WLAN_CONNECTION_MODE->_WLAN_CONNECTION_MODE

        public WLAN_CONNECTION_MODE wlanConnectionMode;

     Public Structure WLAN_CONNECTION_ATTRIBUTES

     ''' WLAN_CONNECTION_MODE->_WLAN_CONNECTION_MODE

     Public wlanConnectionMode As WLAN_CONNECTION_MODE

WLAN_CONNECTION_MODE

public struct WLAN_CONNECTION_PARAMETERS

        public WLAN_CONNECTION_MODE wlanConnectionMode;

Structure WLAN_CONNECTION_PARAMETERS

WLAN_CONNECTION_MODE

The rationale behind the change in the history for this is because is that he/she wanted to "unmarshal". However, in functions like WlanConnect(), it is used as an "input". So, it needs to be marshaled. Then I believe they should be IntPtr.

public struct WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS

Structure WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS

        wlan_notification_acm_connection_start,

        wlan_notification_acm_connection_complete,

        wlan_notification_acm_connection_attempt_fail,

        wlan_notification_acm_disconnecting,

        wlan_notification_acm_disconnected,

        wlan_notification_acm_connection_start

        wlan_notification_acm_connection_complete

        wlan_notification_acm_connection_attempt_fail

        wlan_notification_acm_disconnecting

        wlan_notification_acm_disconnected

        wlan_notification_msm_connected,

        wlan_notification_msm_disconnected,

        public WTS_CONNECTSTATE_CLASS State;

static extern UInt32 midiConnect(IntPtr hMidi, IntPtr hmo, IntPtr pReserved);

Declare Function midiConnect Lib "winmm.dll" (TODO) As TODO

UInt32 Connect(IntPtr midiInputHandle, IntPtr midiOutputHandle)

     return midiConnect(midiInputHandle, midiOutputHandle, IntPtr.Zero);

static extern UInt32 midiDisconnect(IntPtr hMidi, IntPtr hmo, IntPtr pReserved);

Declare Function midiDisconnect Lib "winmm.dll" (TODO) As TODO

UInt32 Disconnect(IntPtr midiInputHandle, IntPtr midiOutputHandle)

     return midiDisconnect(midiInputHandle, midiOutputHandle, IntPtr.Zero);

    internal static extern bool AddPrinterConnection(String pszBuffer);

Declare Function AddPrinterConnection Lib "winspool.dll" (TODO) As TODO

    internal static extern bool AddPrinterConnection(String pszBuffer);

Declare Function AddPrinterConnection Lib "winspool.dll" (TODO) As TODO

internal static extern bool DeletePrinterConnection(String pName);

Declare Function DeletePrinterConnection Lib "winspool.dll" (TODO) As TODO

result = DeletePrinterConnection("\\\\Server_Name\\Printer_Share");

static extern bool FtpCommand(IntPtr hConnect, bool fExpectResponse, [MarshalAs(UnmanagedType.U4)] int dwFlags, string lpszCommand, IntPtr dwContext, ref IntPtr phFtpCommand);

Private Shared Function FtpCommand(ByVal hConnect As IntPtr, ByVal fExpectResponse As Boolean, <MarshalAs(UnmanagedType.U4)> ByVal dwFlags As Integer, ByVal lpszCommand As String, ByVal dwContext As IntPtr, ByRef phFtpCommand As IntPtr) As Boolean

    vAttributes &= "Trusted_Connection=Yes" & Convert.ToChar(0)

This function persists a system data source with the provided name and connection string. Remember to add your own error checking mechanisms.

    // Connection string for SQLConfigDataSource must be null-

This function persists a system data source with the provided name and connection string. Remember to add your own error checking mechanisms.

    // Connection string for SQLConfigDataSource must be null-

static extern void CoDisconnectObject(

    Connect =   2,

    Connect =   2,

static extern bool BluetoothEnableIncomingConnections(IntPtr hRadio,bool fEnabled);

    Private Shared Function BluetoothEnableIncomingConnections( _

        Public returnConnected As Integer

        Public connected As Boolean

static extern bool BluetoothIsConnectable(IntPtr hRadio);

    Private Shared Function BluetoothIsConnectable(ByVal hRadio As IntPtr) As Integer

bool ret = RAW.RasDialDlg(IntPtr.Zero, "Some Connection Name", IntPtr.Zero, ref info);

bool ret = RAW.RasDialDlg(IntPtr.Zero, "Some Connection Name", IntPtr.Zero, ref info);

public static extern int RasEnumConnections(

    [Out] out int connections);

RAW.RASCONN[] connections = new RAW.RASCONN[1];

connections[0].dwSize = Marshal.SizeOf(typeof(RAW.RASCONN));

int connectionsCount = 0;

int nRet = RAW.RasEnumConnections(connections, ref cb, out connectionsCount);

if (connectionsCount == 0)

connections = new RAW.RASCONN[connectionsCount];

for (int i = 0; i < connections.Length; i++)

    connections[i].dwSize = Marshal.SizeOf(typeof(RAW.RASCONN));

nRet = RAW.RasEnumConnections(connections, ref cb, out connectionsCount);

int cb = 0, connectionCount;

if (RAW.RasEnumConnections(null, ref cb, out connectionCount) == RAW.ERROR_BUFFER_TOO_SMALL)

    if (connectionCount == 0) return;

    if (RasApi.RasEnumConnections(buffer, ref cb, out conns) == RAW.ERROR_SUCCESS)

static extern uint RasGetConnectionStatistics(IntPtr hRasConn, ref RAS_STATS lpStatistics);

Public Shared Function RasGetConnectionStatistics( _

uint retVal = RasGetConnectionStatistics(rasConnectionHandle, ref statistics);

public static extern int RasGetConnectStatus(int hrasconn, ref RASCONNSTATUS lprasconnstatus);

Declare Function RasGetConnectStatus Lib "rasapi32.dll" (TODO) As TODO

/// Changes the connection information for an entry in the phone book or creates a new phone-book entry.

/// <param name="lpRasEntry">Pointer to the RASENTRY structure that specifies the connection data to associate with the phone-book entry.</param>

          public int       dwIdleDisconnectSeconds;

        ReconnectIfDropped = 0x100,

/// Create or modify network connection.

/// <param name="connectionName">Name of the network connection to create or modify.</param>

/// <param name="rasEntryStructure">RASENTRY structure containing connection settings.</param>

public static RasError SetEntryProperties(string connectionName, RASENTRY rasEntryStructure)

     return (RasError)RasSetEntryProperties(null, connectionName, ref rasEntryStructure, Marshal.SizeOf(rasEntryStructure), IntPtr.Zero, 0);

        public const int ISC_REQ_CONNECTION     =    0x00000800;

        public const int STANDARD_CONTEXT_ATTRIBUTES = ISC_REQ_CONFIDENTIALITY | ISC_REQ_REPLAY_DETECT | ISC_REQ_SEQUENCE_DETECT | ISC_REQ_CONNECTION;

    /// <param name="LsaHandle">[in] Handle obtained from a previous call to LsaRegisterLogonProcess or LsaConnectUntrusted.</param>

public static extern WinStatusCodes LsaConnectUntrusted([Out] out IntPtr LsaHandle);

Declare Function LsaConnectUntrusted Lib "secur32.dll" (TODO) As TODO

    NewCredentials,     // Allows the caller to clone its current token and specify new credentials for outbound connections.

                public static extern WinStatusCodes LsaConnectUntrusted([Out] out IntPtr LsaHandle);

                        OSCalls.WinStatusCodes status = OSCalls.LsaConnectUntrusted(out lsaHandle);