windows 端口获取pid api

在 Windows 操作系统中，可以使用几种不同的方法来获取正在使用的端口的 PID。以下是一些常用的 API 和命令行工具：

1. GetExtendedTcpTable 函数：此函数可使用 Windows API 来获取所有正在运行的 TCP 连接的详细信息，包括进程 ID。要使用此函数，您需要创建一个 MIB_TCPTABLE_OWNER_PID 结构体，然后将其作为参数传递给 GetExtendedTcpTable 函数。该函数将填充该结构体并将其发送回调用者。

2. GetExtendedUdpTable 函数：与 GetExtendedTcpTable 函数类似，此函数可使用 Windows API 来获取所有正在运行的 UDP 连接的详细信息，包括进程 ID。

3. netstat 命令行工具：netstat 是一个命令行工具，可用于显示所有当前正在运行的网络连接以及它们的本地和远程 IP 地址，端口号和状态。可以使用 netstat 与其他参数一起使用，例如“-ano”，以显示正在运行的连接的进程 ID。

4. TCPView：TCPView 是一个免费的 Windows 应用程序，可让您查看所有正在运行的 TCP 和 UDP 连接，以及它们的本地和远程 IP 地址，端口号和进程 ID。使用 TCPView，您可以通过单击列标题来排序列以查找正在使用的特定端口。

相关问题

根据pid获取端口号

在 Windows 操作系统中，可以使用 WMI 查询获取进程的详细信息，包括 PID 和端口号。以下是一个示例代码，根据进程的 PID 获取端口号：

using System;
using System.Management;

class Program
{
    static void Main(string[] args)
    {
        // 要查询的进程 PID
        int pid = 1234;

        // 使用 WMI 查询获取进程的详细信息
        ManagementObjectSearcher searcher = new ManagementObjectSearcher(
            "SELECT * FROM Win32_Process WHERE ProcessId = " + pid);
        ManagementObjectCollection results = searcher.Get();

        // 遍历查询结果，获取端口号
        foreach (ManagementObject result in results)
        {
            // 获取进程的句柄
            uint processId = (uint)result["ProcessId"];
            IntPtr handle = NativeMethods.OpenProcess(
                NativeMethods.PROCESS_QUERY_INFORMATION | NativeMethods.PROCESS_VM_READ,
                false, (int)processId);

            // 获取进程的模块信息
            NativeMethods.EnumProcessModules(handle, out IntPtr moduleHandle,
                sizeof(IntPtr), out uint neededSize);
            string moduleName = new string(' ', 1024);
            NativeMethods.GetModuleFileNameEx(handle, moduleHandle, moduleName,
                (uint)moduleName.Length);

            // 获取进程监听的端口号
            TcpTable tcpTable = new TcpTable();
            uint tcpTableLength = (uint)Marshal.SizeOf(tcpTable);
            NativeMethods.GetExtendedTcpTable(tcpTable, ref tcpTableLength, true,
                NativeMethods.AF_INET, NativeMethods.TCP_TABLE_CLASS.TCP_TABLE_OWNER_PID_ALL);
            foreach (TcpRow row in tcpTable.rows)
            {
                if (row.owningPid == pid && row.state == TcpState.Listen)
                {
                    Console.WriteLine("Process {0} listens on port {1}", moduleName, row.localPort);
                }
            }

            // 关闭进程句柄
            NativeMethods.CloseHandle(handle);
        }
    }
}

class NativeMethods
{
    public const uint PROCESS_QUERY_INFORMATION = 0x0400;
    public const uint PROCESS_VM_READ = 0x0010;
    public const int AF_INET = 2;

    [DllImport("kernel32.dll", SetLastError = true)]
    public static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, int dwProcessId);

    [DllImport("psapi.dll", SetLastError = true)]
    public static extern bool EnumProcessModules(IntPtr hProcess, out IntPtr lphModule, int cb, out uint lpcbNeeded);

    [DllImport("psapi.dll", CharSet = CharSet.Unicode)]
    public static extern uint GetModuleFileNameEx(IntPtr hProcess, IntPtr hModule, [Out] StringBuilder lpBaseName, uint nSize);

    [DllImport("iphlpapi.dll", SetLastError = true)]
    public static extern int GetExtendedTcpTable(IntPtr pTcpTable, ref uint pdwSize, bool bOrder, int ulAf, TCP_TABLE_CLASS TableClass, uint Reserved = 0);

    [DllImport("kernel32.dll", SetLastError = true)]
    public static extern bool CloseHandle(IntPtr hObject);

    public enum TCP_TABLE_CLASS
    {
        TCP_TABLE_BASIC_LISTENER,
        TCP_TABLE_BASIC_CONNECTIONS,
        TCP_TABLE_BASIC_ALL,
        TCP_TABLE_OWNER_PID_LISTENER,
        TCP_TABLE_OWNER_PID_CONNECTIONS,
        TCP_TABLE_OWNER_PID_ALL,
        TCP_TABLE_OWNER_MODULE_LISTENER,
        TCP_TABLE_OWNER_MODULE_CONNECTIONS,
        TCP_TABLE_OWNER_MODULE_ALL
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct MIB_TCPROW_OWNER_PID
    {
        public uint state;
        public uint localAddr;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public byte[] localPort;
        public uint remoteAddr;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public byte[] remotePort;
        public uint owningPid;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct TcpTable
    {
        public uint rowsCount;
        public MIB_TCPROW_OWNER_PID[] rows;
    }

    public enum TcpState
    {
        Closed = 1,
        Listen = 2,
        SynSent = 3,
        SynReceived = 4,
        Established = 5,
        FinWait1 = 6,
        FinWait2 = 7,
        CloseWait = 8,
        Closing = 9,
        LastAck = 10,
        TimeWait = 11,
        DeleteTcb = 12
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct TcpRow
    {
        public uint state;
        public uint localAddr;
        public uint localPort;
        public uint remoteAddr;
        public uint remotePort;
        public uint owningPid;
    }
}

在上面的代码中，我们首先定义了要查询的进程 PID，然后使用 WMI 查询获取进程的详细信息。接着遍历查询结果，获取进程的模块信息和监听的端口号。具体实现过程中使用了一些 Windows API 函数和结构体，如 OpenProcess、EnumProcessModules、GetModuleFileNameEx、GetExtendedTcpTable 等。获取端口号的核心代码是调用 GetExtendedTcpTable 函数获取进程的 TCP 连接信息，然后从中筛选出监听中的 TCP 连接，从而得到端口号。

VS2010获取USB端口在hub上的PID\\&VID

在Visual Studio 2010中，如果你想要获取连接到USB hub上的设备的Product ID (PID) 和 Vendor ID (VID)，你需要使用Windows API中的函数，例如`SetupDiGetDeviceInformation`和`SetupDiEnumDeviceInterfaces`。以下是一个基本步骤：

1. 引入必要的头文件，如Windows.h和Setupapi.h。
2. 使用`SetupDiGetClassDevs`函数找到所有USB设备的设备信息集。
3. 遍历设备信息集，对于每个设备，通过`SetupDiGetDeviceInterfaceDetail`获取设备接口列表。
4. 在接口列表中查找USB Mass Storage类（通常对应于存储设备），然后使用`SetupDiGetDeviceInformation`获取该接口的详细信息，其中包括PID和VID。

这是一个示例代码片段（请注意，这只是一个简化版本，实际使用时需要处理错误和异常）:

#include <windows.h>
#include <setupapi.h>
#include <devguid.h>

void GetUSBPortPIDVID(LPCWSTR deviceClassName)
{
    HDEVINFO devices = SetupDiGetClassDevs(&GUID_DEVCLASS_USBSTOR, NULL, NULL, DIGCF_PRESENT);
    
    if (devices == INVALID_HANDLE_VALUE)
        return;

    SP_DEVICE_INTERFACE_DATA interfaceData;
    DWORD requiredSize = sizeof(interfaceData);

    for (DWORD i = 0; SetupDiEnumDeviceInterfaces(devices, NULL, deviceClassName, i, &interfaceData); ++i)
    {
        if (!SetupDiGetDeviceInterfaceDetail(devices, &interfaceData, NULL, 0, &requiredSize, NULL))
            continue;

        PSP_DEVICE_INTERFACE_DETAIL_DATA detailData = new SP_DEVICE_INTERFACE_DETAIL_DATA[requiredSize];
        if (!detailData)
            break;

        if (SetupDiGetDeviceInterfaceDetail(devices, &interfaceData, detailData, requiredSize, &requiredSize, NULL))
        {
            USB_HUB_INFORMATION usbHubInfo;
            ZeroMemory(&usbHubInfo, sizeof(usbHubInfo));
            
            if (SetupDiGetDeviceRegistryProperty(devices, &interfaceData, SPDRP_HUB_INFORMATION, NULL, (PBYTE)&usbHubInfo, sizeof(usbHubInfo), NULL))
            {
                WDM_USB_DEVICE_ID id;
                ZeroMemory(&id, sizeof(id));
                
                if (SetupDiGetDeviceRegistryProperty(devices, &interfaceData, SPDRP_USBDEVICEID, NULL, (PBYTE)&id, sizeof(id), NULL))
                {
                    printf("Vendor ID: %x\n", id.VendorId);
                    printf("Product ID: %x\n", id.ProductId);
                }
            }

            delete[] detailData;
        }
    }

    SetupDiDestroyDeviceInfoList(devices);
}