通过ioctl获取系统网关，请用C语言写出程序

以下是通过ioctl获取系统网关的C语言程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <linux/if.h>
#include <linux/if_arp.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>

#define BUF_SIZE 4096

int main(int argc, char *argv[]) {
    int fd, len;
    char buf[BUF_SIZE];
    struct nlmsghdr *nh;
    struct ifinfomsg *ifinfo;
    struct rtattr *attr;
    int rtattrlen;
    unsigned long gw;

    fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (fd < 0) {
        perror("socket");
        return -1;
    }

    memset(buf, 0, sizeof(buf));

    nh = (struct nlmsghdr *)buf;
    nh->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
    nh->nlmsg_type = RTM_GETLINK;
    nh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;

    ifinfo = (struct ifinfomsg *)NLMSG_DATA(nh);
    ifinfo->ifi_family = AF_UNSPEC;

    attr = (struct rtattr *)IFLA_RTA(ifinfo);
    rtattrlen = IFLA_PAYLOAD(nh);
    attr->rta_type = IFLA_MASTER;
    attr->rta_len = RTA_LENGTH(0);
    rtattrlen += attr->rta_len;

    nh->nlmsg_len = NLMSG_ALIGN(nh->nlmsg_len) + RTA_ALIGN(attr->rta_len);

    if (send(fd, nh, nh->nlmsg_len, 0) < 0) {
        perror("send");
        return -1;
    }

    memset(buf, 0, sizeof(buf));

    if ((len = recv(fd, buf, sizeof(buf), 0)) < 0) {
        perror("recv");
        return -1;
    }

    for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, len);
         nh = NLMSG_NEXT(nh, len)) {
        if (nh->nlmsg_type != RTM_NEWLINK) {
            continue;
        }

        ifinfo = (struct ifinfomsg *)NLMSG_DATA(nh);
        if (ifinfo->ifi_family != AF_UNSPEC) {
            continue;
        }

        attr = (struct rtattr *)IFLA_RTA(ifinfo);
        rtattrlen = IFLA_PAYLOAD(nh);
        for (; RTA_OK(attr, rtattrlen); attr = RTA_NEXT(attr, rtattrlen)) {
            if (attr->rta_type == IFLA_ADDRESS) {
                break;
            }
        }
        if (attr->rta_type == IFLA_ADDRESS) {
            break;
        }
    }

    if (nh == NULL) {
        fprintf(stderr, "no interface found\n");
        return -1;
    }

    nh = (struct nlmsghdr *)buf;
    nh->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
    nh->nlmsg_type = RTM_GETROUTE;
    nh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;

    struct rtmsg *rtm = (struct rtmsg *)NLMSG_DATA(nh);
    rtm->rtm_family = AF_INET;
    rtm->rtm_table = RT_TABLE_MAIN;
    rtm->rtm_protocol = RTPROT_UNSPEC;
    rtm->rtm_scope = RT_SCOPE_UNIVERSE;
    rtm->rtm_type = RTN_UNICAST;

    attr = (struct rtattr *)RTM_RTA(rtm);
    attr->rta_type = RTA_DST;
    attr->rta_len = RTA_LENGTH(4);
    gw = 0;
    memcpy(RTA_DATA(attr), &gw, 4);
    rtattrlen = RTA_ALIGN(attr->rta_len);
    attr = (struct rtattr *)((char *)attr + rtattrlen);
    attr->rta_type = RTA_OIF;
    attr->rta_len = RTA_LENGTH(4);
    memcpy(RTA_DATA(attr), &ifinfo->ifi_index, 4);
    rtattrlen += RTA_ALIGN(attr->rta_len);
    nh->nlmsg_len = NLMSG_ALIGN(nh->nlmsg_len) + rtattrlen;

    if (send(fd, nh, nh->nlmsg_len, 0) < 0) {
        perror("send");
        return -1;
    }

    memset(buf, 0, sizeof(buf));

    if ((len = recv(fd, buf, sizeof(buf), 0)) < 0) {
        perror("recv");
        return -1;
    }

    for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, len);
         nh = NLMSG_NEXT(nh, len)) {
        if (nh->nlmsg_type != RTM_NEWROUTE) {
            continue;
        }

        struct rtmsg *rtm = (struct rtmsg *)NLMSG_DATA(nh);
        rtattrlen = RTM_PAYLOAD(nh);
        for (attr = (struct rtattr *)RTM_RTA(rtm);
             RTA_OK(attr, rtattrlen);
             attr = RTA_NEXT(attr, rtattrlen)) {
            if (attr->rta_type == RTA_GATEWAY) {
                memcpy(&gw, RTA_DATA(attr), 4);
                printf("Gateway: %lu.%lu.%lu.%lu\n", (gw >> 0) & 0xff, (gw >> 8) & 0xff, (gw >> 16) & 0xff, (gw >> 24) & 0xff);
                return 0;
            }
        }
    }

    fprintf(stderr, "no gateway found\n");
    return -1;
}

该程序通过netlink连接内核，发送RTM_GETLINK和RTM_GETROUTE消息获取系统网关。请注意，该程序需要以root权限运行。