C/S系统实现两数求和(非阻塞+epoll+心跳包检测用户在线状况+滚动日志+配置文件.)

2023-08-06 08:16:58

C/S系统实现两数求和

任务要求：

实现配置文件
实现日志滚动
设置非阻塞套接字，EPOLL实现
检测客户端的连接，设置心跳检测
主线程 + 心跳检测线程 + EPOLL的ET模式处理事务线程

注意事项：设置volatile类型跳出死循环

作品简介：

本次实验分为bin,config,include,log,src五个文件夹以及一个makefile文件，下面是里面的具体内容以及功能详解：

bin: 存放二进制文件，生成的可执行文件，执行本系统只需在超级终端打开即可。
config：存放配置文件，客户可以在里面设置所要连接的服务器的ip以及端口，以及所要发送的数据。
include：存放本系统的头文件。
log：存放日志文件，当一个文件大于10M的时候会新建一个文件存放名是log+数字，后缀名是txt。
src：存放本系统的源代码，里面两个文件夹，client存放客户机的源代码，server存放服务器的源代码。
makefile：本系统的编译文件，在终端打开主目录，输入命令make即可。

具体实现：

客户机：

头部是一个短整型，存放数据包的格式；

0代表发送的是心跳包，4代表发送的是不完整包，8代表发送的包完整。
然后是一个长度为16的字符数组，存放客户的名字，这里用客户的ip来代替。
接下来是两个整型代表发送的两个数字，也就是本任务发送的主要数据。

客户端每隔3秒发送一个心跳包，由服务器检测心跳，从配置文件读取发送的数据向客户端发送数据，由服务器检测数据完整性，ip和端口存放在配置文件的IP项目下，数据在TWONUMBER项目下。
接收从服务端发来的数据，用data_type判断当前数据是否完整，完整就接受输出从服务器得到的数据；

服务器：
- 服务器实现检测连接，epoll处理事物，两种工作模式（et， lt）

主线程里面包含两个线程，心跳检测线程以及et/lt事物处理线程：
- 心跳检测线程：
  
  检测用户是否掉线，每隔3秒计数器加1，当et接收到客户传来的数据包时，重置计数器，当计数器达到5的时候断开连接。用户用链表连接。
- et事物处理线程：
  
  接受客户端发来的连接，处理客户端发来的数据包，完整性检测。
- lt事物处理线程：
  
  由于本次任务是et模式下，所以lt只是实现了接收数据，如果想要查看效果则需要在server.c中把et换为lt即可，lt工作模式比较简单，由于lt在接收数据时，一次没接收完，下次还会发送事物请求，所以不必要一次接收完，只需要判断连接请求建立连接，发送请求接收数据即可，不必要循环接收。

实现代码：

客户端代码：

client.c:客户端主代码

#include "handsomecui.h"

#include "config.h"

#include "heart_client.h"

#define BUFFER_SIZE 40

int main(int argc, char *argv[])

{

    int client_sockfd;

    int len;

    struct sockaddr_in remote_addr;

    memset(&remote_addr,,sizeof(remote_addr));

    remote_addr.sin_family=AF_INET;

    char s_ip[];

    GetConfigFileStringValue("IPANDPORT", "IP", "127.0.0.1", s_ip, sizeof(s_ip), "Config.ini");

    printf("IP : %s\n", s_ip);

    remote_addr.sin_addr.s_addr=inet_addr(s_ip);

    uint16_t port = GetConfigFileIntValue("IPANDPORT", "PORT", , "Config.ini");

    printf("port : %d\n", (int)port);

    if (port == -)

    {

        printf("Get port failed!\n");

        return -;

    }

    remote_addr.sin_port=htons(port); 

    client_sockfd=socket(PF_INET,SOCK_STREAM,);

    if(client_sockfd<)

    {

        perror("client socket creation failed");

        exit(EXIT_FAILURE);

    }

    if(connect(client_sockfd,(struct sockaddr *)&remote_addr,sizeof(struct sockaddr))<)

    {

        perror("connect to server failed");

        exit(EXIT_FAILURE);

    }

    pthread_t pth;

    int err;

    int *client_sockfd_1 = (int *)malloc(sizeof(int));

    *client_sockfd_1 = client_sockfd;

    if((err = pthread_create(&pth, NULL, send_heart, (void *)client_sockfd_1)) != ){

    fprintf(stderr, "pthread_create: %s\n", strerror(err));

    exit();

    }

    sleep();

    pd = (DATA_PACK *)malloc(sizeof(DATA_PACK));

    char *buf = (char *)malloc(sizeof(*pd));

    pd->data_type = ;

    strcpy(pd->name, "127.0.0.1");

    pd->num1= (int )GetConfigFileIntValue("TWONUMBER", "NUMBER1", 0xfffffff, "Config.ini");

    pd->num2 = (int )GetConfigFileIntValue("TWONUMBER", "NUMBER2", 0xfffffff, "Config.ini");

    len = sizeof(*pd);

    memcpy(buf, pd, len);

    send(client_sockfd,buf,len,);

    free(pd);

    len=recv(client_sockfd,pd,BUFFER_SIZE,);

    if(pd->data_type == )

        printf("receive from server %s:  %d\n",pd->name, pd->num1);

    else

        printf("receive from server %s:  发送数字个数不正确\n", pd->name);

    if(len<)

    {

        perror("receive from server failed");

        exit(EXIT_FAILURE);

    }

    close(client_sockfd);

    return ;

}

config.c:配置文件

#include "config.h"

void GetCompletePath(UINT8 *pszConfigFileName, UINT8 *pszWholePath)

{

    UINT8 *pszHomePath      = NULL;

    UINT8  szWholePath[] = {};

    if (pszConfigFileName == NULL || pszWholePath == NULL)

    {

        printf("GetCompletePath: input parameter(s) is NULL!\n");

        return;

    }

    pszHomePath = (UINT8 *)getenv("HOME");

    if (pszHomePath == NULL)

    {

        printf("GetCompletePath: Can't find home path!\n");

        return;

    }

    snprintf(szWholePath, sizeof(szWholePath)-, "/home/handsome/work/socket/Cuijunyong_3/config/%s", pszConfigFileName);

    strncpy(pszWholePath, szWholePath, strlen(szWholePath));

}

void GetStringContentValue(FILE *fp, UINT8 *pszSectionName, UINT8 *pszKeyName, UINT8 *pszOutput, UINT32 iOutputLen)

{

    UINT8  szSectionName[]    = {};

    UINT8  szKeyName[]        = {};

    UINT8  szContentLine[]    = {};

    UINT8  szContentLineBak[] = {};

    UINT32 iContentLineLen       = ;

    UINT32 iPositionFlag         = ;

    if (fp == NULL || pszSectionName == NULL || pszKeyName == NULL || pszOutput == NULL)

    {

        printf("GetStringContentValue: input parameter(s) is NULL!\n");

        return;

    }

    sprintf(szSectionName, "[%s]", pszSectionName);

    strcpy(szKeyName, pszKeyName);

    while (feof(fp) == )

    {

        memset(szContentLine, 0x00, sizeof(szContentLine));

        fgets(szContentLine, sizeof(szContentLine), fp);      

        if (szContentLine[] == ';' || szContentLine[] == '\r' || szContentLine[] == '\n' || szContentLine[] == '\0')

        {

            continue;

        }

        if (strncasecmp(szSectionName, szContentLine, strlen(szSectionName)) == )

        {

            while (feof(fp) == )

            {

                memset(szContentLine,    0x00, sizeof(szContentLine));

                memset(szContentLineBak, 0x00, sizeof(szContentLineBak));

                fgets(szContentLine, sizeof(szContentLine), fp);   

                if (szContentLine[] == ';')

                {

                    continue;

                }

                memcpy(szContentLineBak, szContentLine, strlen(szContentLine));

                if (strncasecmp(szKeyName, szContentLineBak, strlen(szKeyName)) == )

                {

                    iContentLineLen = strlen(szContentLine);

                    for (iPositionFlag = strlen(szKeyName); iPositionFlag <= iContentLineLen; iPositionFlag ++)

                    {

                        if (szContentLine[iPositionFlag] == ' ')

                        {

                            continue;

                        }

                        if (szContentLine[iPositionFlag] == '=')

                        {

                            break;

                        }

                        iPositionFlag = iContentLineLen + ;

                        break;

                    }

                    iPositionFlag = iPositionFlag + ;    

                    if (iPositionFlag > iContentLineLen)

                    {

                        continue;

                    }

                    memset(szContentLine, 0x00, sizeof(szContentLine));

                    strcpy(szContentLine, szContentLineBak + iPositionFlag);

                    for (iPositionFlag = ; iPositionFlag < strlen(szContentLine); iPositionFlag ++)

                    {

                        if (szContentLine[iPositionFlag] == '\r' || szContentLine[iPositionFlag] == '\n' || szContentLine[iPositionFlag] == '\0')

                        {

                            szContentLine[iPositionFlag] = '\0';

                            break;

                        }

                    }

                    strncpy(pszOutput, szContentLine, iOutputLen-);

                    break;

                }

                else if (szContentLine[] == '[')

                {

                    break;

                }

            }

            break;

        }

    }

}

void GetConfigFileStringValue(UINT8 *pszSectionName, UINT8 *pszKeyName, UINT8 *pDefaultVal, UINT8 *pszOutput, UINT32 iOutputLen, UINT8 *pszConfigFileName)

{

    FILE  *fp                    = NULL;

    UINT8  szWholePath[]      = {};

    if (pszSectionName == NULL || pszKeyName == NULL || pszOutput == NULL || pszConfigFileName == NULL)

    {

        printf("GetConfigFileStringValue: input parameter(s) is NULL!\n");

        return;

    }

    if (pDefaultVal == NULL)

    {

        strcpy(pszOutput, "");

    }

    else

    {

        strcpy(pszOutput, pDefaultVal);

    }

    GetCompletePath(pszConfigFileName, szWholePath);

    fp = fopen(szWholePath, "r");

    if (fp == NULL)

    {

        printf("GetConfigFileStringValue: open %s failed!\n", szWholePath);

        return;

    }

    GetStringContentValue(fp, pszSectionName, pszKeyName, pszOutput, iOutputLen);

    fclose(fp);

    fp = NULL;

}

INT32 GetConfigFileIntValue(UINT8 *pszSectionName, UINT8 *pszKeyName, UINT32 iDefaultVal, UINT8 *pszConfigFileName)

{

    UINT8  szGetValue[] = {};

    INT32  iGetValue       = ;

    if (pszSectionName == NULL || pszKeyName == NULL || pszConfigFileName == NULL)

    {

        printf("GetConfigFileIntValue: input parameter(s) is NULL!\n");

        return -;

    }

    GetConfigFileStringValue(pszSectionName, pszKeyName, NULL, szGetValue, -, pszConfigFileName);   

    if (szGetValue[] == '\0' || szGetValue[] == ';')

    {

        iGetValue = iDefaultVal;

    }

    else

    {

        iGetValue = atoi(szGetValue);

    }

    return iGetValue;

}

heart_client.c：心跳发送

#include "handsomecui.h"

#include "heart.h"

void *send_heart(void *addr)

{

    int* client_sockfd = (int*)addr;

    printf("client_socket: %d\n", *client_sockfd);

    pd = (DATA_PACK *)malloc(sizeof(DATA_PACK));

    pd->data_type = ;

    strcpy(pd->name, "127.0.0.1");

    while(){

//    write(client_sockfd,pd,sizeof(DATA_PACK));

    send(*client_sockfd,pd,sizeof(*pd),);

    sleep(); //定时3秒

    }

    free(client_sockfd);

    free(pd);

    return NULL;

}

服务端代码

addfd.c：添加epoll事件

#include "handsomecui.h"

#include "addfd.h"

void addfd(int epollfd, int fd, int flag){

    struct epoll_event event;

    memset(&event, 0x00, sizeof(event));

    event.data.fd = fd;

    event.events = EPOLLIN;

    if(flag){

        event.events |= EPOLLET;

    }

    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);

    setnonblocking(fd);

}

et.c：et工作模式

#include "handsomecui.h"

#include "et.h"

#include "heart.h"

extern s_t *s_head;

#define MAX_LEN 1024

extern volatile g_stop;

void *et(void *arg){

    pth_etlt *pth_arg = (pth_etlt *)arg;

    struct epoll_event* events = pth_arg->events;

    int number = pth_arg->number;

    int epollfd = pth_arg->epollfd;

    int listenfd = pth_arg->listenfd;

    int i;

    DATA_PACK *data = (DATA_PACK *)malloc(sizeof(DATA_PACK));

    int p = ;

    DATA_PACK *num = (DATA_PACK *)malloc(sizeof(DATA_PACK));

    char *buf = (char *)malloc(sizeof(*num));

    int len = sizeof(*num);

    for(i = ; i < number; i++){

    int sockfd = events[i].data.fd;

    struct sockaddr_in client_address;

    if(sockfd == listenfd){

        socklen_t client_addresslen = sizeof(client_address);

            int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addresslen);

        addfd(epollfd, connfd, );

        printf("client ip: %s  port: %d\n", inet_ntoa(client_address.sin_addr),ntohs(client_address.sin_port));

        s_t *p = (s_t *)malloc(sizeof(s_t)), *q;

        strcpy(p->peerip, inet_ntoa(client_address.sin_addr));

        strcpy(p->name, inet_ntoa(client_address.sin_addr));

        p->sockfd = sockfd;

        p->count = ;

        q = s_head->next;

        s_head->next = p;

        p->next = q;

    }

    else if(events[i].events & EPOLLIN){

     //   printf("ET once\r\n");

        while(g_stop){

        //printf("g_stop = %d\n", g_stop);

        //memset(data, 0x00, sizeof(*data));

        int ret = recv(sockfd, data, MAX_LEN, );

        if(ret < ){

            if((errno == EAGAIN) || (errno == EWOULDBLOCK)){

            //printf("read later \r\n");

            break;

            }

            close(sockfd);

            break;

        }

        else if(ret == ){

            close(sockfd);

        }

        else{

            heart_handler(sockfd, data);

        //    printf("接受的数据长度是: %d\n", ret);

        //    printf("recv data  from %d buf id %s %d %d \r\n", sockfd, data->name, data->num1, data->num2);

            if(data->data_type == ){

                 if(data->num1 == 0xfffffff || data->num2 == 0xfffffff){

                    //    printf("输入的数字个数不对\n");

                    WriteSysLog(data, );

                    num->data_type = ;

                    strcpy(num->name, "127.0.0.1");

                    send(sockfd, buf, len, );

                    break;

                     }

                 WriteSysLog(data, );

                 strcpy(num->name, "127.0.0.1");

                 num->data_type = ;

                    num->num1 = data->num1 + data->num2;

                    memcpy(buf, num, len);

                 WriteSysLog(num, );

                 send(sockfd, buf, len, );

            }

        }

        }

    }

    else{

        printf("做了另外的事情\r\n");

    }

    }

    pthread_exit((void *)data);

}

heart.c：心跳检测，心跳处理

#include "handsomecui.h"

#include "heart.h"

extern s_t *s_head;

extern volatile g_stop;

void init_shead(){

    s_head = (s_t *)malloc(sizeof(s_t));

}

void heart_handler(int sockfd,DATA_PACK *pd)

{

    s_t *cur = s_head->next; 

    while( NULL != cur){

        if(strcmp(cur->name,pd->name) == ){

            cur->count = ; 

            printf("客户端IP： %s ：用户 %s 连接正常\n",cur->peerip,pd->name);

            }

        cur = cur->next;

        }

}

 void *heart_check(void *p)

{

    printf("心跳检测线程已开启！\n");

    while(g_stop){

        check_handler();

        sleep();

//        printf("stop = %d\n", g_stop);

    }

//    puts("******");

    pthread_exit((void *));

}

void check_handler(){

    s_t *temp = NULL; 

    s_t **ppNode = &s_head->next;

    while(NULL != (*ppNode)  && g_stop){

        if((*ppNode)->count == ){

            g_stop = ;

            printf("客户端IP： %s ：用户 %s 已经掉线！！\n",(*ppNode)->peerip,(*ppNode)->name);

            close((*ppNode)->sockfd); 

            temp = *ppNode; 

            *ppNode = (*ppNode)->next;

            free(temp); 

            temp = NULL;

            return;

        }

        else if((*ppNode)->count > ){

            printf("客户端IP： %s ：用户 %s 连接异常！\n",(*ppNode)->peerip,(*ppNode)->name);

            (*ppNode)->count++;

            printf("count = %d\n",(*ppNode)->count);

            ppNode = &((*ppNode)->next); 

            continue;

        }

        else if((*ppNode)->count == ){

            (*ppNode)->count++;

            printf("count = %d\n",(*ppNode)->count);

            ppNode = &((*ppNode)->next);

        }

        else;

    } 

}

log.c：滚动日志文件

#include "handsomecui.h"

#include "log.h"

typedef unsigned char   UINT8;

typedef signed   int    INT32;

typedef unsigned int    UINT32;

void WriteSysLog(DATA_PACK *str, int s_w){

    char buf[], temp[];

     long MAXLEN = **;

     time_t timep;

     int fp;

     struct tm *p; 

     time(&timep);

     p = localtime(&timep);

     memset(buf,,sizeof(buf));

     sprintf(buf,"%d-%d-%d %d:%d:%d : ",(+p->tm_year),(+p->tm_mon),\

     p->tm_mday,p->tm_hour, p->tm_min, p->tm_sec); 

     if(!s_w)

        strcat(buf, "收到了");

     sprintf(temp, "%s", str->name);

     strcat(buf, temp);

     if(s_w)

        strcat(buf, "服务器发送了数据： ");

     if(!s_w)

        strcat(buf, "传来的数据： ");

     if(s_w < ){

          sprintf(temp, "%d", str->num1);

         strcat(buf, temp);

         strcat(buf, "\t");

             sprintf(temp, "%d", str->num2);

         if(!s_w)

             strcat(buf, temp);

         strcat(buf, "\n");

     }

     else

        strcat(buf, "发送数字数目不正确\n");

     UINT8 *pszHomePath = (UINT8 *)getenv("HOME");

     UINT8  szWholePath[]  = {};

     UINT8 pszConfigFileName[];

     strcpy(pszConfigFileName, "log.txt");

     if (pszHomePath == NULL)

        {

        printf("GetCompletePath: Can't find home path!\n");

        return;

        }

        snprintf(szWholePath, sizeof(szWholePath)-, "/home/handsome/work/socket/Cuijunyong_3/log/%s", pszConfigFileName);

    //puts(szWholePath);

     fp = open(szWholePath,O_RDONLY|O_CREAT|O_WRONLY, );

     if(fp < )

     {

          fprintf(stderr, "open file 1 error: %s\n", strerror(errno));

     }

     else

     {

          off_t n = lseek(fp, , SEEK_END);

        // printf("文件的字节数是：%d\n", (int)n);

          if(n >= MAXLEN)

          {

            close(fp);

            int i;

             for(i = ; i < ; i++){

                strcpy(pszConfigFileName, "log");

                temp[] = i + '';

                temp[] = '\0';

                strcat(pszConfigFileName, temp);

                strcat(pszConfigFileName, ".txt");

                snprintf(szWholePath, sizeof(szWholePath)-, "/home/handsome/work/socket/Cuijunyong_3/log/%s", pszConfigFileName);

                puts(szWholePath);

                fp = open(szWholePath,O_RDONLY|O_CREAT|O_WRONLY, );

                n = lseek(fp, , SEEK_END);

                if(n >= MAXLEN){

                    close(fp);

                    continue;

                }

                else{

                    puts(buf);

                    write(fp, buf, strlen(buf));

                    close(fp);

                    return;

                }

            }

          }

          else

          {

               printf("%s", buf);

            write(fp, buf, strlen(buf));

            close(fp);

          }

     }

}

lt.c：lt工作模式

#include "handsomecui.h"

#include "lt.h"

void lt(struct epoll_event* events, int number, int epollfd, int listenfd){

    char buf[BUF_SIZE];

    int i;

    for(i = ; i < number; i++){

    int sockfd = events[i].data.fd;

    if(sockfd == listenfd){

        struct sockaddr_in client_address;

        socklen_t client_addresslen = sizeof(client_address);

        int connfd = accept(listenfd, (struct sockaddr *)&client_address, &client_addresslen);

        if(connfd < ){

            printf("接受失败\r\n");

        exit();

        }

        addfd(epollfd, connfd, );

    }

    else if(events[i].events & EPOLLIN){

        printf("LT once\r\n");

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

        int ret = recv(sockfd, buf, sizeof(buf)-, );

        if(ret <= ){

            printf("rec 0\r\n");

        close(sockfd);

        continue;

        }

        printf("recv data from  %d  buf is %s\r\n", sockfd, buf);

    }

    else{

        printf("做了另外的一些事\r\n");

    }

    }

}

server.c：服务器主代码

#include "handsomecui.h"

#include "lt.h"

#include "et.h"

#include "addfd.h"

#include "heart.h"

s_t *s_head = NULL;

volatile g_stop = ;

int main(int argc, char **argv){

    if(argc <= ){

    printf("请输入ip地址和端口\r\n");

    exit();

    }

    const char* ip = argv[];

    int port = atoi(argv[]);

    int ret = ;

    struct sockaddr_in address;

    bzero(&address, sizeof(address));

    address.sin_family = AF_INET;

    inet_pton(AF_INET, ip, &address.sin_addr);

    address.sin_port = htons(port);

    int listenfd = socket(AF_INET, SOCK_STREAM, );

    assert(listenfd >= );

    ret = bind(listenfd, (struct sockaddr *)&address, sizeof(address));

    assert(ret != -);

    ret = listen(listenfd, );

    assert(ret != -);

    struct epoll_event events[MAX_SOCKET_NUMBERS];

    int epollfd = epoll_create();

    assert(epollfd != -);

    addfd(epollfd,listenfd, );

    int err1;

    pthread_t pth1;

    init_shead();

    if( (err1 = pthread_create(&pth1, NULL, heart_check, (void *)) ) != ){

    puts("-------------------");

    fprintf(stderr, "pthread_creat : %s\n", strerror(err1));

    exit();

    }

    DATA_PACK *num;

    while(g_stop){

    int err;

    int ret = epoll_wait(epollfd, events, MAX_SOCKET_NUMBERS, -);

        if(ret < ){

            printf("epoll等候失败\r\n");

        exit();

        }

    pthread_t pth;

    pth_etlt arg = {events, ret, epollfd, listenfd};

    if( (err = pthread_create(&pth, NULL, et, (void *)&arg) ) != ){

        fprintf(stderr, "pthread_creat : %s\n", strerror(err));

        exit();

    }

    //pthread_join(pth, (void**)&num);

    //printf("num1 = %d num2 = %d\n", num->num1, num->num2);

    //lt(events, ret, epollfd, listenfd);

    }

   close(listenfd);

    return ;

}

setnonblocking.c：设置非阻塞

#include "handsomecui.h"

#include "setnonblocking.h"

int setnonblocking(int fd){

    int old_option = fcntl(fd, F_GETFL);

    int new_option = old_option | O_NONBLOCK;

    fcntl(fd, F_SETFL, new_option);

    return new_option;

}

配置文件config.ini：

[IPANDPORT]

;the name of IP

IP=127.0.0.1

;the age of employee

PORT=

[TWONUMBER]

;the name of employer

NUMBER1=

;the age of employer

NUMBER2=

原文地址：http://www.cnblogs.com/handsomecui/p/5694262.html

码农公寓

相关文章