基于TCP的socket编程

最新推荐文章于 2022-10-30 17:31:20 发布

Better_JH

最新推荐文章于 2022-10-30 17:31:20 发布

阅读量1k

点赞数 1

分类专栏：网络文章标签： socket tcp 服务器网络通信

本文链接：https://blog.csdn.net/Better_JH/article/details/72846264

版权

网络专栏收录该内容

14 篇文章 0 订阅

订阅专栏

socket：网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket（套接字）。
建立socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket ，另一个运行于服务器端，称为ServerSocket 。　
套接字之间的连接过程：
1、服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。
2、客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。
3、连接确认：当服务器端套接字监听到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程（或进程），把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。
注：TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节。
—————————————————————————————————————————————————————————–
基于TCP（面向字节流）的socket编程，分为客户端和服务器端。
服务器端的流程如下：
1、创建套接字（socket）（套接字即一个文件描述符）
2、将套接字绑定到一个本地地址和端口上（bind）
3、将套接字设为监听模式，准备接收客户端请求（listen）
4、等待客户请求到来；当请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字（accept）
5、用返回的套接字和客户端进行通信（read/write）
6、关闭套接字
客户端的流程如下：
1、创建套接字（socket）
2、向服务器发出连接请求（connect）
3、和服务器端进行通信（read/write）
4、关闭套接字

多进程tcp_socket原理：服务器accept一个客户端，然后fork子进程，子进程再次fork创建一个孙子进程，然后子进程退出，由孙子进程来对客户端进行服务（孙子进程运行结束会被init进程回收），而父进程继续accept。相关代码：

//server端：
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static void usage(const char* proc)
{
    printf("Usage:%s[local_ip][local_port]\n",proc);
}
int startup(const char* _ip,int _port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);//创建套接字
    if(sock<0)
    {
        perror("socket");
        return 1;
    }
    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(_port);
    servaddr.sin_addr.s_addr = inet_addr(_ip);
    if(bind(sock,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)//绑定
    {
        perror("bind");
        return 2;
    }
    if(listen(sock,10)<0)//监听
    {
        perror("listen");
        return 3;
    }
    return sock;
}
int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    int listen_sock = startup(argv[1],atoi(argv[2]));
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    while(1)
    {
        int sock = accept(listen_sock,(struct sockaddr*)&clientaddr,&len);//等待客户端连接
        if(sock<0)
        {
            perror("accept");
            continue;
        }
        printf("client ip:%s port:%d\n",inet_ntoa(clientaddr.sin_addr),ntohs(clientaddr.sin_port));
        pid_t id = fork();
        if(id <0 )
        {
            perror("fork");
            exit(2);
        }
        else if(id ==0)
        {

            pid_t _id = fork();
            if(_id>0)
            {
                exit(3);
            }
            else if(_id <0)
            {
                perror("fork");
                exit(4);
            }
            char buf[1024];
            while(1)
            {
                ssize_t s =read(sock,&buf,sizeof(buf)-1);
                if(s > 0)
                {
                    buf[s] = 0;
                    printf("client ip:%s  port:%d say:%s\n",inet_ntoa(clientaddr.sin_addr),ntohs(clientaddr.sin_port),buf);
                    write(sock,&buf,strlen(buf));
                }
                else
                {
                    printf("client is quit\n");
                    break;
                }
            }
            close(sock);
        }
    }
    close(listen_sock);
    return 0;
}
//client端：
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static void usage(const char* proc)
{
    printf("Usage:%s[server_ip][server_port]\n",proc);
}
int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET,SOCK_STREAM,0);//创建套接字
    if(sock<0)
    {
        perror("socket");
        return 2;
    }
    struct sockaddr_in peer;
    peer.sin_family = AF_INET;
    peer.sin_port = htons(atoi(argv[2]));
    peer.sin_addr.s_addr = inet_addr(argv[1]);
    int ret = connect(sock,(struct sockaddr*)&peer,sizeof(peer));//连接
    if(ret<0)
    {
        perror("connect");
        printf("%s\n",strerror(ret));
        return 3;
    }
    char buf[1024];
    while(1)//通信
    {
        printf("please enter: ");
        fflush(stdout);
        ssize_t s=read(0,&buf,sizeof(buf));
        if(s<0)
        {
            perror("read");
            return 4;
        }
        buf[s-1]=0;
        write(sock,&buf,strlen(buf));
        printf("server echo: %s\n",buf);        
    }
    close(sock);
    return 0;
}

这里写图片描述

这里写图片描述

多进程服务器的优点：稳定性好。缺点：开销大，服务器资源有限，CPU占用大，使得其性能减弱。

多线程tcp_socket原理：服务器accept一个客户端，然后创建一个线程并设置其分离属性（线程退出时不需要被join，系统自动来回收该资源）,由子线程来为客户端提供服务，而主线程继续accept。相关代码：

//server端：
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static void usage(const char* proc)
{
    printf("Usage:%s[local_ip][local_port]\n",proc);
}
int startup(const char* _ip,int _port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        return 1;
    }
    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(_port);
    servaddr.sin_addr.s_addr = inet_addr(_ip);
    if(bind(sock,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
    {
        perror("bind");
        return 2;
    }
    if(listen(sock,10)<0)
    {
        perror("listen");
        return 3;
    }
    return sock;

}
void *handler(void * _sock)
{
    int sock = (int)_sock;
    char buf[1024];
    char *msg = "HTTP/1.0 200 ok\r\n\r\n<html><h1>HELLO WORLD</h1></html>\r\n";
    while(1)
    {
        ssize_t s =read(sock,buf,sizeof(buf)-1);
        if(s > 0)
        {
            buf[s] = 0;
            printf("client say:%s\n",buf);
            write(sock,msg,strlen(msg));
        }
        else
        {
            printf("client is quit\n");
            break;
        }
    }
    return (void *)0;

}
int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    int listen_sock = startup(argv[1],atoi(argv[2]));
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    while(1)
    {
        int sock = accept(listen_sock,(struct sockaddr*)&clientaddr,&len);
        if(sock<0)
        {
            perror("accept");
            continue;
        }
        printf("client ip:%s  port:%d\n",inet_ntoa(clientaddr.sin_addr),ntohs(clientaddr.sin_port));
        pthread_t id ;
        if(pthread_create(&id,NULL,handler,(void *)sock)<0)
        {
            perror("pthread_create");
            exit(2);
        }
        pthread_detach(id);//设置分离属性

    }
    return 0;
}
//client端：
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static void usage(const char* proc)
{
    printf("Usage:%s[server_ip][server_port]\n",proc);
}
int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        return 2;
    }
    struct sockaddr_in peer;
    peer.sin_family = AF_INET;
    peer.sin_port = htons(atoi(argv[2]));
    peer.sin_addr.s_addr = inet_addr(argv[1]);
    int ret = connect(sock,(struct sockaddr*)&peer,sizeof(peer));
    if(ret<0)
    {
        perror("connect");
        printf("%s\n",strerror(ret));
        return 3;
    }
    char buf[1024];
    while(1)
    {
        printf("please enter: ");
        fflush(stdout);
        ssize_t s=read(0,buf,sizeof(buf));
        if(s<0)
        {
            perror("read");
            return 4;
        }
        buf[s-1]=0;
        write(sock,buf,strlen(buf));
        read(sock,buf,sizeof(buf));
        printf("server echo: %s\n",buf);        
    }
    close(sock);
    return 0;
}