Linux Socket编程（一）：简单地实现进程间TCP通信

其他 2021-01-22 19:00:50 阅读次数: 0

服务端和客户端通过Socket通信过程

参考博客：
[TCP网络编程中connect()、listen()和accept()三者之间的关系] -> 下图来自此博客(https://blog.csdn.net/tennysonsky/article/details/45621341)
网络套接字编程基本api
在这里插入图片描述

服务端：

  1. socket() ：创建套接字，设置套接字IP地址类型、传输协议类型。
  2. bind()：绑定ip地址和端口号到套接字。
  3. listen()：将套接字变成被动的连接监听套接字。监听套接字的端口号，随时准备接收客户端发来的连接请求。
    listen()函数不会阻塞，它主要做的事情为，将该套接字和套接字对应的连接队列长度告诉 Linux 内核，然后，listen()函数就结束。
  4. accept()：阻塞直到有客户端成功连接，并取走队列中已完成的连接。
    accept()函数从处于 established 状态的连接队列头部取出一个已经完成的连接，如果这个队列没有已经完成的连接，accept()函数就会阻塞当前线程，直到取出队列中已完成的客户端连接为止。
  5. read()\write()、recv()\send()：与客户端之间进行数据的交换。
    read()是阻塞I/O模式，服务端进程会被阻塞直到在内核缓冲区接收到完整数据，并从内核缓冲区拷贝到进程中为止。
  6. close()：关闭套接字，即关闭连接。

客户端：

  1. socket()：创建套接字，设置套接字IP地址类型、传输协议类型。
    客户端是发送连接请求一方，端口不用固定，可以随机分配，因此不用绑定。
  2. connect()：客户端根据服务器的ip地址和端口号，请求与服务端连接。
    客户端主动连接服务器，建立连接是通过三次握手，而这个连接的过程是由内核完成，不是这个函数完成的，这个函数的作用仅仅是通知 Linux 内核，让 Linux 内核自动完成 TCP 三次握手连接，最后把连接的结果返回给这个函数的返回值（成功连接为0， 失败为-1）。
  3. read()\write()、recv()\send()
  4. close()

服务端代码

主要实现功能是将客户端发送的字符串中的小写字母全部转化为大写字母，再返回给客户端。（PS：本人新学，所以代码注释的比较详细，实际上代码量不多的）参考博客：Linux socket编程

#include <iostream>
#include <stdio.h>
#include <cstring>       // void *memset(void *s, int ch, size_t n);
#include <sys/types.h>   // 数据类型定义
#include <sys/socket.h>  // 提供socket函数及数据结构sockaddr
#include <arpa/inet.h>   // 提供IP地址转换函数，htonl()、htons()...
#include <netinet/in.h>  // 定义数据结构sockaddr_in
#include <ctype.h>       // 小写转大写
#include <unistd.h>      // close()、read()、write()、recv()、send()...
using namespace std;

const int flag = 0; // 0表示读写处于阻塞模式
const int port = 8080;
const int buffer_size = 1<<20;


int main(int argc, const char* argv[]){
    
    
    // 创建服务器监听的套接字。Linux下socket被处理为一种特殊的文件，返回一个文件描述符。
    // int socket(int domain, int type, int protocol);
    // domain设置为AF_INET/PF_INET，即表示使用ipv4地址(32位)和端口号（16位）的组合。
    int server_sockfd = socket(PF_INET,SOCK_STREAM,0);  
    if(server_sockfd == -1){
    
    
        close(server_sockfd);
        perror("socket error!");
    }
    // /* Enable address reuse */
    // int on = 1;
    // int ret = setsockopt( server_sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );

    // 此数据结构用做bind、connect、recvfrom、sendto等函数的参数，指明地址信息。
    struct sockaddr_in server_addr;
    memset(&server_addr,0,sizeof(server_addr)); // 结构体清零
    server_addr.sin_family = AF_INET;  // 协议
    server_addr.sin_port = htons(port);  // 端口16位, 此处不用htons()或者错用成htonl()会连接拒绝!!
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 本地所有IP
    // 另一种写法, 假如是127.0.0.1
    // inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr.s_addr);


    // int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); 
    // bind()函数的主要作用是把ip地址和端口绑定到套接字(描述符)里面
    // struct sockaddr是通用的套接字地址，而struct sockaddr_in则是internet环境下套接字的地址形式，二者长度一样，都是16个字节。二者是并列结构，指向sockaddr_in结构的指针也可以指向sockaddr。
    // 一般情况下，需要把sockaddr_in结构强制转换成sockaddr结构再传入系统调用函数中。
    if(bind(server_sockfd,(struct sockaddr*)&server_addr,sizeof(server_addr)) == -1){
    
    
        close(server_sockfd);
        perror("bind error");
    }
    // 第二个参数为相应socket可以排队的准备道来的最大连接个数
    if(listen(server_sockfd, 5) == -1){
    
    
        close(server_sockfd);
        perror("listen error");
    }

    printf("Listen on port %d\n", port);
    while(1){
    
    
        struct sockaddr_in client_addr;
        socklen_t client_len = sizeof(client_addr);
        // accept()函数从处于established状态的连接队列头部取出一个已经完成的连接，
        // 如果这个队列没有已经完成的连接，accept()函数就会阻塞当前线程，直到取出队列中已完成的客户端连接为止。
        int client_sockfd = accept(server_sockfd, (struct sockaddr*)&client_addr, &client_len);

        char ipbuf[128];
        printf("client iP: %s, port: %d\n", inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ipbuf, sizeof(ipbuf)),
            ntohs(client_addr.sin_port));

        // 实现客户端发送小写字符串给服务端，服务端将小写字符串转为大写返回给客户端
        char buf[buffer_size];
        while(1) {
    
    
            // read data, 阻塞读取
            int len = recv(client_sockfd, buf, sizeof(buf),flag);
            if (len == -1) {
    
    
                close(client_sockfd);
                close(server_sockfd);
                perror("read error");
            }else if(len == 0){
    
      // 这里以len为0表示当前处理请求的客户端断开连接
                break;
            }
            printf("read buf = %s", buf);
            // 小写转大写
            for(int i=0; i<len; ++i) {
    
    
                buf[i] = toupper(buf[i]);
            }
            printf("after buf = %s", buf);

            // 大写串发给客户端
            if(send(client_sockfd, buf, strlen(buf),flag) == -1){
    
    
                close(client_sockfd);
                close(server_sockfd);
                perror("write error");
            }
            memset(buf,'\0',len); // 清空buf
        }
        close(client_sockfd);
    }
    close(server_sockfd);

    return 0;
}

客户端代码

// client 端相对简单, 另外可以使用nc命令连接->nc ip prot
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <string.h>


const int port = 8080;
const int buffer_size = 1<<20;
int main(int argc, const char *argv[]) {
    
    
    

    int client_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (client_sockfd == -1) {
    
    
        perror("socket error");
        exit(-1);
    }
    

    struct sockaddr_in client_addr;
    bzero(&client_addr, sizeof(client_addr));
    client_addr.sin_family = AF_INET;
    client_addr.sin_port = htons(port);
    inet_pton(AF_INET, "127.0.0.1", &client_addr.sin_addr.s_addr);
    
    int ret = connect(client_sockfd, (struct sockaddr*)&client_addr, sizeof(client_addr));
    if (ret == -1) {
    
    
        perror("connect error");
        exit(-1);
    }
    
    while(1) {
    
    
        char buf[buffer_size] = {
    
    0};
        fgets(buf, sizeof(buf), stdin); // 从终端读取字符串
        write(client_sockfd, buf, strlen(buf));
        //接收, 阻塞等待
        int len = read(client_sockfd, buf, sizeof(buf));
        if (len == -1) {
    
    
             perror("read error");
             exit(-1);
        }
        printf("client recv %s\n", buf);
        
    }
    
    close(client_sockfd);
    return 0;
}

遇到问题

  1. connect error: Connection refused，客户端连接服务器的时候，连接被拒绝。
    原因：由于主机字节序和网络字节序转换的函数错误使用，对端口的转换用了htonl()。端口是16位的，应该使用htons()、ntohs()；IP是32位的，应该使用htonl()、ntohl()。
    （注：数据流有大端字节序和小端字节序之分，TCP/IP协议规定网络数据流采用大端字节序。通过对大小端的存储原理分析可发现，对于char型数据，由于其只占一个字节，所以不存在这个问题，这也是一般情况下把数据缓冲区定义成char类型的原因之一。对于 IP 地址、端口号等非char型数据，必须在数据发送到网络上之前将其转换成大端模式，在接收到数据之后再将其转换成符合接收端主机的存储模式。）
// Linux 系统为主机字节序和网络字节序的转换提供了4个函数
#include <arpa/inet.h>
/*主机字节顺序 --> 网络字节顺序*/
uint32_t htonl(uint32_t hostlong);/* IP */
uint16_t htons(uint16_t hostshort);/* 端口 */
/*网络字节顺序 --> 主机字节顺序*/
uint32_t ntohl(uint32_t netlong);/* IP */
uint16_t ntohs(uint16_t netshort);/* 端口 */
  1. bind error: Address already in use，绑定的地址（ip+端口）已经在使用中。
    原因：Ctrl+Z中断任务的执行，但该任务并没结束，它只是在进程中维持挂起的状态。（Ctrl+C是强制终止程序的执行并结束进程）
    用netstat -anp | grep 8080查看服务器监听端口8080的使用状态。发现pid为4600的服务器进程和4623的客户端进程还处于ESTABLISHED状态，并未结束。用kill -9 pid结束客户端和服务端的进程，释放端口。
    Problem: Address already in use

猜你喜欢

转载自blog.csdn.net/XindaBlack/article/details/105599656
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
Java基础复习_day13_Collection集合
2018.11.16 c语言学习经验
且看Java内置四大核心函数式接口
小程序云开发中数据库的数据分段和显示图片
python的函数
Web-JS进阶
【干货】C++常用代码积累笔记大全
Spring的ioc操作 与 IOC底层原理
构建之法20191121-11 Scrum立会报告+燃尽图 07
Spring boot之Hello World访问404
每日归档
更多
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022