C与Node.js IPC报错TypeError: Unsupported fd type: UNKNOWN的解决及优化

问题1：修复Unsupported fd type: UNKNOWN错误 #

这个错误的核心原因是你误用了net.Socket来处理FIFO（命名管道）的文件描述符——net.Socket是专门为**网络套接字（TCP/UDP）**设计的，Node.js内部会对fd的类型做校验，而FIFO属于管道类fd，长期运行中（比如C程序频繁打开/关闭写端触发Node重连）就会触发类型校验失败。

修改后的Node.js代码（用fs流替代net.Socket）

const C = require('constants');
const fs = require('fs');

function listen() {
  // 以非阻塞只读模式打开FIFO
  const fd = fs.openSync('/tmp/fifo', C.O_NONBLOCK | C.O_RDONLY);
  // 基于已打开的fd创建可读流，禁用自动关闭（我们手动控制）
  const stream = fs.createReadStream(null, { fd, autoClose: false });

  stream.on('data', (data) => {
    // 处理数据：因为FIFO每次写入固定20字节，过滤掉空内容
    const timeStr = data.toString().trim();
    if (timeStr) console.log(timeStr);
  });

  stream.on('end', () => {
    // C程序关闭写端时，流会触发end事件，此时清理资源并重连
    fs.closeSync(fd);
    stream.destroy();
    listen();
  });

  stream.on('error', (err) => {
    console.error('Stream error:', err);
    // 出错后强制清理资源，避免fd泄漏
    fs.closeSync(fd);
    stream.destroy();
    setTimeout(listen, 1000); // 延迟重连，避免频繁重试
  });
}

listen();

优化后的C代码（减少不必要的open/close）

原C代码每次循环都打开/关闭FIFO，会频繁触发Node端的end事件，增加系统开销和出错概率。我们可以保持写端长期打开：

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

int main() {
    int fd;
    char * fifo_name = "/tmp/fifo";
    // 创建FIFO（如果已存在会返回EEXIST，不影响后续操作）
    if (mkfifo(fifo_name, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo failed");
        exit(1);
    }

    // 保持写端长期打开，避免每次循环的open/close开销
    fd = open(fifo_name, O_WRONLY);
    if (fd == -1) {
        perror("open fifo failed");
        exit(1);
    }

    char buff[20];
    time_t my_time;
    while (1) {
        time(&my_time);
        strftime(buff, sizeof(buff), "%Y-%m-%d %H:%M:%S", localtime(&my_time));
        write(fd, buff, sizeof(buff));
        usleep(10000);
    }

    // 实际不会走到这里，可添加信号处理（比如SIGINT）来安全关闭fd
    close(fd);
    return 0;
}

问题2：更优的IPC实现方式 #

根据你的需求（定时传递时间数据），推荐以下几种更稳定高效的方案：

1. Unix域套接字（最推荐）

比FIFO更灵活，支持双向通信，性能比本地TCP套接字更高，Node.js和C都有原生良好支持，不会出现FIFO的流边界问题。

• C端实现：用AF_UNIX类型的套接字创建服务器，监听本地路径
• Node.js端实现：用net.createConnection连接到Unix套接字路径

示例代码（C服务器 + Node客户端）：
C代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>

#define UDS_PATH "/tmp/uds_time_socket"

int main() {
    int server_fd, client_fd;
    struct sockaddr_un addr;
    char buff[20];
    time_t my_time;

    // 创建Unix域套接字
    server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket failed");
        exit(1);
    }

    // 绑定套接字路径（先删除旧文件避免绑定失败）
    memset(&addr, 0, sizeof(struct sockaddr_un));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, UDS_PATH, sizeof(addr.sun_path)-1);
    unlink(UDS_PATH);

    if (bind(server_fd, (struct sockaddr*)&addr, sizeof(struct sockaddr_un)) == -1) {
        perror("bind failed");
        close(server_fd);
        exit(1);
    }

    // 监听连接
    if (listen(server_fd, 5) == -1) {
        perror("listen failed");
        close(server_fd);
        exit(1);
    }

    // 接受客户端连接（阻塞直到有客户端连接）
    client_fd = accept(server_fd, NULL, NULL);
    if (client_fd == -1) {
        perror("accept failed");
        close(server_fd);
        exit(1);
    }

    // 持续发送时间数据
    while (1) {
        time(&my_time);
        strftime(buff, sizeof(buff), "%Y-%m-%d %H:%M:%S", localtime(&my_time));
        write(client_fd, buff, sizeof(buff));
        usleep(10000);
    }

    // 清理资源（实际不会执行，可添加信号处理）
    close(client_fd);
    close(server_fd);
    unlink(UDS_PATH);
    return 0;
}

Node.js代码

const net = require('net');

const UDS_PATH = '/tmp/uds_time_socket';

function connectToServer() {
    const client = net.createConnection(UDS_PATH);

    client.on('data', (data) => {
        const timeStr = data.toString().trim();
        if (timeStr) console.log(timeStr);
    });

    client.on('close', () => {
        // 连接断开后自动重连
        setTimeout(connectToServer, 1000);
    });

    client.on('error', (err) => {
        console.error('Client error:', err);
        client.destroy();
    });
}

connectToServer();

2. 共享内存（极致性能需求）

如果需要传输大量数据且追求极低延迟，共享内存是最优选择。C可以用System V共享内存API（shmget/shmat），Node.js可以用第三方模块（如shm-typed-array）直接操作共享内存区域。

3. Node.js子进程IPC（如果C程序是Node启动的）

如果你的C程序是由Node.js启动的子进程，可以直接用child_process模块的stdin/stdout进行通信，Node.js原生支持，无需额外的套接字或管道配置。

内容的提问来源于stack exchange，提问作者dislick