day08

client.h

#ifndef CLIENT_H
#define CLIENT_H

#include "link.h"
#include "protocol.h"
#include <string.h>

#define MAX_DATA_LEN 64

int makeSocket();
void makeConnect(int sockfd);
void makeReadThread(int sockfd);

void getUsrListFromPDU(PDU *pPDU);

void showChatData(PDU *pPDU);

void *readThread(void *arg);

void readDataFromSTDIN(char caData[MAX_DATA_LEN]);

#endif // CLIENT_H

client.c

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h> //struct sockaddr_in
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include "client.h"

List *pList = NULL;
uint g_iId = 0;

void getUsrListFromPDU(PDU *pPDU)
{
    if (NULL == pPDU || NULL == pList)
    {
        return;
    }
    int iNum = pPDU->iDataLen / sizeof(int);
    Node *pNode = NULL;
    int i = 0;
    while (iNum)
    {
        pNode = makeNode();
        if (NULL == pNode)
        {
            return;
        }
        memcpy(&(pNode->iId), pPDU->caData+i*sizeof(int)
               , sizeof(int));
        insertList(pList, pNode);
        i++;
        iNum--;
    }
    if (0 == g_iId)
    {
        pNode = pList->pFirstNode;
        while (NULL != pNode->pNext)
        {
            pNode = pNode->pNext;
        }
        g_iId = pNode->iId;
    }
    showList(pList);
}

void showChatData(PDU *pPDU)
{
    if (NULL != pPDU)
    {
        char caMsg[MAX_DATA_LEN] = {'\0'};
        memcpy(caMsg, pPDU->caData, pPDU->iDataLen);
        printf("%d says: %s\n", pPDU->iFromId, caMsg);
    }
}

void *readThread(void *arg)
{
    int sockfd = (int)arg;
    PDU *pPDU = NULL;
    uint iType = 0;
    while (1)
    {
        pPDU = readPDU(sockfd);
        iType = parsePDU(pPDU);
        switch (iType)
        {
        case ENUM_MSG_RESPONSE_USR_LIST:
            getUsrListFromPDU(pPDU);
            break;
        case ENUM_MSG_GROUP_CHAT:
        case ENUM_MSG_PRIVATE_CHAT:
            showChatData(pPDU);
            break;
        default:
            break;
        }
    }
    return NULL;
}

void readDataFromSTDIN(char caData[MAX_DATA_LEN])
{
    memset(caData, '\0', MAX_DATA_LEN);
    int ret = read(STDIN_FILENO, caData, MAX_DATA_LEN);
    if (-1 == ret)
    {
        perror("read");
        return;
    }
    if ('\0' != caData[MAX_DATA_LEN-1]
        && '\n' != caData[MAX_DATA_LEN-1])
    {
        while ('\n' != getchar())
        {}
    }
    caData[MAX_DATA_LEN-1] = '\0';
}




int makeSocket()
{
    int sockfd = socket(AF_INET
                        , SOCK_STREAM
                        , 0);
    if (-1 == sockfd)
    {
        perror("socket");
        exit(EXIT_FAILURE);
    }
    return sockfd;
}


void makeConnect(int sockfd)
{
    int ret = -1;
    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(8888);
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    bzero(&(serverAddr.sin_zero), 8);

    ret = connect(sockfd, (struct sockaddr *)&serverAddr
                  , sizeof(serverAddr));
    if (-1 == ret)
    {
        perror("connect");
        exit(EXIT_FAILURE);
    }
}


void makeReadThread(int sockfd)
{
    int ret = -1;
    pthread_t thread;
    ret = pthread_create(&thread, NULL
                         , readThread, (void*)sockfd);
    if (0 != ret)
    {
        printf("%s\n", strerror(ret));
        exit(EXIT_FAILURE);
    }
}

main.c(client)

#include "client.h"

extern List *pList;
extern uint g_iId;

int main(void)
{
    pList = makeList();
    if (NULL == pList)
    {
        return -1;
    }

    int sockfd = -1;
    sockfd = makeSocket();
    makeConnect(sockfd);
    makeReadThread(sockfd);

    //write data to server
    char caData[MAX_DATA_LEN] = {'\0'};
    int iLen = 0;
    PDU *pPDU = NULL;
    int iToId = 0;
    char caMsg[MAX_DATA_LEN] = {'\0'};
    while (1)
    {
        //1002 hello
        readDataFromSTDIN(caData);
        memset(caMsg, '\0', MAX_DATA_LEN);
        sscanf(caData, "%d%s", &iToId, caMsg);

        iLen = strlen(caMsg);
        if (iLen > 0)
        {
            pPDU = makePDU(iLen);
            memcpy(pPDU->caData, caMsg, iLen);
            pPDU->iFromId = g_iId;
            if (0 == iToId)
            {
                pPDU->iType = ENUM_MSG_GROUP_CHAT;
            }
            else
            {
                pPDU->iToId = iToId;
                pPDU->iType = ENUM_MSG_PRIVATE_CHAT;
            }
            sendPDU(sockfd, pPDU);
        }
    }

    return 0;
}

server.h

#ifndef SERVER_H
#define SERVER_H

#include <stdio.h>

#include "link.h"
#include "protocol.h"


void sendUsrListToClient(int sockfd, const List *pList);

void updateClientsUsrList(const List *pList);

void handleGroupChat(PDU *pPDU);

void handlePrivateChat(PDU *pPDU);

void *handleClient(void *arg);

int makeSocket();
void makeBind(int sockfd);
void makeListen(int sockfd);
int makeAccept(int sockfd);
void makeHandleClientThread(int sockfd);
void storeClientInfo(int sockfd);


#endif // SERVER_H

server.c

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h> //struct sockaddr_in
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include <stdlib.h>
#include "server.h"

List *pList = NULL;
uint iBaseId = 1001;

void sendUsrListToClient(int sockfd, const List *pList)
{
    if (sockfd < 0 || NULL == pList)
    {
        return;
    }
    int iDataLen = pList->iLen * sizeof(int);
    PDU *pPDU = makePDU(iDataLen);
    if (NULL == pPDU)
    {
        return;
    }

    Node *pNode = pList->pFirstNode;
    int i = 0;
    while (NULL != pNode)
    {
        memcpy(pPDU->caData+i*sizeof(int)
               , &(pNode->iId), sizeof(int));
        i++;
        pNode = pNode->pNext;
    }
    pPDU->iType = ENUM_MSG_RESPONSE_USR_LIST;   
    sendPDU(sockfd, pPDU);
}

void updateClientsUsrList(const List *pList)
{
    if (NULL == pList)
    {
        return;
    }
    PDU *pPDU = makePDU(sizeof(int));
    if (NULL == pPDU)
    {
        return;
    }
    memcpy(pPDU->caData, &(pList->pFirstNode->iId)
           , sizeof(int));
    pPDU->iType = ENUM_MSG_RESPONSE_USR_LIST;
    Node *pNode = pList->pFirstNode->pNext;
    while (NULL != pNode)
    {
        sendPDU(pNode->sockfd, pPDU);
        pNode = pNode->pNext;
    }
}


void handleGroupChat(PDU *pPDU)
{
    if (NULL != pPDU)
    {
        Node *pNode = pList->pFirstNode;
        while (NULL != pNode)
        {
            sendPDU(pNode->sockfd, pPDU);
            pNode = pNode->pNext;
        }
    }
}

void handlePrivateChat(PDU *pPDU)
{
    if (NULL != pPDU)
    {
        Node *pNode = NULL;
        pNode = findNode(pList, pPDU->iToId);
        if (NULL != pNode)
        {
            sendPDU(pNode->sockfd, pPDU);
        }
    }
}

void *handleClient(void *arg)
{
    int clientSockfd = (int)arg;

    storeClientInfo(clientSockfd);

    PDU *pPDU = NULL;
    uint iType = 0;
    while (1)
    {
        pPDU = readPDU(clientSockfd);
        if (NULL != pPDU)
        {
            iType = parsePDU(pPDU);
            switch (iType)
            {
            case ENUM_MSG_REQUEST_USR_LIST:
                break;
            case ENUM_MSG_GROUP_CHAT:
                handleGroupChat(pPDU);
                break;
            case ENUM_MSG_PRIVATE_CHAT:
                handlePrivateChat(pPDU);
                break;
            default:
                break;
            }
        }
    }
}

int makeSocket()
{
    int sockfd = socket(AF_INET
                        , SOCK_STREAM
                        , 0);
    if (-1 == sockfd)
    {
        perror("socket");
        exit(EXIT_FAILURE);
    }
    return sockfd;
}


void makeBind(int sockfd)
{
    int ret = -1;
    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;   //ipv4
    serverAddr.sin_port = htons(8888); //port
    //server ip
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    bzero(&(serverAddr.sin_zero), 8);
    //将sockfd和地址进行绑定
    ret = bind(sockfd, (struct sockaddr *)&serverAddr
                   , sizeof(serverAddr));
    if (-1 == ret)
    {
        perror("bind");
        exit(EXIT_FAILURE);
    }
}

void makeListen(int sockfd)
{
    int ret = -1;
    ret = listen(sockfd, 5);
    if (-1 == ret)
    {
        perror("listen");
        exit(EXIT_FAILURE);
    }
}

int makeAccept(int sockfd)
{
    struct sockaddr_in clientAddr;
    int iLen = sizeof(clientAddr);
    int clientSockfd = -1;
    clientSockfd = accept(sockfd
                    , (struct sockaddr *)&clientAddr
                    , &iLen);
    if (-1 == clientSockfd)
    {
        perror("accept");
        exit(EXIT_FAILURE);
    }
    return clientSockfd;
}


void makeHandleClientThread(int sockfd)
{
    pthread_t thread;
    pthread_create(&thread, NULL, handleClient
                   , (void *)sockfd);
}


void storeClientInfo(int sockfd)
{
    Node *pNode = makeNode();
    if (NULL == pNode)
    {
        return;
    }
    pNode->iId = iBaseId;
    pNode->sockfd = sockfd;
    iBaseId++;
    insertList(pList, pNode);
}

main.c(server)

#include "server.h"

extern List *pList;

int main(void)
{
    pList = makeList();
    if (NULL == pList)
    {
        return -1;
    }

    int sockfd = -1;
    sockfd = makeSocket();
    makeBind(sockfd);
    makeListen(sockfd);

    int clientSockfd = -1;
    while (1)
    {
        clientSockfd = makeAccept(sockfd);
        makeHandleClientThread(clientSockfd);

        sendUsrListToClient(clientSockfd, pList);
        updateClientsUsrList(pList);
    }

    return 0;
}

link.h

#ifndef LINK_H
#define LINK_H

#include <stdio.h>

typedef struct Node
{
    int iId;
    int sockfd;
    struct Node *pNext;
}Node;

typedef struct List
{
    int iLen;
    Node *pFirstNode;
}List;

Node *makeNode();
List *makeList();
void insertList(List *pList, Node *pNode);
Node *findNode(const List *pList, int iId);
void showList(const List *pList);

#endif

link.c

#include "link.h"
#include <stdlib.h>

Node *makeNode()
{
    Node *pNode = NULL;
    pNode = (Node *)malloc(sizeof(Node));
    if (NULL != pNode)
    {
        pNode->iId = 0;
        pNode->sockfd = -1;
        pNode->pNext = NULL;
    }
    return pNode;
}
List *makeList()
{
    List *pList = NULL;
    pList = (List *)malloc(sizeof(List));
    if (NULL != pList)
    {
        pList->iLen = 0;
        pList->pFirstNode = NULL;
    }
    return pList;
}

void insertList(List *pList, Node *pNode)
{
    if (NULL == pList || NULL == pNode)
    {
        return;
    }
    if (NULL == pList->pFirstNode)
    {
        pList->pFirstNode = pNode;
    }
    else
    {
        pNode->pNext = pList->pFirstNode;
        pList->pFirstNode = pNode;
    }
    pList->iLen++;
}
Node *findNode(const List *pList, int iId)
{
    if (NULL == pList)
    {
        return NULL;
    }
    Node *pNode = pList->pFirstNode;
    while (NULL != pNode)
    {
        if (pNode->iId == iId)
        {
            break;
        }
        pNode = pNode->pNext;
    }
    return pNode;
}
void showList(const List *pList)
{
    if (NULL == pList)
    {
        return;
    }
    Node *pNode = pList->pFirstNode;
    while (NULL != pNode)
    {
        printf("id: %d, sockfd: %d\n", pNode->iId
                                     , pNode->sockfd);
        pNode = pNode->pNext;
    }
    printf("-------------------------------\n");
}

protocol.h

#ifndef PROTOCOL_H
#define PROTOCOL_H

#include <stdio.h>

typedef unsigned int uint;

enum ENUM_MSG_TYPE
{
    ENUM_MSG_MIN = 0,
    ENUM_MSG_PRIVATE_CHAT,   //私聊
    ENUM_MSG_GROUP_CHAT,     //群聊
    ENUM_MSG_REQUEST_USR_LIST,   //请求用户列表
    ENUM_MSG_RESPONSE_USR_LIST,  //回复用户列表
    ENUM_MSG_MAX = 0x0fffffff
};

typedef struct PDU
{
    uint iPDULen;    //整个协议数据单元的大小
    uint iType;      //消息类型：群聊，私聊，获取用户列表
    uint iDataLen;   //消息的长度
    int iFromId;     //消息的发送者
    int iToId;       //消息的接收者
    char caData[4];  //要发送的消息
}PDU;

PDU *makePDU(int iDataLen);
uint parsePDU(PDU *pPDU);
void sendPDU(int sockfd, const PDU *pPDU);
PDU *readPDU(int sockfd);

#endif

protocol.c

#include "protocol.h"
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>

PDU *makePDU(int iDataLen)
{
    PDU *pPDU = NULL;
    uint iLen = sizeof(PDU) - 4*sizeof(char) + iDataLen;
    pPDU = (PDU *)malloc(iLen);
    if (NULL != pPDU)
    {
        memset(pPDU, 0, iLen);
        pPDU->iPDULen = iLen;
        pPDU->iType = ENUM_MSG_MIN;
        pPDU->iDataLen = iDataLen;
    }
    return pPDU;
}

uint parsePDU(PDU *pPDU)
{
    uint iType = ENUM_MSG_MIN;
    if (NULL != pPDU)
    {
        iType = pPDU->iType;
    }

    return iType;
}


void sendPDU(int sockfd, const PDU *pPDU)
{
    if (sockfd < 0 || NULL == pPDU)
    {
        return;
    }

    int ret = -1;
    int iLeft = pPDU->iPDULen;
    int iSended = 0;
    while (iLeft)
    {
        ret = write(sockfd, (char *)pPDU+iSended, iLeft);
        if (-1 == ret)
        {
            if (EINTR == errno)
            {
                continue;
            }
            perror("write");
            return;
        }
        iSended += ret;
        iLeft -= ret;
    }
}


PDU *readPDU(int sockfd)
{
    int ret = -1;
    uint iPDULen = 0;
    ret = read(sockfd, &iPDULen, sizeof(uint));
    if (-1 == ret)
    {
        perror("read");
        return NULL;
    }
    PDU *pPDU = makePDU(iPDULen-3*sizeof(int));
    if (NULL == pPDU)
    {
        return NULL;
    }
    pPDU->iPDULen = iPDULen;
    int iLeft = iPDULen - sizeof(int);
    int iReaded = sizeof(int);
    while (iLeft)
    {
        ret = read(sockfd, (char *)pPDU+iReaded, iLeft);
        if (-1 == ret)
        {
            if (EINTR == errno)
            {
                continue;
            }
            perror("while read");
            return NULL;
        }
        iLeft -= ret;
        iReaded += ret;
    }
    return pPDU;
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,293评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,604评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,958评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,729评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,719评论 5赞 366
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,630评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,000评论 3赞 397
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,665评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,909评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,646评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,726评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,400评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,986评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,959评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,197评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 44,996评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,481评论 2赞 342

推荐阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,594评论 18赞 139
  • HCNA-RS笔记-20171126-day08
    时钟频率：决定数据发送速度，由DCE点提供 在串口链路上两台设备互联时必须有一端为DCE提供时钟频率 DTE：用户...
    狗达Da阅读 214评论 0赞 0
  • day08 WEB
    WEB 的学习笔记 一 、网络的架构 client/server : 客户端/服务端 优点 ： 交互性好...
    东少D_余哥阅读 159评论 0赞 0
  • RFC5357
    啊 http://www.jianshu.com/writer#/notebooks/14946179/notes...
    指如出剑阅读 487评论 0赞 0
  • 无穷吸引力
    每次去玩都觉得说 迪士尼也就这样吧 可是…每次也能说走就走 不管刮风下雨 这次真的是狼狼狈狈 邋里邋遢 土里土气
    Samanta333阅读 220评论 0赞 0