SmartPDCode/f407/applications/net.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <limits.h>
#include "rtdbg.h"
#include "sys.h"
#include "paras.h"
#include "cfg.h"
#include "fs.h"

#if 1
    #define LOGE  LOG_E
    #define LOGW  LOG_W
    #define LOGD  LOG_D
#else
    #define LOGD  rt_printf
    #define LOGW  rt_printf
    #define LOGE  rt_printf
#endif


#define DFLT_NIC            "e0"



////////////////////////////////////////////////
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <lwip/sockets.h>
#include <lwip/ip_addr.h>
#include <lwip/ip6_addr.h>

void print_net(char*s, network_data_t *p)
{
    LOGD("__%s__net.mode:    %d\n", s, p->mode);
    LOGD("__%s__net.addr:    %s\n", s, p->ip_address);
    LOGD("__%s__net.mask:    %s\n", s, p->mask);
    LOGD("__%s__net.gateway: %s\n", s, p->gateway);
    LOGD("__%s__net.dns1:    %s\n", s, p->dns1);
    LOGD("__%s__net.dns2:    %s\n", s, p->dns2);
}
void print_modbus(char*s, modbus_data_t *p)
{
    LOGD("__%s__mbus.mode:    %d\n", s, p->mode);
    LOGD("__%s__mbus.addr:    %d\n", s, p->addr);
    LOGD("__%s__mbus.baud:    %d\n", s, p->baudrate);
    LOGD("__%s__mbus.path:    %s\n", s, p->path);
}

static int set_ipaddr(int family, const char* iface, const char* addr, const char* netmask)
{
    ip4_addr_t  ipaddr4;
    ip6_addr_t  ipaddr6;

    if(family==AF_INET) {
        //ip4_addr_set(&ipaddr4, IP4_ADDR(&ipaddr4, 0xbeef, 0xfeed, 0xdead, 0xbeef));
    }
    else {
        //ip6_addr_set(&ipaddr6, IP6_ADDR(&ipaddr6, 0xbeef, 0xfeed, 0xdead, 0xbeef, 0x1337, 0xbabe, 0xbaad, 0xface));
        
        //netif_add_ip6_address(&netif, &ipaddr_v6, &chosen_idx);
        //netif.ip6_addr_state[chosen_idx] = IP6_ADDR_VALID;
        //ip6_addr_assign_zone(ip_2_ip6(&netif.ip6_addr[0]), IP6_UNICAST, &netif);
        //netif_ip6_addr_set_state(&netif, 0, IP6_ADDR_TENTATIVE);
    }
    
    return 0;
}
static int get_ipaddr(int family, char *iface, char *addr, char *netmask)
{
    
    
    return 0;
}

static int set_gateway(int family, const char* gateway)
{
    
    
    return 0;

}
static int get_gateway(int family, const char* gateway)
{

    return 0;
}
static int set_dhcp(int on)
{
    if(on) {
        
    }
    else {
        
    }
    return 0;
}
static int is_number(char *str)
{
    while (*str) {
        if (!isdigit(*str)) {
            return 0;
        }
        str++;
    }
    return 1;
}
static int ip_check(char* addr)
{
    int flag=IP_ERR;
    struct in_addr addr4;
    struct in6_addr addr6;

    if (inet_pton(AF_INET, addr, &addr4) == 1) {
        flag = IP_V4;
    } else if (inet_pton(AF_INET6, addr, &addr6) == 1) {
        flag = IP_V6;
    }

    if(flag==IP_ERR) {
        LOGE("____ wrong ip addr: %s\n", addr);
    }
    
    return flag;
}
static int is_ipv6_prefix(char *ss)
{
    if(is_number(ss)) {
        int val = atoi(ss);
        if(val>1 && val<128) {
            return 1;
        }
    }

    return 0;
}




static int nw_check(network_data_t *para, int ipv)
{
    if(ipv==IP_V4) {
        if((ip_check(para->ipaddr)!=IP_V4) || (ip_check(para->mask)!=IP_V4) || (ip_check(para->gateway)!=IP_V4)) {
            return -1;
        }
    }
    else {
        if((ip_check(para->ipaddr)!=IP_V6) || (!is_ipv6_prefix(para->mask)) || (ip_check(para->gateway)!=IP_V6)) {
            return -1;
        }
    }

    return 0;
}
static int get_net(network_data_t *para, int ipv)
{
    return 0;
}
static int set_net(network_data_t *para, int ipv)
{
    int r,ipv2;
    network_data_t info4,info6,*info;

    get_net(&info4, IP_V4);
    get_net(&info6, IP_V6);

    info = ((ipv==IP_V4)?&info4:&info6);
    
    if(para->mode<2 && para->mode!=info->mode) {
        info->mode = para->mode;
    }
    
    ipv2 = ip_check(para->ipaddr);
    if((ipv==ipv2) && strcmp(para->ipaddr, info->ipaddr)) {
        strcpy(info->ipaddr, para->ipaddr);
    }
    
    if(ipv==IP_V4) {
        ipv2 = ip_check(para->mask);
    }
    else {
        ipv2=is_ipv6_prefix(para->mask)?IP_V6:IP_ERR;
    }
    if((ipv==ipv2) && strcmp(para->mask, info->mask)) {
        strcpy(info->mask, para->mask);
    }

    ipv2 = ip_check(para->gateway);
    if((ipv==ipv2) && strcmp(para->gateway, info->gateway)) {
        strcpy(info->gateway, para->gateway);
    }
    

    return r;
}

//////////////////////////////////////////////////////////////////////////////
int sys_set_net(network_data_t *para, int ip_version)
{
    int r,ipv;

    network_data_t para2;
    r = get_net(&para2, ip_version);
    if(r==0) {
        if(memcmp(para, &para2, sizeof(network_data_t))==0) {
            LOGW("%s NetworkInfo is same, no need to set\n", DFLT_NIC);
            return -1;
        }
        set_dns(para);
        r = set_net(para, ipVersion);
        if(r==0) {
            sys_reboot();
            //nic_restart(DFLT_NIC); exit(0);
        }
    }
    else {
        LOGE("get_net failed\n");
    }
    
    return r;
}

int sys_get_net(network_data_t *para, int ip_version)
{
    int r;

    r = get_net(para, ip_version);

    return r;
}


int sys_get_mac(char *mac, int maclen)
{
    int sock;
    struct ifreq ifr;

    if(!mac || maclen<6) {
        return -1;
    }

    sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock == -1){
        return -1;
    }

    strcpy(ifr.ifr_name, "eth0");
    if (ioctl(sock, SIOCGIFHWADDR, &ifr) < 0){
        close(sock); return -1;
    }
    close(sock);

    //uint8_t *p = (uint8_t*)ifr.ifr_hwaddr.sa_data;
    //snprintf(mac, maclen, "%02x%02x%02x%02x%02x%02x", p[0], p[1], p[2], p[3], p[4], p[5]);

    return 0;
}

int sys_get_chip_id(int *id)
{
    int sock;
    struct ifreq ifr;

    if(!id) {
        return -1;
    }

    
    return 0;
}


int sys_ip_check(char *ip)
{
    return ip_check(ip);
}



///////////////////////////////////////////////////////////////////////
#define MAX_BUFFER_SIZE 1024
static void* plug_thread(void *arg)
{
    int nlSock;
    struct sockaddr_nl srcAddr;
    struct nlmsghdr *nlMsg;
    char buffer[MAX_BUFFER_SIZE];
    int plug_in=0,plug_out=0;
    thread_handle_t *h=(thread_handle_t*)arg;

    printf("___plug_thread start\n");

    nlSock = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (nlSock < 0) {
        printf("Failed to create Netlink socket");
        goto quit;
    }

    memset(&srcAddr, 0, sizeof(srcAddr));
    srcAddr.nl_family = AF_NETLINK;
    srcAddr.nl_groups = RTMGRP_LINK | RTMGRP_NOTIFY;

    if (bind(nlSock, (struct sockaddr *)&srcAddr, sizeof(srcAddr)) < 0) {
        perror("Failed to bind Netlink socket");
        close(nlSock);
        goto quit;
    }

	int flags = fcntl(nlSock, F_GETFL, 0);
    fcntl(nlSock, F_SETFL, flags | O_NONBLOCK);

    while (h->quit==0) {
        fd_set readSet;
        FD_ZERO(&readSet);
        FD_SET(nlSock, &readSet);

        // 设置超时时间为 1 秒
        struct timeval timeout;
        timeout.tv_sec = 1;
        timeout.tv_usec = 0;

        // 监视 Netlink Socket 的可读状态
        int result = select(nlSock + 1, &readSet, NULL, NULL, &timeout);
        if (result == -1) {
            perror("Failed to select");
            goto quit;
        } else if (result == 0) {
            // 超时，没有新数据到达
            //printf("Timeout\n");
            continue;
        }

        if (FD_ISSET(nlSock, &readSet)) {
            // 接收消息
            int bytesRead = recv(nlSock, buffer, MAX_BUFFER_SIZE, 0);
            if (bytesRead < 0) {
                perror("Failed to receive message from Netlink socket");
                close(nlSock);
                goto quit;
            }

            // 遍历接收到的消息,获取到Netlink的消息头。
            nlMsg = (struct nlmsghdr *)buffer;
            while (NLMSG_OK(nlMsg, bytesRead)) {
                if (nlMsg->nlmsg_type == NLMSG_DONE) {
                    break;
                }

                if (nlMsg->nlmsg_type == RTM_NEWLINK || nlMsg->nlmsg_type == RTM_DELLINK) {
                    //NLMSG_DATA()获取完整的ifinfomsg结构体的指针
                    //根据消息头nlMsg获取到其后面的数据部分ifinfomsg结构体的指针
                    struct ifinfomsg *ifInfo = (struct ifinfomsg *)NLMSG_DATA(nlMsg);
                    if (ifInfo->ifi_family == AF_UNSPEC) {
                        //获取路由信息的属性，以及消息负载的长度，通过这两个参数来判断本次的数据是否有效
                        struct rtattr *attribute = IFLA_RTA(ifInfo);
                        int attributeLen = IFLA_PAYLOAD(nlMsg);
                        
                        while (RTA_OK(attribute, attributeLen)) {
                            char *ifaceName = (char *)RTA_DATA(attribute);
                            if ((attribute->rta_type == IFLA_IFNAME) && (strcmp(ifaceName, "eth0")==0)) {
                            
                                //printf("____Interface: %s \n", ifaceName);
                                if((ifInfo->ifi_flags & IFF_LOWER_UP)) {
                                    if(plug_in==0) {
                                        system("ifup eth0");
                                        printf("____eth0 plug in\n");
                                        plug_in = 1; plug_out = 0;
                                    }
                                }
                                else  {
                                    if(plug_out==0) {
                                        system("ifdown eth0");
                                        printf("____eth0 plug out\n");
                                        plug_in = 0; plug_out = 1;
                                    }
                                }
                            }
                            attribute = RTA_NEXT(attribute, attributeLen);
                        }
                    }
                }
                nlMsg = NLMSG_NEXT(nlMsg, bytesRead);
            }
        }
    }

    close(nlSock);

quit:
    printf("___plug_thread exit\n");
    pthread_exit(NULL);
}
///////////////////////////////////////////////////////////



static void* polling_thread(void *arg)
{
    thread_handle_t *h=(thread_handle_t*)arg;

    //wdog_init();
    //tmp_create();
    while(h->quit==0) {
        
        sleep(1);
    }
    pthread_exit(NULL);
}




int sys_init(void)
{
    lock_s_init();
    paras_init();
    
    thread_start(THREAD_ID_POLLING, polling_thread, NULL);

    return 0;
}