linux下socket网络编程的学习过程-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_70042862/article/details/131848556

文章介绍了服务端和客户端的Socket通讯协议流程，包括创建套接字、绑定IP和端口、监听、接受连接、数据读写以及关闭连接的步骤。同时，详细阐述了网络编程中的字节序转换API和地址结构体，以及如何进行数据收发。最后，给出了一个类似网盘服务的示例，演示了如何处理客户端请求和服务端响应。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

服务端socket通讯协议代码流程

1.创建套接字（api：socket）
2.为套接字添加信息（ip地址和端口）（api：bind）
3.监听网络连接（api：listen）
4.监听到有客户端接入，连接该客户端（api：accept）
5.数据交互（api：read、wriet）
6.关闭套接字，断开连接（api：colse）

客户端socket通讯协议代码流程

创建套接字（api：socket）
连接服务端（api：accept）
数据交互（api：read、wriet）
关闭套接字，断开连接（api：colse）

socket网络编程API

创建套接字socket

int socket(int domain , int type , int protocl);

需要#include <sys/types.h>
#include <sys/socket.h>

参数1：domain：指明所使用的的协议族，通常用AF_INEF（因特网域）
参数2：type：指定套接字类型

SOCK_STREAM：使用TCP协议
SOCK_DGRAM：使用UDP协议
SOCK_RAW:允许对底层协议IP/ICMP直接访问+

参数3：protocol:通常赋值为0，有一下宏

IPPROTO_TCP
IPPROTO_UDP
IPPROTO_SCTP
IPPROTO_TIPC

返回套接字描述符

地址准备

int bind(int sockfd,const struct *sockaddr,socklen_t addrlen);

第一个参数sockfd：socket描述符，创建socket套接字时返回得到的
第二个参数sockadder：该结构体：一般配置sockaddr_in中前三个结构体即可，然后取其地址转换成（struct sockaddr_in*）型

struct sockaddr
{
	unsigned short as_family;//协议族
	char sa_data[14];//IP+端口号
}
//同等代换的结构体
struct sockaddr_in
{
	sa_family_t sin_family;//协议族
	in_port_t sin_port;//端口号
	struct in_addr;//ip地址结构体只有一个参数s_addr
	unsigned char sin_zero[8];//没有作用只是为了对齐sockaddr结构体的地址才能替换
}

数据转换api

上面说了需要我们输入ip地址和端口号，而我们输入的地址是字符型计算机不能解析，则我们需要将id字符串转换从网络格式的api
而端口号在输入的过程，不同系统字节序不同，网络字节序和主机字节序不同，也需要api在其中相互转换。
字节序api

#include <netinet/in.h>
uint16_t htons(uint16_t host16bitvalue);//返回网络字节序的值
uint16_t stohs(uint16_t net16bitvalue);//返回主机字节序的值
uint32_t htonl(uint32_t host32bitvalue);//返回网络字节序的值
uint32_t ntohl(uint32_t net32bitvalue);//返回网络字节序的值

字符串格式与网络格式相互转换api

#include <arpa/inet.h>
//字符串转换为网络格式,straddr为存放字符串格式的地址，sddrp为转换完成后存放网络格式的地址
int inet_aton(const char*straddr，struct in_addr *addrp);
//把网络格式转换为字符串格式
char *inet_ntoa(struct in_addr);

监听

int listen(int sockfd,int backlog);

第一个参数：sockfd套接字描述符
第二个参数：backlog最大监听数

连接

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

第二个参数为连接到的客户端ip地址保存的地址
第三个参数为客户端地址长度

数据收发

用文件操作的read和write即可，详情回看文件操作内容

客户端连接

connect(c_fd,(struct sockaddr*)&c_addr,sizeof(struct sockaddr));
//我直接将应用代码写出来了，define的函数我懒得找了

第一个为socket的标识符，第二个写入连接的服务器IP地址端口号等结构体数据，第三个写结构体长度

应用

做一个类似网盘的服务端和客户端，客户端查看网盘的当前路径，读取当前路径的文件，和获取当前路径下的文件
服务端
服务端中对客户端传输过来的指令进行解析，并执行相应操作
对不同指令进行解析操作：

int get_cmd_type(char *cmd)中识别哪个操作
void msg_handler(struct Msg msg, int fd) 对指令执行相应操作，如使用ls等命令行读数据，然后write操作发送至客户端处理
main函数中父进程等待客户端连接，实现多个客户端连接
子进程等待客户端命令传入，并处理

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <config.h>
#include <sys/stat.h>
#include <fcntl.h>


int get_cmd_type(char *cmd)
{
	if(!strcmp("ls",cmd))         return LS;
	if(!strcmp("pwd",cmd))        return LS;
	if(strstr(cmd,"cd")!=NULL)    return CD;
	if(strstr(cmd,"get")!=NULL)        return GET;

	return 100;
}

char *getDesDir(char *cmsg)
{
	char *p;
	p = strtok(cmsg," ");
	p = strtok(NULL," ");
	return p;
}

char dataBuf[128]={0};

void msg_handler(struct Msg msg, int fd)
{
	printf("cmd:%s\n",msg.data);
	int ret = get_cmd_type(msg.data);
	printf("ret=%d\n",ret);
	switch(ret){
		case LS:
			msg.type = 0;
			FILE *r = popen(msg.data,"r");
			fread(msg.data,sizeof(msg.data),1,r);
			write(fd, &msg,sizeof(msg));

			break;
		case CD:
			msg.type = 1;
			char *dir = getDesDir(msg.data);
			printf("dir:%s\n",dir);
			chdir(dir);
			break;

		case GET:
			msg.type = 2;
			printf("get");
			char *file = getDesDir(msg.data);
			int fd2 = open(file,O_RDWR);
			read(fd2,dataBuf,128);
			write(fd,dataBuf,128);
			break;
	}
}


int main(int argc, char **argv)
{
	int s_fd;
	int c_fd;
	int n_read;
	char readBuf[128];

	struct sockaddr_in s_addr;
	struct sockaddr_in c_addr;

	struct Msg msg;
	struct Msg msgsend;


	if(argc != 3){
		printf("param is not good\n");
		exit(-1);
	}

	memset(&s_addr,0,sizeof(struct sockaddr_in));
	memset(&c_addr,0,sizeof(struct sockaddr_in));

	//1. socket
	s_fd = socket(AF_INET, SOCK_STREAM, 0);
	if(s_fd == -1){
		perror("socket");
		exit(-1);
	}

	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&s_addr.sin_addr);


	//2. bind
	bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

	//3. listen
	listen(s_fd,10);
	//4. accept
	int clen = sizeof(struct sockaddr_in);
	while(1){

		c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);
		if(c_fd == -1){
			perror("accept");
		}

		printf("get connect: %s\n",inet_ntoa(c_addr.sin_addr));

		if(fork() == 0){

			while(1){
				n_read = read(c_fd, &msg, sizeof(msg));	
				if(n_read == 0){
					printf("client out\n");
					break;
				}else if(n_read > 0){
					printf("get msg.%d\n",n_read);
					msg_handler(msg,c_fd);
				}
			}
		}

	}
	close(c_fd);
	close(s_fd);
	return 0;
}

客户端

客户端main函数中父函数等待命令输入并处理后发送到服务端，或者在客户端执行该操作
客户端main函数中子函数等待服务端回传数据并打印或者生成新文件

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <string.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include "config.h"
#include <fcntl.h>

int get_cmd_type(char* cmd)
{
        if(!strcmp("ls",cmd)){return LS;}
        else if(!strcmp("pwd",cmd)){return LS;}
        else if(!strcmp("lls",cmd)){return LLS;}
        else if(strstr(cmd,"cd")!=NULL){return CD;}
        else if(strstr(cmd,"get")!=NULL){return GET;}
        else{printf("error\n");}
}

char read_Buff[1028] = {0};
int fd[2],fd1[2];
int len_flie;

char *getDesDir(char *cmsg)
{
        char *p;
        p = strtok(cmsg," ");
        p = strtok(NULL," ");
        return p;
}

void msg_handler(struct Msg msg,int c_fd)
{
        switch(get_cmd_type(msg.data))
        {
                case LS:
                case CD:
                       {
                                msg.type = 1;
                                write(c_fd,&msg,sizeof(msg));
                                break;
                        }
                case GET:
                        {
                                msg.type = 2;
                                write(c_fd,&msg,sizeof(msg));
                                char* File = getDesDir(msg.data);
                                write(fd[1],File,sizeof(File)+1);
                                break;
                        }
                case LLS:
                        {
                                msg.type = 3;
                                system("ls");
                                break;
                        }
        }
//      memset(msg.data,0,sizeof(msg.data));
}       
        
int main(int argc , char**argv)
{       
        int c_fd;
        int c_len;
        struct sockaddr_in c_addr;
        char readBuf[128];
        int n_read;
        struct Msg c_msg;

        memset(&c_addr,0,sizeof(struct sockaddr_in));

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

        pipe(fd);
        pipe(fd1);
        c_addr.sin_family = AF_INET;
        c_addr.sin_port = htons(atoi(argv[2]));
        inet_aton(argv[1],&c_addr.sin_addr);

        c_len = sizeof(struct sockaddr_in);
        if(connect(c_fd,(struct sockaddr*)&c_addr,c_len)==-1)
        {
                exit(-1);
        }
        while(1)
        {

                if(fork() == 0)
                {
                        while(1)
                        {
                                memset(c_msg.data,0,sizeof(c_msg.data));
                                printf("> ");
                                gets(c_msg.data);
                                msg_handler(c_msg,c_fd);
                        }
                }
                close(fd[1]);
                close(fd1[0]);
                while(1)
                {
                        n_read = read(c_fd,&c_msg,sizeof(c_msg));
                                printf("no connect\n");
                        if(n_read == 0)
 {
                                printf("no connect\n");
                                exit(-1);
                        }
                        else
                        {
                                if(c_msg.type == 3 )
                                {
                                        char *flie;
                                        flie = malloc(len_flie);
                                        write(fd1[1],"1",1);

                                        len_flie = read(fd[0],flie,1024);
                                		printf("no connect\n");
                                        printf("flie name:%s,%d",flie,len_flie);
                                        int newfiled = open(flie,O_RDWR|O_CREAT,0600);
                                        write(newfiled,c_msg.data,strlen(c_msg.data));
                                        putchar('>');
                                        free(flie);
                                        close(newfiled);
                                        printf("get file succuse\n");
                                }
                                else
                                {
                                        printf("\n%s\n",c_msg.data);
                                }
                        }
                }
        }

        return 0;
}