LINUX服务器service的socket，bind, listen, accept, read

Slow

已于 2024-07-22 20:09:06 修改

阅读量582

点赞数 11

CC 4.0 BY-SA版权

文章标签：服务器网络运维 linux c语言

于 2024-07-20 16:44:05 首次发布

本文链接：https://blog.csdn.net/weixin_43399456/article/details/140573368

1.int socket(int domain,int type,int protocol);

参数

domain

AF_INET

AF_INET6

AF_UNIX,AF_LOCAL

AF_NETLINK

AF_PACKET

type

SOCK_STREAM: 流式套接字，唯一对应于TCP

SOCK_DGRAM:数据报套接字，唯一对应着UDPSOCK_RAW:原始套接字

protocol

一般填0，原始套接字编程时需填充

返回值

成功返回文件描述符

出错返回-1

2.int bind(int sockfd,const struct sockaddr *addr,socklen_t addrlen)

参数

sockfd:通过socket()函数拿到的fd

addr:采用struct sockaddr的结构体地址,通用结构体

struct sockaddr{

sa_family_t sa_family;

char sa_data[4];

}

struct sockaddr_in{ 基于Internel通信结构体

as_family_t sin_family;

in_port_t sin_port;

struct in_addr sin_addr;

sin_zero ， //填充字节，需清零

}

struct in_addr{

uint32_t s_addr;

}

addrlen:地址长度

return value

成功返回0

出错返回-1

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

3.listen()函数

int listen(int sockfd,int backlog);

参数：

sockfd: 通过socket()函数拿到的fd；

backLog:同时允许几路客户端和服务器进行正在连接的过程（正在三次握手），一般填5。

内核中服务器的套接字fd会维护2个链表

1.正在三次握手的客户端链表（数量=2*backlog+1）

2.已经建立好连接的客户端链表（已经完成三次握手分配好了的newfd）

返回值：

成功返回0

出错返回-1

listen(fd,5)；//表示系统允许11（2*5+1）个客户端同时进行三次握手

4.accept()函数

阻塞等待客户端连接请求

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

参数

sockfd:经过前面socket()创建并通过bind(),listen()设置过的fd

addr：指向存放地址信息的结构体的首地址

获取客户端IP地址和端口号

addrlen：存放地址信息的结构体的大小

返回值

成功，返回返回已经建立连接的新的newfd

出错，返回-1

4.字节序

字节序是指不同的CPU访问内存中的多字节数据时候，存在大小端的问题

如果CPU访问的是字符串，则不存在大小端问题

一般来说X86/ARM ：小端模式

power/miop:arm作为路由时，大端模式

网络传输的时候采用大端模式

字节转换函数

把给定系统所采用的字节序称为主机字节序，为了避免不同类别主机之间在数据交换时由于对于字

节序的不同而导致的差错，引入了网络字节序。

主机字节序到网络字节序

u_long htonl(u_long hostlong);

u_short htons(u_short short);

网络字节序到主机字节序

u_long ntohl(u_long hostlong);

u_short ntohs(u_short short);

IP地址的转换

inet_aton()

将strptr所指的字符串转换成32位的网络字节序二进制值

inet_addr()

功能同上，返回转换后的地址

仅适用于IPV4,出错时返回-1。

局限性：不能用于255.255.255.255的转换

#include<stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include<stdlib.h>
#include <strings.h>
#include<unistd.h>


#include <string.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>





#define SERV_IP 5001
#define SERV_IP_ADDR "192.168.64.0"
#define BACKLOG 5
#define BUFSIZE 1024
#define QUIT_STR "QUIT"
int main()
{
        //socket
        int fd = -1;
        fd = socket(AF_INET,SOCK_STREAM,0);//fd为socket的返回值，文件描述符，对应TCP、ipv4
        if(fd < 0)//返回值为-1，则创建socket套接字失败
        {
                perror("socket");
                exit(1);
        }
        /*
           struct sockaddr_in {
           sa_family_t    sin_family;  address family: AF_INET 
           in_port_t      sin_port;    port in network byte order 
           struct in_addr sin_addr;    internet address 
           };

           Internet address. 
           struct in_addr {
           uint32_t       s_addr;      address in network byte order 
           };  */

        struct sockaddr_in sin;//创建结构体，定义结构体Ip地址为32位为ipv4，端口号由主机字节序转为网络字节序，Ip地址也是
        sin.sin_family = AF_INET;
        sin.sin_port = htons(SERV_IP);
        sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR);
        bzero(&sin,sizeof(sin));//结构体内容值0
        //bing
        if(bind(fd,(struct sockaddr *)&sin,sizeof(sin))<0)//bind绑定函数，返回值为-1则创建失败，异常退出
        {
                perror("bind");
                exit(1);
        }

        //listen

        if(listen(fd,BACKLOG)<0)//监听函数，返回值为-1则创建失败，异常退出
        {
                perror("listen");
                exit（1）；

        }
        //accept

        int newfd=-1;
        newfd = accept(fd,NULL,NULL);//接受函数，返回值为newfd,与fd不同，如果newfd=-1则创建accept函数失败，异常退出
        if(newfd<0)
        {
                perror("accept");
                exit(1);
        }

        //read



        char buf[BUFSIZE];//定义字符串buf大小为宏定义bufsize
        int ret = -1;//定义整型的ret
        while(1)//一直循环
        {
                do{
                        bzero(buf,BUFSIZE);//buf置0
                        ret = read(newfd,buf,BUFSIZE-1);//ret为从newfd读BUFSIZE-1的大小到buf里面的read的内容的大小

                }while(ret<1);//当ret没有接受内容为0，为-1时，一直循环，直到ret有值
                if(ret<0)//如果ret读到字节数为负数，则报错，异常退出
                {
                        perror("read");
                        exit(1);
                }
                if(!ret)如果没有读到字节数或者为空格，则跳出while循环
                {
                        break;
                }
                printf("receive data :%s \n",buf);//打印buf里面的内容

                if(!strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)))//如果读到的内容为QUIT,则打印客户端存在！，即如果客户端发送QUIT,则返回客户端存在，并结束while循环
                {
                        printf("Client is exiting!\n");
                        break;
                }
        }
        close(newfd);
        close(fd);
        return 0;
}

与后面的客户端结合起来实现客户端和服务端通信

改进，服务器自动获取客户端ip地址，自动分配端口号

#include<stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include<stdlib.h>
#include <strings.h>
#include<unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#define SERV_PORT 5001
#define SERV_IP_ADDR "192.168.157.34"
#define BACKLOG 5
#define BUFSIZE 1024
#define QUIT_STR "QUIT"
int main()
{
        //socket
        int fd = -1;
        fd = socket(AF_INET,SOCK_STREAM,0);
        if(fd < 0)
        {
                perror("socket");
                exit(1);
        }
        /*
           struct sockaddr_in {
           sa_family_t    sin_family;  address family: AF_INET 
           in_port_t      sin_port;    port in network byte order 
           struct in_addr sin_addr;    internet address 
           };

           Internet address. 
           struct in_addr {
           uint32_t       s_addr;      address in network byte order 
           };  */

        struct sockaddr_in sin;

        bzero(&sin,sizeof(sin));
        sin.sin_family = AF_INET;
        sin.sin_port = htons(SERV_PORT);
        sin.sin_addr.s_addr = INADDR_ANY;//自动获取ip地址
        //bing
        if(bind(fd,(struct sockaddr *)&sin,sizeof(sin))<0)
        {
                perror("bind");
                exit(1);
        }

        //listen

        if(listen(fd,BACKLOG)<0)
        {
                perror("listen");
                exit(1);
        }
        //accept

/*
        int newfd=-1;
        newfd = accept(fd,NULL,NULL);
        if(newfd<0)
        {
                perror("accept");
                exit(1);
        }
*/
        int newfd = -1;
        char ipv4_addr[16];//定义16个字节长度的ipv4地址
        struct sockaddr_in clin;//创建结构体 clin

        socklen_t sockaddr_len = sizeof(clin);//定义socklen_t 类型的结构体长度
        newfd = accept(fd,(struct sockaddr *)&clin,&sockaddr_len);//accept用法同Bind,文件描述符，结构体地址，结构体长度，不同的是结构体长度为指针类型，需要取地址
        if(newfd<0)
        {
        perror("accept");
        exit(1);
        }
        if(!inet_ntop(AF_INET,(void *)&clin.sin_addr,ipv4_addr,sizeof(clin)))//将网络字节序clin.sin_addr变为本地的字符串形式ipv4_addr的ip地址
        {
        perror("inet_ntop");
        exit(1);
        }
        printf("client :(%s,%d) is connect!\n",ipv4_addr,ntohs(clin.sin_port));//打印本地字符串形式的ip地址，打印客户端的端口号




        //read



        char buf[BUFSIZE];
        int ret = -1;
        while(1)
        {
                do{
                        bzero(buf,BUFSIZE);
                        ret = read(newfd,buf,BUFSIZE-1);

                }while(ret<1);
                if(ret<0)
                {
                        perror("read");
                        exit(1);
                }
                if(!ret)
                {
                        break;
                }
                printf("receive data :%s \n",buf);

                if(!strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)))
                {
                        printf("Client is exiting!\n");
                        break;
                }
        }
        close(newfd);
        close(fd);
        return 0;
}

运行结果