ipv6 nd

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>

#define BUFSIZE 8192

void processNeighMessage(struct nlmsghdr *nlheader, const char *targetIPv6, int *neighborFound, char *macAddress, char *interfaceName) {
    struct ndmsg *ndm = (struct ndmsg*)NLMSG_DATA(nlheader);
    struct rtattr *rta = (struct rtattr*)NDA_RTA(ndm);

    while (RTA_OK(rta, nlheader->nlmsg_len)) {
        if (rta->rta_type == NDA_DST) {
            struct in6_addr *ipv6addr = (struct in6_addr*)RTA_DATA(rta);
            char ipv6str[INET6_ADDRSTRLEN];
            inet_ntop(AF_INET6, ipv6addr, ipv6str, INET6_ADDRSTRLEN);
            printf("IPv6 Address: %s\n", ipv6str);

            if (strcmp(ipv6str, targetIPv6) == 0) {
                printf("IPv6 Neighbor found for %s.\n", targetIPv6);

                // Extract MAC address
                struct rtattr *mac_rta = (struct rtattr*)NDA_RTA(ndm);
                while (RTA_OK(mac_rta, nlheader->nlmsg_len)) {
                    if (mac_rta->rta_type == NDA_LLADDR) {
                        unsigned char *mac = (unsigned char*)RTA_DATA(mac_rta);
                        sprintf(macAddress, "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
                                mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
                        printf("MAC Address: %s\n", macAddress);
                        *neighborFound = 1;
                        break;
                    }
                    mac_rta = RTA_NEXT(mac_rta, nlheader->nlmsg_len);
                }

                // Extract interface name
                strncpy(interfaceName, ndm->ndm_ifname, IFNAMSIZ - 1);
                interfaceName[IFNAMSIZ - 1] = '\0';
                printf("Interface Name: %s\n", interfaceName);
                return;
            }
        }
        rta = RTA_NEXT(rta, nlheader->nlmsg_len);
    }
}

int checkIPv6Neighbor(int ifindex, const char *targetIPv6, char *macAddress, char *interfaceName) {
    int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (sock == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_nl nladdr;
    memset(&nladdr, 0, sizeof(struct sockaddr_nl));
    nladdr.nl_family = AF_NETLINK;

    struct {
        struct nlmsghdr nlh;
        struct ndmsg ndm;
    } request;

    memset(&request, 0, sizeof(request));

    request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg));
    request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
    request.nlh.nlmsg_type = RTM_GETNEIGH;
    request.ndm.ndm_family = AF_INET6;
    request.ndm.ndm_ifindex = ifindex;

    if (sendto(sock, &request, sizeof(request), 0, (struct sockaddr*)&nladdr, sizeof(nladdr)) == -1) {
        perror("sendto");
        close(sock);
        exit(EXIT_FAILURE);
    }

    char buffer[BUFSIZE];
    struct nlmsghdr *nlheader;

    int neighborFound = 0;

    ssize_t received = recv(sock, buffer, sizeof(buffer), 0);
    if (received < 0) {
        perror("recv");
        close(sock);
        exit(EXIT_FAILURE);
    }

    for (nlheader = (struct nlmsghdr*)buffer; NLMSG_OK(nlheader, (size_t)received); nlheader = NLMSG_NEXT(nlheader, received)) {
        if (nlheader->nlmsg_type == NLMSG_DONE) {
            close(sock);
            if (neighborFound) {
                printf("IPv6 Neighbor found.\n");
            } else {
                printf("No matching IPv6 Neighbor found for %s.\n", targetIPv6);
            }
            return neighborFound;  // No matching neighbor found
        }

        if (nlheader->nlmsg_type == NLMSG_ERROR) {
            fprintf(stderr, "Netlink request error\n");
            close(sock);
            exit(EXIT_FAILURE);
        }

        processNeighMessage(nlheader, targetIPv6, &neighborFound, macAddress, interfaceName);
    }

    close(sock);
    return neighborFound;
}

int main() {
    int ifindex = 2;  // Replace with your actual interface index
    const char *targetIPv6 = "fe80::1";  // Replace with the IPv6 address you want to check
    char macAddress[18];  // Buffer to store MAC address (including null terminator)
    char interfaceName[IFNAMSIZ];  // Buffer to store interface name

    if (checkIPv6Neighbor(ifindex, targetIPv6, macAddress, interfaceName)) {
        // You can use macAddress and interfaceName as needed
        printf("MAC Address: %s\n", macAddress);
        ｝

 

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <unistd.h>
#define MAX_NEIGHBORS 1024
int main(int argc, char **argv) {
    int sock;
    struct rtattr *tb[RTA_MAX + 1];
    struct rtmsg *rtm;
    char *target_ip;
    int i;
    int found = 0;
    if (argc != 3) {
        printf("Usage: %s <family> <target>\n", argv[0]);
        exit(1);
    }
    sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (sock == -1) {
        perror("socket");
        exit(1);
    }
    target_ip = argv[2];
    memset(tb, 0, sizeof(tb));
    tb[RTA_DST] = rtm_family_attr(AF_INET6);
    rtm = (struct rtmsg *)tb[RTA_DST];
    rtm->rtm_family = AF_INET6;
    rtm->rtm_dst_len = IPV6_ADDR_LEN;
    rtm->rtm_type = RTN_UNICAST;
    rtm->rtm_scope = RT_SCOPE_HOST;
    rtm->rtm_table = RT_TABLE_MAIN;
    rtm->rtm_protocol = RTPROT_STATIC;
    rtm->rtm_flags = RTM_F_LOOKUP_TABLE;
    if (setsockopt(sock, SOL_NETLINK, RTM_GETNEIGH, tb, sizeof(tb)) == -1) {
        perror("setsockopt");
        exit(1);
    }
    if (recv(sock, &rtm, sizeof(rtm), 0) == -1) {
        perror("recv");
        exit(1);
    }
    for (i = 0; i < RTA_PAYLOAD(rtm); i += RTA_ALIGN(sizeof(struct rtattr))) {
        struct rtattr *rta = (struct rtattr *)&rtm[i];
        if (rta->rta_type == RTA_DST) {
            char *addr = RTA_DATA(rta);
            if (memcmp(addr, target_ip, IPV6_ADDR_LEN) == 0) {
                found = 1;
                break;
            }
        } else if (rta->rta_type == RTA_GENMASK) {
            break;  // ignore netmask attribute for IPv6 neighbor table lookup. we only care about the destination address.
        } else if (rta->rta_type != RTA_NEXT) {
            printf("Unknown attribute type %d encountered.\n", rta->rta_type);  // unexpected attribute encountered. we should handle it gracefully and not terminate the loop. just print a message and continue to the next iteration.

 

 

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/types.h>
#include <sys/socket.h>

void closePortConnections(int port) {
    // 创建套接字
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);

    // 设置服务器地址结构
    struct sockaddr_in server_address;
    memset(&server_address, 0, sizeof(server_address));
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = htonl(INADDR_ANY);
    server_address.sin_port = htons(port);

    // 绑定套接字
    bind(server_socket, (struct sockaddr*)&server_address, sizeof(server_address));

    // 开始监听
    listen(server_socket, 5);

    // 关闭指定端口上的所有连接
    int optval = 1;
    setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));

    // 关闭套接字
    close(server_socket);
    
    printf("关闭端口 %d 上的所有连接成功\n", port);
}

int main() {
    int portToClose = 8080;  // 替换为你要关闭的端口号
    closePortConnections(portToClose);

    return 0;
}