nodejs获取机器IP&扫描局域网_node 获取本机内网ip ,如果本机有两个网卡一个wifi 一个集成网卡如何判断正在使用

nodejs获取机器IP&局域网扫描

步骤

1. 获取本机的网卡IP
2. 将所在IP转换成对应网段，对应子网只能是255.255.255.0这种，
   • 注： 没有考虑比如 192.168.0.0/255.255.252.0 类似的情况
3. 通过socket方式逐个链接，链接成功的保存下来，链接失败的返回false
4. 最终结果返回一个扫描到的数组

代码

const os = require("os"); //导入OS模块
const net = require("net");
const Socket = net.Socket;

const timeout = 100;

/**
 * 链接指定主机，成功则返回IP，失败返回false
 * @param {string} host ip地址
 * @param {number} port 端口号
 * @param {function} cb 回调
 * @returns Promise
 */
async function scanHost(host, port, cb) {
  return new Promise((resolve, reject) => {
    const socket = new Socket();

    socket.setTimeout(timeout);

    socket.on("connect", function () {
      console.debug(`链接成功：${host}`);
      socket.end();
      cb && cb(null, host);
      resolve(host);
    });

    socket.on("timeout", function () {
      console.error(`链接超时：${host}`);
      socket.destroy();
      cb && cb(new Error("timeout"), host);
      resolve(false);
    });

    socket.on("error", function (err) {
      console.warn(`链接失败：${host}`);
      cb && cb(err, host);
      resolve(false);
    });

    socket.on("close", function (err) {});
    socket.connect(port, host);
  });
}

/**
 * 扫描指定网段
 * @param {string} net 网段
 * @param {number} port 端口号
 * @param {function} cb 回调
 * @returns Pomise
 */
async function scan(net, port, cb) {
  if (port < 0 || port > 65535) {
    throw new Error("输入的端口号超过有效范围0 ~ 65535.");
  }

  const deferCache = [];

  for (let i = 1; i <= 255; i++) {
    deferCache.push(scanHost(net + "." + i, port));
  }

  const result = (await Promise.all(deferCache)).filter((it) => it);

  if (cb) {
    cb(result);
  }

  return result;
}

/**
 * 获取本机局域网的IPV4
 * @return {Array} 
 */
function getIpAddress() {
  let ipv4 = [];
  let ifaces = os.networkInterfaces();

  //   console.log(ifaces); //所有类型的适配器和全部内容

  for (let dev in ifaces) {
    if (/en[\d]+/.test(dev)) {
      ifaces[dev].forEach(function (details, alias) {
        //判断需要获取IP的适配器，过滤掉非IPv4和mac无效的设备
        if (details.family == "IPv4" && details.mac !== "00:00:00:00:00:00") {
          //判断是IPV4还是IPV6 还可以通过alias去判断
          ipv4.push(details.address);
        }
      });
    }
  }

  return ipv4;
}

function getNet() {
  const ipv4 = getIpAddress();
  const netList = [];

  console.debug(`找到有效IP: ${ipv4.join(", ")}`);

  if (!ipv4 || !ipv4.length) {
    return false;
  }

  ipv4.map((ip) => {
    const net = ip.split(".").slice(0, 3).join(".");
    if (!netList.includes(net)) {
      netList.push(net);
    }
  });
  return netList;
}
// console.log(getIpAddress());
// console.log(getNet());

// scan(getNet(), 22221, (result) => {
//   console.log(result);
// });

async function autoScan(port = 22221) {
  const netList = getNet();
  
  if (!netList || !netList.length) {
    return;
  }
  
  return (await Promise.all(netList.map(async (net)=>{
    const result = await scan(net, port)
    if(result && result.length){
        return result
    }
    return false
  }))).filter(it => it)
}

// scan("192.168.32", 22221, (result) => {
//   console.log(result);
// });
// scan("192.168.32", 5555, (result) => {
//     console.log(result);
// });

// test
autoScan(80).then((result) => console.log(result));

// module.exports = {
//   autoScan,
//   scan,
//   getIpAddress,
//   getNet,
//   scanHost,
// };
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154