udp广播配置

pro/CMakeLists.txt

@@ -123,6 +123,7 @@ set(PDU_SRC_LIST
 	${PROJECT_SOURCE_DIR}/src/hlw8110_handle.c
 	${PROJECT_SOURCE_DIR}/src/breaker_detection.c
 	${PROJECT_SOURCE_DIR}/src/cascade_slave_tcp.c
+	${PROJECT_SOURCE_DIR}/src/broadcast.c
 	)
 
 set(NO_WARNNING_FLAGS "-Wno-unused-function -Wno-unused-variable -Wno-unused-but-set-variable")
@@ -301,6 +302,7 @@ set(PDU_SRC_LIST
 	${PROJECT_SOURCE_DIR}/modbus/src/modbus-data.c
 	${PROJECT_SOURCE_DIR}/modbus/src/modbus-rtu.c
 	${PROJECT_SOURCE_DIR}/modbus/src/modbus-tcp.c
+	${PROJECT_SOURCE_DIR}/src/broadcast.c
 
 	)
 

pro/src/app.c

@@ -35,6 +35,7 @@
 #include "stdlib.h"
 #include "led.h"
 #include "beep.h"
+#include "broadcast.h"
 
 
 static void* power_thread(void* arg)
@@ -3558,6 +3559,11 @@ int app_init(void)
 
     upg_init();
     dev_Alarm_Run_message(_globalDeviceManager,language_alarm_Init_Success[0],"Server Thread");
+
+    broadcast_init();
+    
+//    thread_start(THREAD_ID_BROADCAST,broardcast_tread,NULL);
+//    thread_start(THREAD_ID_MULCAST,multcast_tread,NULL);
     
     return 0;
 }

pro/src/broadcast.c

@@ -0,0 +1,471 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <signal.h>
+#include <errno.h>
+#include "common.h"
+#include "sys.h"
+#include "cfg.h"
+#include <errno.h>
+#include "broadcast.h"
+#include "thread.h"
+
+
+
+
+
+
+typedef struct {
+    int broad_sock_fd;
+    int mul_sock_fd;
+    struct sockaddr_in broadcast_addr;
+    struct sockaddr_in bind_addr;
+    struct ip_mreq mreq;
+}broad_cast_t;
+
+static broad_cast_t broad_cast;
+
+extern GlobalDeviceManager __globalDeviceManage;
+
+
+#define BROADCAST_PORT 31002
+#define BROADCAST_INTERVAL 5
+#define MAX_MESSAGE_SIZE 1024
+#define MULTICAST_PORT 31001
+#define MULTICAST_GROUP "224.0.0.88"
+
+
+
+
+static volatile int running = 1;
+void signal_handler(int sig) {
+    running = 0;
+    printf("\nShutting down...\n");
+}
+
+
+#define TYPE_MESSGE          "{"\
+                                "\"version\":\"%s\","\
+                                "\"powerState\":\"on\","\
+                                "\"hostname\":\"%s\","\
+                                "\"product_id\":\"%s\","\
+                                "\"device_name\":\"%s\","\
+                                "\"https\":true,"\
+                                "\"network\":[{"\
+                                    "\"hostIP\":\"%s\","\
+                                    "\"netmask\":\"%s\","\
+                                    "\"gateway\":\"%s\","\
+                                    "\"dns1\":\"%s\","\
+                                    "\"dns2\":\"%s\","\
+                                    "\"mode\":\"%s\","\
+                                    "\"autoDNS\":true,"\
+                                    "\"macAddress\":\"%s\""\
+                                "}]"\
+                                "}\r\n"
+
+
+
+
+
+void * broard_thread(void *argc)
+{
+    NetworkInfo_t nw4;
+    int r4 = sys_get_net(&nw4, IP_V4);
+    thread_handle_t *h=(thread_handle_t*)argc;
+
+    char message[MAX_MESSAGE_SIZE] = {0};
+    GlobalDeviceManager *mgr = &__globalDeviceManage;
+
+    while(h->quit == 0)
+    {
+        int len = snprintf(message,sizeof(message),TYPE_MESSGE,
+            VERSION,
+            mgr->_globalDevInfo.product.name,
+            mgr->_globalDevInfo.product.pnumber,
+            mgr->_globalDevInfo.product.pname,
+            getLocalIpAddress("eth0"),
+            getLocalMask("eth0"),
+            getLocalGateway("eth0"),
+            nw4.dns1,
+            nw4.dns2,
+            nw4.mode == 0 ? "dhcp" : "static",
+            get_mac_address("eth0"));
+        ssize_t sent = sendto(broad_cast.broad_sock_fd, message, len, 0, (struct sockaddr *)&(broad_cast.broadcast_addr), sizeof(broad_cast.broadcast_addr));
+        if (sent < 0) {
+            fprintf(stderr, "sendto failed (errno %d: %s)\n", errno, strerror(errno));
+        } else {
+            printf("Broadcast Discovery message sent (%zd bytes)\n", sent);
+        }
+        sleep(BROADCAST_INTERVAL);
+    }
+    pthread_exit(NULL);
+}
+
+
+void* broard_mul_thread(void *argc)
+{
+    NetworkInfo_t nw4;
+    int r4 = sys_get_net(&nw4, IP_V4);
+    thread_handle_t *h=(thread_handle_t*)argc;
+    GlobalDeviceManager *mgr = &__globalDeviceManage;
+
+    char message[MAX_MESSAGE_SIZE] = {0};
+    char buffer[1024];
+    while(h->quit == 0)
+    {
+        struct sockaddr_in sender_addr;
+        socklen_t sender_len = sizeof(sender_addr);
+
+        ssize_t received = recvfrom(broad_cast.mul_sock_fd, buffer, sizeof(buffer) - 1, 0,
+                                   (struct sockaddr *)&sender_addr, &sender_len);
+
+        if (received > 0) {
+            buffer[received] = '\0';
+            printf("Received multicast request from %s:%d: %s\n", inet_ntoa(sender_addr.sin_addr), ntohs(sender_addr.sin_port), buffer);
+                        
+            // Check if it's a discovery request
+            if (strstr(buffer,"\"command\":\"discover\"") != NULL) {
+                        
+                printf("Discovery request received, sending multicast discovery message...\n");
+
+                int len = snprintf(message,sizeof(message),TYPE_MESSGE,
+                                    VERSION,
+                                    mgr->_globalDevInfo.product.name,
+                                    mgr->_globalDevInfo.product.pnumber,
+                                    mgr->_globalDevInfo.product.pname,
+                                    getLocalIpAddress("eth0"),
+                                    getLocalMask("eth0"),
+                                    getLocalGateway("eth0"),
+                                    nw4.dns1,
+                                    nw4.dns2,
+                                    nw4.mode == 0 ? "dhcp" : "static",
+                                    get_mac_address("eth0"));
+                        
+                ssize_t sent = sendto(broad_cast.mul_sock_fd, message, len, 0, (struct sockaddr *)&sender_addr, sizeof(sender_addr));
+                if (sent < 0) {
+                    fprintf(stderr, "sendto failed (errno %d: %s)\n", errno, strerror(errno));
+                } else {
+                    printf("Multicast Discovery message sent to %s:%d (%zd bytes)\n", inet_ntoa(sender_addr.sin_addr), ntohs(sender_addr.sin_port), sent);
+                }
+            }
+        } else if (received < 0) {
+            if (errno != EAGAIN && errno != EWOULDBLOCK) {
+                fprintf(stderr, "recvfrom failed (errno %d: %s)\n", errno, strerror(errno));
+                break;
+            }
+        }
+    }
+    pthread_exit(NULL);
+}
+
+
+
+
+
+void broadcast_init(void)
+{
+    GlobalDeviceManager *mgr = &__globalDeviceManage;
+    NetworkInfo_t nw4;
+    int r4 = sys_get_net(&nw4, IP_V4);
+
+    if(mgr->_globalDevInfo.broadcast.broad_enable)
+    {
+        broad_cast.broad_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+        if(broad_cast.broad_sock_fd < 0)
+        {
+            perror("socket");
+            goto faild;
+        }
+        int broadcast = 1;
+        if (setsockopt(broad_cast.broad_sock_fd, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast)) < 0) {
+            perror("setsockopt SO_BROADCAST");
+            goto faild1;
+        }
+        broad_cast.broadcast_addr.sin_family = AF_INET;
+        broad_cast.broadcast_addr.sin_port = htons(mgr->_globalDevInfo.broadcast.broadcast_port);
+        broad_cast.broadcast_addr.sin_addr.s_addr = inet_addr(mgr->_globalDevInfo.broadcast.boardcast_ip);
+        //create broard thread
+
+        thread_start(THREAD_ID_BROADCAST,broard_thread,NULL);
+
+        broad_cast.mul_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+        if( broad_cast.mul_sock_fd < 0)
+            goto failed_mul;
+        
+
+        int reuse = 1;
+        if (setsockopt(broad_cast.mul_sock_fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
+            perror("setsockopt SO_REUSEADDR");
+            goto failed_mul_1;
+        }
+        //struct sockaddr_in bind_addr;
+        memset(&broad_cast.bind_addr, 0, sizeof(broad_cast.bind_addr));
+        broad_cast.bind_addr.sin_family = AF_INET;
+        broad_cast.bind_addr.sin_port = htons(mgr->_globalDevInfo.broadcast.mulcast_port);
+        broad_cast.bind_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+        
+        if (bind(broad_cast.mul_sock_fd, (struct sockaddr *)&(broad_cast.bind_addr), sizeof(broad_cast.bind_addr)) < 0) {
+            perror("bind");
+            goto failed_mul_1;
+        }
+        int ttl = 255;
+        if (setsockopt(broad_cast.mul_sock_fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
+            perror("setsockopt IP_MULTICAST_TTL");
+            goto failed_mul_1;
+        }
+        int loopback = 0;
+        if (setsockopt(broad_cast.mul_sock_fd, IPPROTO_IP, IP_MULTICAST_LOOP, &loopback, sizeof(loopback)) < 0) {
+            perror("setsockopt IP_MULTICAST_LOOP");
+            goto failed_mul_1;
+        }  
+    
+    
+        //struct ip_mreq mreq;
+        broad_cast.mreq.imr_multiaddr.s_addr = inet_addr(mgr->_globalDevInfo.broadcast.mulcast_ip);
+        broad_cast.mreq.imr_interface.s_addr = htonl(INADDR_ANY);
+        if (setsockopt(broad_cast.mul_sock_fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &broad_cast.mreq, sizeof(broad_cast.mreq)) < 0) {
+            perror("setsockopt IP_ADD_MEMBERSHIP");
+           /*
+            char buff[256] = {0};
+            sprintf(buff,"ip route add default via %s dev eth0",nw4.gateway);
+            system(buff);
+            sleep(1);
+            if (setsockopt(broad_cast.mul_sock_fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &broad_cast.mreq, sizeof(broad_cast.mreq)) < 0) {
+                perror("setsockopt IP_ADD_MEMBERSHIP");
+                goto failed_mul_1;
+            } 
+            */
+           goto failed_mul_1;  
+        }         
+
+        struct timeval timeout;
+        timeout.tv_sec = 1;  // 1 second timeout
+        timeout.tv_usec = 0;
+        if (setsockopt(broad_cast.mul_sock_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
+            perror("setsockopt SO_RCVTIMEO");
+            goto failed_mul_1;
+        }
+        //create broard mul thread
+
+        thread_start(THREAD_ID_MULCAST,broard_mul_thread,NULL);
+    }
+
+    return;
+failed_mul_1:
+    close(broad_cast.mul_sock_fd);
+    broad_cast.mul_sock_fd = -1;
+failed_mul:
+    return;
+faild1:
+    close(broad_cast.broad_sock_fd);
+    broad_cast.broad_sock_fd = -1;
+faild:
+    return;
+}
+
+void broadcast_deinit(void)
+{
+    if(broad_cast.mul_sock_fd > 0)
+    {
+        close(broad_cast.mul_sock_fd);
+        thread_stop(THREAD_ID_MULCAST);
+        broad_cast.mul_sock_fd = -1;
+    }
+    if(broad_cast.broad_sock_fd > 0)
+    {
+        close(broad_cast.broad_sock_fd); 
+        thread_stop(THREAD_ID_BROADCAST);
+        broad_cast.broad_sock_fd = -1;
+    }
+}
+
+
+
+void* broardcast_tread(void* args)
+{
+
+    int port = BROADCAST_PORT;
+    char message[MAX_MESSAGE_SIZE] ={0};
+
+
+    // signal(SIGINT, signal_handler);
+    // signal(SIGTERM, signal_handler);
+    
+
+    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sockfd < 0) {
+        perror("socket");
+        return NULL;
+    }
+
+    int broadcast = 1;
+    if (setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast)) < 0) {
+        perror("setsockopt SO_BROADCAST");
+        close(sockfd);
+        return NULL;
+    }
+
+    struct sockaddr_in broadcast_addr = {0};
+    broadcast_addr.sin_family = AF_INET;
+    broadcast_addr.sin_port = htons(port);
+    broadcast_addr.sin_addr.s_addr = inet_addr("192.168.1.147");
+
+    // char ip[32]={0};
+    // char mac[32] = {0};
+    // char mask[32] = {0};
+    // char gateway[32] = {0};
+    NetworkInfo_t nw4;
+    int r4 = sys_get_net(&nw4, IP_V4);
+    //paras_data_t* para = paras_get();
+
+    while (running) {
+
+        
+        int len = snprintf(message,sizeof(message),TYPE_MESSGE,VERSION,"SmartPDU","1","",
+                                                                getLocalIpAddress("eth0"),
+                                                                getLocalMask("eth0"),
+                                                                getLocalGateway("eth0"),
+                                                                nw4.dns1,
+                                                                nw4.dns2,
+                                                                nw4.mode == 0 ? "dhcp" : "static",
+                                                                get_mac_address("eth0"));
+        ssize_t sent = sendto(sockfd, message, len, 0, (struct sockaddr *)&broadcast_addr, sizeof(broadcast_addr));
+        if (sent < 0) {
+            fprintf(stderr, "sendto failed (errno %d: %s)\n", errno, strerror(errno));
+        } else {
+            printf("Broadcast Discovery message sent (%zd bytes)\n", sent);
+        }
+        sleep(BROADCAST_INTERVAL);
+    }
+    close(sockfd);
+
+
+    pthread_exit(NULL);
+}
+
+
+
+
+void* multcast_tread(void* args)
+{
+    int port = MULTICAST_PORT;
+    char message[MAX_MESSAGE_SIZE] = {0};
+    // signal(SIGINT, signal_handler);
+    // signal(SIGTERM, signal_handler);
+    
+    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sockfd < 0) {
+        return NULL;
+    }
+    
+    int reuse = 1;
+    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
+        perror("setsockopt SO_REUSEADDR");
+        close(sockfd);
+        return NULL;
+    }
+
+    struct sockaddr_in bind_addr;
+    memset(&bind_addr, 0, sizeof(bind_addr));
+    bind_addr.sin_family = AF_INET;
+    bind_addr.sin_port = htons(port);
+    bind_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+    
+    if (bind(sockfd, (struct sockaddr *)&bind_addr, sizeof(bind_addr)) < 0) {
+        perror("bind");
+        close(sockfd);
+        return NULL;
+    }
+
+
+    int ttl = 255;
+    if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
+        perror("setsockopt IP_MULTICAST_TTL");
+        close(sockfd);
+        return NULL;
+    }
+    int loopback = 0;
+    if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_LOOP, &loopback, sizeof(loopback)) < 0) {
+        perror("setsockopt IP_MULTICAST_LOOP");
+        close(sockfd);
+        return NULL;
+    }  
+
+
+    struct ip_mreq mreq;
+    mreq.imr_multiaddr.s_addr = inet_addr(MULTICAST_GROUP);
+    mreq.imr_interface.s_addr = htonl(INADDR_ANY);
+    if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
+        perror("setsockopt IP_ADD_MEMBERSHIP");
+        close(sockfd);
+        return NULL;
+    }
+
+    struct timeval timeout;
+    timeout.tv_sec = 1;  // 1 second timeout
+    timeout.tv_usec = 0;
+    if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
+        perror("setsockopt SO_RCVTIMEO");
+        close(sockfd);
+        return NULL;
+    }
+
+    // Set up multicast send address
+    // struct sockaddr_in multicast_addr;
+    // memset(&multicast_addr, 0, sizeof(multicast_addr));
+    // multicast_addr.sin_family = AF_INET;
+    // multicast_addr.sin_port = htons(port);
+    // multicast_addr.sin_addr.s_addr = inet_addr(MULTICAST_GROUP);
+
+    char buffer[1024];
+    NetworkInfo_t nw4;
+    int r4 = sys_get_net(&nw4, IP_V4);
+
+    while (running) {
+        struct sockaddr_in sender_addr;
+        socklen_t sender_len = sizeof(sender_addr);
+
+        ssize_t received = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0,
+                                   (struct sockaddr *)&sender_addr, &sender_len);
+
+        if (received > 0) {
+            buffer[received] = '\0';
+            printf("Received multicast request from %s:%d: %s\n", inet_ntoa(sender_addr.sin_addr), ntohs(sender_addr.sin_port), buffer);
+                        
+            // Check if it's a discovery request
+            if (strstr(buffer, "\"command\":\"discover\"") != NULL) {
+                        
+                printf("Discovery request received, sending multicast discovery message...\n");
+
+                int len = snprintf(message,sizeof(message),TYPE_MESSGE,VERSION,"SmartPDU","1","",
+                                                                getLocalIpAddress("eth0"),
+                                                                getLocalMask("eth0"),
+                                                                getLocalGateway("eth0"),
+                                                                nw4.dns1,
+                                                                nw4.dns2,
+                                                                nw4.mode == 0 ? "dhcp" : "static",
+                                                                get_mac_address("eth0"));
+                        
+                ssize_t sent = sendto(sockfd, message, len, 0, (struct sockaddr *)&sender_addr, sizeof(sender_addr));
+                if (sent < 0) {
+                    fprintf(stderr, "sendto failed (errno %d: %s)\n", errno, strerror(errno));
+                } else {
+                    printf("Multicast Discovery message sent to %s:%d (%zd bytes)\n", inet_ntoa(sender_addr.sin_addr), ntohs(sender_addr.sin_port), sent);
+                }
+            }
+        } else if (received < 0 && running) {
+            if (errno != EAGAIN && errno != EWOULDBLOCK) {
+                fprintf(stderr, "recvfrom failed (errno %d: %s)\n", errno, strerror(errno));
+                break;
+            }
+        }
+
+    }
+    close(sockfd);
+    pthread_exit(NULL);
+
+}

pro/src/broadcast.h

@@ -0,0 +1,29 @@
+#ifndef __BROAD_CAST_H
+#define __BROAD_CAST_H
+
+
+
+
+
+
+
+
+void broadcast_deinit(void);
+void broadcast_init(void);
+
+
+// void* broardcast_tread(void* args);
+
+// void* multcast_tread(void* args);
+
+
+
+
+
+
+
+
+
+
+#endif
+

pro/src/common.c

@@ -242,6 +242,84 @@ char* get_mac_address(const char *iface_name)
     return mac_str;  
 }
 
+char *getLocalMask(char *dev)
+{
+    int fd;
+    struct ifreq ifr;
+    static char ip_addr[64];
+
+    fd = socket(AF_INET, SOCK_DGRAM, 0);
+    ifr.ifr_addr.sa_family = AF_INET;
+    strncpy(ifr.ifr_name, dev, IFNAMSIZ-1);
+ 
+    ioctl(fd, SIOCGIFNETMASK, &ifr);
+    close(fd);
+    char *p =inet_ntoa(((struct sockaddr_in *)&ifr.ifr_netmask)->sin_addr);
+
+    strcpy(ip_addr, p);
+
+    return ip_addr;      
+}
+
+
+// 将32位整数IP地址转换为点分十进制格式
+static char* int_to_ip(unsigned int ip) {
+    struct in_addr addr;
+    static char ip_addr[64];
+    addr.s_addr = ip;
+    char *p = inet_ntoa(addr);
+    strcpy(ip_addr, p);
+    return ip_addr;
+}
+
+char *getLocalGateway(char *dev)
+{
+    FILE *fp;
+    char line[256];
+    char iface[16];
+    unsigned int destination, gateway, mask;
+    int flags, refcnt, use, metric, mtu, window, irtt;
+
+    unsigned int gate_way = 0;
+
+    fp = fopen("/proc/net/route", "r");
+    if (fp == NULL) {
+        perror("fopen /proc/net/route");
+        return NULL;
+    }
+
+    //printf("Gateways from /proc/net/route:\n");
+    //printf("%-12s %-15s %-15s %-15s %s\n", 
+    //       "Interface", "Destination", "Gateway", "Netmask", "Flags");
+    //printf("------------ --------------- --------------- --------------- -----\n");
+
+    // 跳过第一行标题
+    fgets(line, sizeof(line), fp);
+
+    while (fgets(line, sizeof(line), fp)) {
+        int count = sscanf(line, "%15s %x %x %x %d %d %d %x %d %d %d",
+                          iface, &destination, &gateway, &mask,
+                          &flags, &refcnt, &use, &metric, &mtu, &window, &irtt);
+        
+
+        if (count >= 4) {
+            // 显示默认网关（目标为0.0.0.0）或所有路由
+            // printf("%-12s %-15s %-15s %-15s 0x%04X\n",
+            //        iface,
+            //        int_to_ip(destination),
+            //        int_to_ip(gateway),
+            //        int_to_ip(mask),
+            //        flags);
+            //    int_to_ip(destination)
+            //sprintf(gate_way,"%s",gateway);
+            gate_way = destination;
+        }
+    }
+
+    fclose(fp);
+
+    return int_to_ip(gate_way);
+}
 
 
 

pro/src/common.h

@@ -418,6 +418,16 @@ typedef struct
     char                account[64];
 }sms_recv_t;
 
+
+typedef struct { 
+    uint8_t     broad_enable;          
+    uint16_t    broadcast_port;
+    uint16_t    mulcast_port;
+    char        boardcast_ip[64];
+    char        mulcast_ip  [64];
+//    char        cmd[128];
+}mulcast_t;
+
 typedef struct
 {
     bool Cellular_enable; // 4G模块启用状态
@@ -484,7 +494,8 @@ typedef struct
     MiscInfo_t      misc;
 
     CellInfo_t      cell;
-    WIFIInfo_t     wifi;
+    WIFIInfo_t      wifi;
+    mulcast_t       broadcast;          //udp 广播
 }GlobalDeviceInfo;
 ///////////////////////////////////////////////////////////////////////////////////
 //自定义共享内存类
@@ -1399,7 +1410,13 @@ void printf_power_info(GlobalPowerInfo* _globalPowerInfo);
 
 
 int getTotalMemorySize(unsigned int* totalSize);
+
 char* getLocalIpAddress(char* dev);
+char *getLocalMask(char *dev);
+char *getLocalGateway(char *dev);
+
+
+
 char* get_mac_address(const char *iface_name) ;
 void get_disk_occupy(char ** reused);
 

pro/src/dflt.c

@@ -141,6 +141,14 @@ GlobalDeviceInfo DFLT_PARAS={
         .WIFI_name = "",
         .WIFI_code= "",
     },
+    .broadcast = {
+        .broad_enable = 0,
+        .broadcast_port = 31002,
+        .mulcast_port   = 31001,
+        .boardcast_ip   = "",       
+        .mulcast_ip     = "",
+//        .cmd            = "\"command\":\"discover\"",
+    },
 };
 
 

pro/src/paras.c

@@ -1110,6 +1110,155 @@ static int proc_cellular(dictionary *dic, int op, CellInfo_t *cell)
 
     return r;
 }
+static int proc_mulcast(dictionary *dic,int op, mulcast_t * mulcast)
+{
+    int r=0;
+    char temp[128];
+    char *p,*token=NULL;
+    if(op==PARAS_CHECK) {
+        if (mulcast->broad_enable > 1)
+        {
+            LOGE("___ check mulcast_t, mode is invalid, correct value is 0/1\n");
+            r = -1;
+        }
+        return r;
+    }
+    else if (op==PARAS_CREATE) {
+
+    }else if(op== PARAS_WRITE)
+    {
+        r = proc_mulcast(dic, PARAS_CHECK, mulcast);
+        if(r) {
+            return -1;
+        }
+    }    
+    token = "broadcast:broad_enable";
+    if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            mulcast->broad_enable = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", mulcast->broad_enable);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+
+    token = "broadcast:broadcast_port";
+    if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            mulcast->broadcast_port = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", mulcast->broadcast_port);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+
+    token = "broadcast:mulcast_port";
+    if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            mulcast->mulcast_port = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", mulcast->mulcast_port);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+
+    token = "broadcast:boardcast_ip";
+    if(op==PARAS_READ) {
+       const char *str = iniparser_getstring(dic, token, NULL);
+        if(str == NULL) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            strcpy(mulcast->boardcast_ip,str);
+            //mulcast->boardcast_ip = r;
+        }
+    }
+    else {
+        sprintf(temp, "%s", mulcast->boardcast_ip);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+
+
+    token = "broadcast:mulcast_ip";
+    if(op==PARAS_READ) {
+        const char *str = iniparser_getstring(dic, token, NULL);
+        if(str == NULL) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            strcpy(mulcast->mulcast_ip,str);
+            //mulcast->boardcast_ip = r;
+        }
+    }
+    else {
+        sprintf(temp, "%s", mulcast->mulcast_ip);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+    /*
+        token = "broadcast:cmd";
+        if(op==PARAS_READ) {
+            const char *str = iniparser_getstring(dic, token, NULL);
+            if(str == NULL) {
+                LOGE("___ iniparser_getint %s failed\n", token);
+                return -1;
+            } else {
+                strcpy(mulcast->cmd,str);
+                //mulcast->boardcast_ip = r;
+            }
+        }
+        else {
+            sprintf(temp, "%s", mulcast->cmd);
+            r = iniparser_set(dic, token, temp);
+            if(r) {
+                LOGE("___ iniparser_set %s failed\n", token);
+                return -1;
+            }
+        }
+    */
+    r = 0;
+    if(op==PARAS_READ) {
+        r = proc_mulcast(dic, PARAS_CHECK, mulcast);
+    }
+    return r;
+
+}
+
+
 static int proc_wifi(dictionary *dic, int op, WIFIInfo_t *pWIFIManager)
 {
     int r=0;
@@ -1235,6 +1384,10 @@ static int proc_wifi(dictionary *dic, int op, WIFIInfo_t *pWIFIManager)
 
     return r;
 }
+
+
+
+
 static int proc_ntp(char *path, int op, NTPManager *ntp)
 {
     int r=0;
@@ -3642,6 +3795,10 @@ static dictionary* ini_load(char *path, GlobalDeviceInfo *info)
         LOGE("___proc_wifi failed\n");
     }
 
+    r = proc_mulcast(dic, PARAS_READ, &info->broadcast);
+    if(r) {
+        LOGE("___proc_mulcast failed\n");
+    }
     r = proc_misc(dic, PARAS_READ, &info->misc);
     if(r) {
         LOGE("___proc_misc failed\n");
@@ -3732,8 +3889,18 @@ static int ini_reset(paras_handle_t *h)
     fprintf(fp, "ip          = \"%s\"\n", info->wifi.WIFI_ip);
     fprintf(fp, "ssid        = \"%s\"\n", info->wifi.WIFI_name);
     fprintf(fp, "password    = \"%s\"\n", info->wifi.WIFI_code);
+    fprintf(fp, "\n");
 
+
+    fprintf(fp, "[broadcast]\n");
+    fprintf(fp, "broad_enable        = \"%d\"\n", info->broadcast.broad_enable);
+    fprintf(fp, "broadcast_port      = \"%d\"\n", info->broadcast.broadcast_port);
+    fprintf(fp, "mulcast_port        = \"%d\"\n", info->broadcast.mulcast_port);
+    fprintf(fp, "boardcast_ip        = \"%s\"\n", info->broadcast.boardcast_ip);
+    fprintf(fp, "mulcast_ip          = \"%s\"\n", info->broadcast.mulcast_ip);  
+    //fprintf(fp, "cmd                 = \"%s\"\n", info->broadcast.cmd);  
     fprintf(fp, "\n");
+
     fclose(fp);
 
     sys_get_path(tmp, INI_FILE_BAK_NAME);
@@ -3793,6 +3960,11 @@ static int ini_save(paras_handle_t *h)
         LOGE("___proc_misc failed\n");
     }
 
+    r = proc_mulcast(h->dic, PARAS_WRITE, &h->info->broadcast);
+    if(r) {
+        LOGE("___proc_mulcast failed\n");
+    }
+
     FILE *fp=fopen(h->path, "w");
     if(!fp) {
         LOGE("___%s open failed\n", h->path);

pro/src/sys.c

@@ -633,6 +633,9 @@ static int set_dns(NetworkInfo_t *para)
 
     r = file_save(FILE_DNS, buf, strlen(buf))+1;
     if(r==0) {
+#if(CHIP_TYPE == CHIP_T113s)
+        system("mkdir -p /var/run");
+#endif
         system("killall dnsmasq; /usr/sbin/dnsmasq &");
     }
 

pro/src/thread.c

@@ -30,6 +30,8 @@ static thread_attr_t thdAttrs[THREAD_ID_MAX]={
     {"ui",          NULL,           NULL,           STACK_SZ,       1},
     {"Cellular",    NULL,           NULL,           STACK_SZ,       1},
     {"RECV_MESSAGE_QUEUE",    NULL,           NULL,           STACK_SZ,       1},
+    {"broadcast",   NULL,           NULL,           STACK_SZ,       1},
+    {"mul_broadcast",   NULL,           NULL,           STACK_SZ,       1},
 };
 static thread_handle_t thdHandles[THREAD_ID_MAX]={0};
 

pro/src/thread.h

@@ -34,7 +34,8 @@ enum {
     THREAD_ID_UI,
     THREAD_ID_CELLULAR,
     THREAD_ID_RECV_MESSAGE_QUEUE,//进程间通信队列处理线程
-
+    THREAD_ID_BROADCAST,
+    THREAD_ID_MULCAST,
     THREAD_ID_MAX
 };