TCP&UDP C/S在linux上的简单实现

最新推荐文章于 2023-04-20 13:31:46 发布

fengzhishang_meteor

最新推荐文章于 2023-04-20 13:31:46 发布

阅读量1k

点赞数

分类专栏： Network

Network 专栏收录该内容

27 篇文章 4 订阅

订阅专栏

目标：
完成一个精简TCP服务器，可接收来自多个用户的请求，并返回结果。

思路：
（1）服务器
      C++ TCP服务器的实现主要由以下几个函数来完成：
        a）socket
     创建服务器监听套接字
  b）bind
     绑定服务器监听信息到套接字上
  c）listen
     开始监听，接收客户端的TCP连接
  d）accept
     从listen所维护的队列中取出一条已连接的TCP，返回该连接的socket描述字
        e）服务器客户端在连接socket描述字上进行消息通信
  f） close
     关闭打开着的套接字
      为了更好的服务多个发起请求的客户端，在e步骤上，我们使用fork以派生子进程来独立处理每个客户端的请求。
      if( (childpid=fork())==0)
     {
      close(listenfd);         //从父进程复制下来的监听socket描述符要关闭。
      //communication(connfd);
      exit(0);
     }
（2）客户端
    客户端的实现主要由以下函数完成：
     a）socket
        创建客户端连接套接字
    b）connect
    向指定服务器发起连接请求
     c）服务器客户端在连接socket描述字上进行消息通信
     d）close
        关闭打开着的套接字

server.cpp
#include<sys/types.h>
#include<sys/socket.h>
#include<strings.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<signal.h>
#include<sys/wait.h>

#define LISTEN_PORT 84
void str_echo(int sockfd)
{
    ssize_t n;
    char line[512];

    printf("ready to read\n");
    while( (n=read(sockfd,line,512))>0 )
    {
            line[n]='\0';
            printf("Client: %s\n",line);
            bzero(&line,sizeof(line));
    }
    printf("end read\n");
}

int main(int argc, char **argv)
{
    int listenfd, connfd;
    pid_t childpid;
    socklen_t chilen;

    struct sockaddr_in chiaddr,servaddr;

    listenfd=socket(AF_INET,SOCK_STREAM,0);
    if(listenfd==-1)
    {
        printf("socket established error: %s\n",(char*)strerror(errno)); return -1;
    }

    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family=AF_INET;
    servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
    servaddr.sin_port=htons(LISTEN_PORT);

    int bindc=bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
    if(bindc==-1)
    {
        printf("bind error: %s\n",strerror(errno)); return -1;
    }

    listen(listenfd,5);
    for(;;)
    {
        chilen=sizeof(chiaddr);

        connfd=accept(listenfd,(struct sockaddr*)&chiaddr,&chilen);
        if(connfd==-1)
        {    printf("accept client error: %s\n",strerror(errno)); return -1; }
        else        
            printf("client connected\n");

        if((childpid=fork())==0)
        {
            close(listenfd);
            printf("client from %s\n",inet_ntoa(chiaddr.sin_addr));
            str_echo(connfd);
            exit(0);    
        }
        else if (childpid<0)
            printf("fork error: %s\n",strerror(errno));
        close(connfd);
    }
}

client.cpp
#include<sys/types.h>
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<sys/socket.h>
#include<strings.h>
#include<string.h>
#include<arpa/inet.h>
#include<errno.h>

#define SERVER_PORT 84
void str_cli(char *data,int sockfd)
{
    char recv[512];

    int wc=write(sockfd,data,strlen(data));

    exit(0);
}
int main(int argc, char **argv)
{
    int sockfd;
    struct sockaddr_in servaddr;

    if(argc!=3)
        return -1;

    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd==-1)
    {
        printf("socket established error: %s\n",(char*)strerror(errno)); return -1;
    }

    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family=AF_INET;
    servaddr.sin_port=htons(SERVER_PORT);
    inet_pton(AF_INET,argv[1],&servaddr.sin_addr);

    printf("client try to connect\n");
    int conRes=connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
    if(conRes==-1)
    {    
        printf("connect error: %s\n",strerror(errno)); return -1;
    }

    str_cli(argv[2],sockfd);

    exit(0);
}

分析：
最简单的服务器仅能完成基本的通信，并没有考虑其他边界或者异常情况，同时，采用子进程处理客户端连接，一旦子进程数量增多，并且子进程需要长时间的运行，那么服务器性能将严重下降。

http://www.cnblogs.com/aga-j/archive/2011/09/15/2177018.html

UDP C/S编程的步骤如下图所示

与TCP C/S通信的区别在于：
服务端没有设置监听和等待连接的过程。客户端没有连接服务端的过程。
基于UDP的通信时不可靠地，面向无连接的，发送的数据无法确切知道对方收到没有，就算对方根本不存在，也可以发送数据出去。
这样的通信通常用在对可靠性、安全性要求不高的地方，比如语音通信（没听清楚可以让对方再说一遍）。
下面是一个简单的例子：

SERVER

#include <sys/types.h>
#include <sys/socket.h>
#include<pthread.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    if (argc != 2)
    {
        printf("Usage: %s port\n", argv[0]);
        exit(1);
    }
    printf("Welcome! This is a UDP server, I can only received message from client and reply with same message\n");
    
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(atoi(argv[1]));
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    int sock;
    if ( (sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    {
        perror("socket");
        exit(1);
    }
    if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    {
        perror("bind");
        exit(1);
    }
    char buff[512];
    struct sockaddr_in clientAddr;
    int n;
    int len = sizeof(clientAddr);
    while (1)
    {
        n = recvfrom(sock, buff, 511, 0, (struct sockaddr*)&clientAddr, &len);
        if (n>0)
        {
            buff[n] = 0;
            printf("%s %u says: %s\n", inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port), buff);
            n = sendto(sock, buff, n, 0, (struct sockaddr *)&clientAddr, sizeof(clientAddr));
            if (n < 0)
            {
                perror("sendto");
                break;
            }
        }
        else
        {
            perror("recv");
            break;
        }
    }
    return 0;
}

CLIENT

#include <sys/types.h>
#include <sys/socket.h>
#include<pthread.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>


int main(int argc, char **argv)
{
    if (argc != 3)
    {
        printf("Usage: %s ip port", argv[0]);
        exit(1);
    }
    printf("This is a UDP client\n");
    struct sockaddr_in addr;
    int sock;

    if ( (sock=socket(AF_INET, SOCK_DGRAM, 0)) <0)
    {
        perror("socket");
        exit(1);
    }
    addr.sin_family = AF_INET;
    addr.sin_port = htons(atoi(argv[2]));
    addr.sin_addr.s_addr = inet_addr(argv[1]);
    if (addr.sin_addr.s_addr == INADDR_NONE)
    {
        printf("Incorrect ip address!");
        close(sock);
        exit(1);
    }

    char buff[512];
    int len = sizeof(addr);
    while (1)
    {
        gets(buff);
        int n;
        n = sendto(sock, buff, strlen(buff), 0, (struct sockaddr *)&addr, sizeof(addr));
        if (n < 0)
        {
            perror("sendto");
            close(sock);
            break;
        }
        n = recvfrom(sock, buff, 512, 0, (struct sockaddr *)&addr, &len);
        if (n>0)
        {
            buff[n] = 0;
            printf("received:");
            puts(buff);
        }
        else if (n==0)
        {
            printf("server closed\n");
            close(sock);
            break;
        }
        else if (n == -1)
        {
            perror("recvfrom");
            close(sock);
            break;
        }
    }
    
    return 0;
}

http://www.cnblogs.com/uvsjoh/archive/2013/01/01/2841764.html