NOTIFICATION_EVENT_RS232_DETECTED is also raised when connecting the device to USB.

    private static extern uint RasEnumConnections(

        [Out] out int connections);

public static RASCONN[] GetAllConnections()

        RASCONN[] allConnections = tempConn;

        int lpcConnections = 0;

        uint ret = RasEnumConnections(tempConn, ref lpcb, out lpcConnections);

        // first call returned that there are more than one connections

        allConnections = new RASCONN[lpcb / Marshal.SizeOf(typeof(RASCONN))];

        allConnections[0] = tempConn[0];

        ret = RasEnumConnections(allConnections, ref lpcb, out lpcConnections);

        if (lpcConnections > allConnections.Length)

        throw new Exception("RAS: error retrieving correct connection count");

        else if (lpcConnections == 0)

        allConnections = new RASCONN[0];

        return allConnections;

    internal static extern UInt32 RasEnumConnections([In, Out] _RASCONN[] lprasconn, ref UInt32 lpcb, ref UInt32 lpcConnections);

        public IntPtr ConnectionHandle { get { return m_hrasconn; } }

    public static _RASCONN[] EnumerateConnections()

        if (RasEnumConnections(rasconn, ref size, ref noelements) != 0x00)

            if (RasEnumConnections(rasconn, ref size, ref noelements) != 0x00) { rasconn = null; }

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

        RASCS_ConnectDevice,

        RASCS_DeviceConnected,

        RASCS_AllDevicesConnected,

        RASCS_Connected = RASCS_DONE,

        RASCS_Disconnected

    public static RASCONNSTATUS GetConnectStatus(IntPtr hrasconn)

        RasGetConnectStatus(hrasconn, ref status);

Use this function together with RasEnumConnections, to return a list of the active connections, then the sample code below will loop through the RASCONN[] array and close each one.

public static void CloseAllConnections()

        RASCONN[] connections = GetAllConnections();

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

        RasHangUp(connections[i].hrasconn);

static extern short SQLAllocConnect(IntPtr EnvironmentHandle, out IntPtr ConnectionHandle);

  IntPtr connectionHandle  = IntPtr.Zero;

  if (!isOK(SQLAllocConnect(environmentHandle, out connectionHandle)))

    throw new Exception("Failed to allocate connection handle.");

    private static extern short SQLBrowseConnect(IntPtr hconn, StringBuilder inString,

                if (SQL_NEED_DATA == SQLBrowseConnect(hconn, inString, inStringLength, outString,

                    if (SQL_NEED_DATA != SQLBrowseConnect(hconn, inString, inStringLength, outString,

static extern short SQLAllocStmt(IntPtr ConnectionHandle, out IntPtr StatementHandle);

    Private Shared Function SQLAllocStmt(ByVal connectionHandle As IntPtr, <Runtime.InteropServices.Out()> _

            //We will use a DSN in our connection string

            string connectionString = "DSN=SomeDSN; Uid=myun; Pwd=mypwd;";

            //Allocate a database connection handle, using the environment handle we allocated earlier

            //Connect to the DB, the completed connection string will be passed back

            short retcode = SQLDriverConnect(dbcHandle, IntPtr.Zero, connectionString, 256, completedConnString, 1024, out strLength, SQL_DRIVER_COMPLETE);

            //Free resources and disconnect

            SQLDisconnect(dbcHandle);

  private static extern short SQLBrowseConnect( IntPtr handleConnection, StringBuilder connectionString, short stringLength, StringBuilder outConnection, short bufferLength, out short stringLength2Ptr );

Declare Function SQLBrowseConnect Lib "odbc32.dll" (TODO) As TODO

static extern short SQLConnect (int connectionHandle, string serverName,

    Private Function SQLConnect(ByVal hDBc As IntPtr, ByVal servername As String, ByVal serverlen As Short, _

     RetCode = SQLAllocConnect(hEnv,ref hdbc);

     RetCode = SQLConnect(hdbc, "Northwind",-3,null,-3,null,-3);

    Private Sub OnGetODBCConnectionNames(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles cmbExpSID.DropDown, cmbImpSid.DropDown

public static extern short  SQLDisconnect(IntPtr ConnectionHandle);

Declare Function SQLDisconnect Lib "odbc32.dll" ( _

   connectionHandle As Integer) As Short

See SQLDriverConnect.

    public static extern short SQLDriverConnect(IntPtr  hdbc,

    Private Shared Function SQLDriverConnect(ByVal hdbc As IntPtr, ByVal hwnd As IntPtr, ByVal szConnStrIn As String, _

    void driverConnect(string connstr, ushort driverCompletion)

        const short    MAX_CONNECT_LEN = 1024;

        StringBuilder  out_connect = new StringBuilder(MAX_CONNECT_LEN);

        string            in_connect  = connstr;

        if (!isOK(SQLDriverConnect(connectionHandle,

            in_connect,

            (short) in_connect.Length,

            out_connect,

            MAX_CONNECT_LEN,

                string msg  = GetError(IntPtr.Zero) + "\nconnection string:\n\t" + connstr;

            connectionHandle,

            if (!isOK(SQLAllocConnect(environmentHandle, out connectionHandle)))

                throw new Exception("Failed to allocate connection handle.");

        if (connectionHandle.ToInt32()!=0)

            SQLDisconnect(connectionHandle);

        if (connectionHandle.ToInt32()!=0)

            SQLFreeConnect(connectionHandle);

            connectionHandle = IntPtr.Zero;

        IntPtr        ConnectionHandle,

See SQLDriverConnect example.

  static extern short SQLFreeConnect(IntPtr ConnectionHandle);

See SQLDriverConnect example.

See SQLDriverConnect example.

        if (!isOK(SQLAllocStmt(connectionHandle, out statementHandle)))

   bool connect);

[DllImport("winscard.dll", EntryPoint="SCardConnect", CharSet=CharSet.Auto)]

static extern int SCardConnect(

rv = SCardConnect(hContext, "Reader X", SCARD_SHARE_SHARED,

error CS1502: The best overloaded method match for 'PCSC_ContactlessNet.SmartCard.SCardConnect(System.IntPtr, string, uint, uint, out int, out uint)' has some invalid arguments

static extern int SCardDisconnect(int hCard, int dwDisposition);

    static extern int SCardConnect(IntPtr hContext,

    static extern int SCardDisconnect(IntPtr hCard, int Disposition);

            result = SCardConnect(hContext, readerName, 2, 3, ref phCard, ref ActiveProtocol);

            SCardDisconnect(phCard, 0);

   IntPtr hCard,            // Reference value returned from SCardConnect

  // Copy code to connect to the card here

updated to better working signature (VS2010)...still need to establish context, and connect the card like in sample area, but this is an example of code that will read an iClass UID

// Paste here code for SCardEstablishContext, SCardConnect

// Paste here code for SCardDisconnect, pbRecvBuffer contains Answer as Byte[]

  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;

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