【智能家居】四、网络服务器线程控制功能点

网络控制
网络线程控制功能点代码

• inputCommand.h（输入控制指令）
• socketControl.c（socket网络控制指令）
• main.c（主函数）
• 编译
• 运行结果

网络控制

Linux网络编程

“网络控制”（Network Control）通常指的是通过网络对远程设备、系统或服务进行管理和监控的过程。这可以包括远程设备的配置、监测、故障排除、升级等操作。网络控制的目的是在分布式环境中实现对各种网络设备和资源的远程管理。

网络控制的关键特性和功能包括：

1. 远程管理： 允许管理员或系统操作员通过网络连接到远程设备或系统，执行各种管理任务，而无需物理接触设备。

2. 配置管理： 能够通过网络修改和配置设备的各种参数，例如网络设置、安全配置、服务设置等。

3. 监控和诊断： 实时监测远程设备的性能、状态和运行情况，以及执行远程故障诊断。

4. 远程升级： 允许通过网络远程升级设备的固件、软件或操作系统，以确保设备始终具有最新的功能和安全性。

5. 故障排除： 提供对设备进行故障排除的工具和功能，以便在出现问题时进行远程修复。

6. 安全性： 网络控制需要具备安全机制，以确保远程访问和操作的安全性，包括身份验证、加密通信等。

7. 自动化： 通过网络控制可以实现自动化操作，例如定期计划的任务、自动备份等。

8. 远程命令执行： 允许通过网络发送命令到远程设备执行，这对于远程调试和控制非常有用。

网络控制在各种领域都有应用，包括物联网设备、网络设备、服务器管理、远程监控系统等。这种远程控制的能力在大规模、分布式、或难以物理接触的环境中尤为重要，可以提高效率、降低成本，并加强对整个网络基础设施的管理和控制。

以下是一个基于 POSIX 线程的简单网络控制的例子：

#include 
#include 
#include 

// 模拟网络控制的数据结构
struct NetworkControl {
    int isConnected; // 模拟网络连接状态
    pthread_mutex_t mutex; // 用于同步的互斥锁
};

// 初始化网络控制
void initNetworkControl(struct NetworkControl *network) {
    network->isConnected = 0;
    pthread_mutex_init(&network->mutex, NULL);
}

// 模拟网络连接函数
void connectToNetwork(struct NetworkControl *network) {
    pthread_mutex_lock(&network->mutex);
    network->isConnected = 1;
    pthread_mutex_unlock(&network->mutex);
    printf("Connected to the network.\n");
}

// 模拟网络断开函数
void disconnectFromNetwork(struct NetworkControl *network) {
    pthread_mutex_lock(&network->mutex);
    network->isConnected = 0;
    pthread_mutex_unlock(&network->mutex);
    printf("Disconnected from the network.\n");
}

// 网络控制线程执行函数
void *networkControlThread(void *data) {
    struct NetworkControl *network = (struct NetworkControl *)data;

    while (1) {
        // 模拟网络连接和断开
        connectToNetwork(network);
        sleep(2);
        disconnectFromNetwork(network);
        sleep(2);
    }

    pthread_exit(NULL);
}

int main() {
    // 初始化网络控制
    struct NetworkControl network;
    initNetworkControl(&network);

    pthread_t network_control_thread;

    // 创建网络控制线程
    if (pthread_create(&network_control_thread, NULL, networkControlThread, (void *)&network) != 0) {
        fprintf(stderr, "Failed to create network control thread.\n");
        return 1;
    }

    // 主函数等待网络控制线程退出
    pthread_join(network_control_thread, NULL);

    // 销毁互斥锁
    pthread_mutex_destroy(&network.mutex);

    return 0;
}

在这个例子中，我们使用了一个简单的数据结构 struct NetworkControl 来表示网络控制状态，使用互斥锁 pthread_mutex_t 来确保线程安全。网络控制线程不断地模拟连接和断开操作。主函数等待网络控制线程退出，然后销毁互斥锁。这只是一个简单的例子，实际中可能需要根据具体需求进行更复杂的网络控制实现。

网络线程控制功能点代码

inputCommand.h（输入控制指令）

#include 
#include 
#include 
#include 
#include 
#include       
#include 
#include 
#include 
#include 
#include 
 
struct InputCommand
{
    char commandName[128];                              //“控制方式”名
    char deviceName[128];               				//“设备工厂”名
    char command[32];                                   //存放指令
    int fd;                                             //存放文件描述符（串口/网络）
    int s_fd;									        //存放服务器套接字描述符
    char port[12];								        //存放端口号
    char ipAdress[32];							        //存放 IP地址
    char log[1024];                                     //日志
    int (*Init)(struct InputCommand *voice);            //“初始化”函数指针
    int (*getCommand)(struct InputCommand *voice);      //“获取指令”函数指针
 
    struct InputCommand *next;
};
 
struct InputCommand* addVoiceControlToInputCommandLink(struct InputCommand *phead);	//“语音控制”加入指令链表函数声明

struct InputCommand* addSocketControlToInputCommandLink(struct InputCommand *phead); //“网络控制”加入指令链表函数声明

socketControl.c（socket网络控制指令）

#include "inputCommand.h"
 
// 套接字初始化函数 
int socketInit(struct InputCommand *socketMsg)
{
    int s_fd;                                       //套接字描述符
	struct sockaddr_in s_addr;
	memset(&s_addr, 0, sizeof(struct sockaddr_in));   //数据清空
 
    // 1. 创建套接字，ipv4，tcp协议
	s_fd=socket(AF_INET, SOCK_STREAM, 0);
	if (s_fd == -1) {
		perror("socket:");
		exit(-1);
	}
 
    s_addr.sin_family = AF_INET;                        //ipv4
	s_addr.sin_port = htons(atoi(socketMsg->port));     //端口号，选择5000以上。honts返回网络字节序,atoi(argv[2])防止端口被占用
	inet_aton(socketMsg->ipAdress, &s_addr.sin_addr);    //转换为网络能识别的格式
 
    // 2. 绑定
	bind(s_fd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr_in));
 
    // 3. 监听
	listen(s_fd, 10); //监听10个连接
    printf("socket Server listening ...\n");
 
    socketMsg->s_fd = s_fd;	// 保存套接字描述符

    return s_fd;
}
 
// 全局变量，表示 socket 控制的输入命令对象
struct InputCommand socketControl = {
    .commandName = "socket",
    .command = '\0',
    .port = "8080",
    .ipAdress = "192.168.1.254",
    .Init = socketInit,
    .log = {'\0'},
    .next = NULL
};

// 将 socket 控制对象加入到输入命令链表中的函数
struct InputCommand* addSocketControlToInputCommandLink(struct InputCommand *phead)
{
	if (phead == NULL) {
		return &socketControl;
	}
	else {
		socketControl.next = phead;
		phead = &socketControl;
		
		return phead;
	}
}

main.c（主函数）

#include 
#include "controlDevice.h"
#include "inputCommand.h"

struct InputCommand *pcommandHead = NULL; // 定义指令工厂初始链表头
struct InputCommand *socketHandler = NULL; // 全局变量，用于处理 socket 控制

// 读取 TCP 端口指令的线程执行函数
void *socketReadThread(void *data) 
{
    int n_read;
    printf("Connect success\n");

    while (1) {
        memset(socketHandler->command, '\0', sizeof(socketHandler->command));
        n_read = read(socketHandler->fd, socketHandler->command, sizeof(socketHandler->command));

        if (n_read == -1) {
            perror("read:");
        } 
        else {
            printf("Get SocketCommand --> %s\n", socketHandler->command);
        }
    }
}

// 网络控制线程执行函数
void *socketControlThread(void *data) 
{
    int c_fd; // 客户端套接字描述符
    struct sockaddr_in c_addr;
    memset(&c_addr, 0, sizeof(struct sockaddr_in));
    int clen = sizeof(struct sockaddr_in);

    pthread_t socketRead_thread; // 线程里面套线程，网络连接后信息通信

    // 查找名为 "socket" 的指令处理对象
    socketHandler = findCommandByName("socket", pcommandHead);

    if (socketHandler == NULL) {
        printf("find socketHandler error\n");
        pthread_exit(NULL);
    }

    // 初始化网络控制功能
    if (socketHandler->Init(socketHandler) < 0) {
        printf("socketControl init error\n");
        pthread_exit(NULL);
    } 
    else {
        printf("socketControl init success\n");
    }

    while (1) {
        // 4. 接收连接
        c_fd = accept(socketHandler->s_fd, (struct sockaddr *)&c_addr, &clen); // 接收连接请求，阻塞至有客户端完成三次握手
        socketHandler->fd = c_fd;                                               // 将套接字描述符返回给 "网络控制" 链表节点
        pthread_create(&socketRead_thread, NULL, socketReadThread, NULL);        // 创建新线程：用于读取 TCP 端口指令
    }
}

int main() 
{
    if (wiringPiSetup() == -1) {
        fprintf(stdout, "Unable to start wiringPi: %s\n", strerror(errno));
        return 1;
    }

    pthread_t socketControl_thread;

    // 指令工厂初始化，将 socket 控制对象加入到输入命令链表中
    pcommandHead = addSocketControlToInputCommandLink(pcommandHead);

    // 创建网络控制线程
    pthread_create(&socketControl_thread, NULL, socketControlThread, NULL);

    // 主函数等待网络控制线程退出
    pthread_join(socketControl_thread, NULL);

    return 0;
}