Linux——使用Socket实现C/S模型

最新推荐文章于 2024-05-13 19:14:19 发布
最新推荐文章于 2024-05-13 19:14:19 发布
阅读量440 收藏 3
点赞数 2
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoan08133192/article/details/105322685
版权

1，C/S模型创建流程图

      注意，下图，TCP客户端没有调用bind函数，这时候会有默认的IP和端口号。而服务器端就要进行绑定，因为如果让它分配随机的情况下，客户端调用connect函数的时候不知道绑定的服务器端的socket信息。

       2，服务器端代码如下：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>

#define SERV_PORT 9527

int main(void)
{
    int sfd, cfd;
    int len, i, ret;
    char buf[BUFSIZ], clie_IP[BUFSIZ];

    struct sockaddr_in serv_addr, clie_addr;
    socklen_t clie_addr_len;

    /*创建一个socket 指定IPv4协议族 TCP协议*/
    sfd = socket(AF_INET, SOCK_STREAM, 0);

    if(sfd == -1){
       perror("socket error");
       exit(1);
    }

    /*初始化一个地址结构 man 7 ip 查看对应信息*/
    bzero(&serv_addr, sizeof(serv_addr));           //将整个结构体清零
    serv_addr.sin_family = AF_INET;                 //选择协议族为IPv4
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);  //监听本地所有IP地址
    serv_addr.sin_port = htons(SERV_PORT);          //绑定端口号    

    /*绑定服务器地址结构*/
    ret = bind(sfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

    if(ret== -1){
       perror("bind error");
       exit(1);
    }

    /*设定链接上限,注意此处不阻塞*/
    ret = listen(sfd, 64);                          //同一时刻允许向服务器发起链接请求的数量
    if(sfd == -1){
       perror("listen error");
       exit(1);
    }

    printf("wait for client connect ...\n");

    /*获取客户端地址结构大小*/ 
    clie_addr_len = sizeof(clie_addr);
    /*参数1是sfd; 参2传出参数, 参3传入传入参数, 全部是client端的参数*/
    cfd = accept(sfd, (struct sockaddr *)&clie_addr, &clie_addr_len);           /*监听客户端链接, 会阻塞*/
    if(cfd == -1){
       perror("accept error");
       exit(1);
    }

    printf("client IP:%s\tport:%d\n", 
            inet_ntop(AF_INET, &clie_addr.sin_addr.s_addr, clie_IP, sizeof(clie_IP)), 
            ntohs(clie_addr.sin_port));

    while (1) {
        /*读取客户端发送数据*/
        len = read(cfd, buf, sizeof(buf));
        write(STDOUT_FILENO, buf, len);

        /*处理客户端数据*/
        for (i = 0; i < len; i++)
            buf[i] = toupper(buf[i]);

        /*处理完数据回写给客户端*/
        write(cfd, buf, len); 
    }

    /*关闭链接*/
    close(sfd);
    close(cfd);

    return 0;
}

       注意，上面的if语句的作用是对错误的时候进行判断，如果出错给出相应的处理规则。但是这样做，会使逻辑变得不是很清楚。还有另外一种处理错误的方法，为使错误处理的代码不影响主程序的可读性，我们把与socket相关的一些系统函数加上错误处理代码包装成新的函数，做成一个模块wrap.c(这里面使用的还是系统的函数，只不过把错误处理放到了这里面，使主程序的可读性增强了（与上面的if方法相比）)：

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>

void perr_exit(const char *s)
{
	perror(s);
	exit(-1);
}

int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
	int n;

again:
	if ((n = accept(fd, sa, salenptr)) < 0) {
		if ((errno == ECONNABORTED) || (errno == EINTR))//慢速系统调用
			goto again;
		else
			perr_exit("accept error");
	}
	return n;
}

int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;

	if ((n = bind(fd, sa, salen)) < 0)
		perr_exit("bind error");

    return n;
}

int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;
    n = connect(fd, sa, salen);
	if (n < 0) {
		perr_exit("connect error");
    }

    return n;
}

int Listen(int fd, int backlog)
{
    int n;

	if ((n = listen(fd, backlog)) < 0)
		perr_exit("listen error");

    return n;
}

int Socket(int family, int type, int protocol)
{
	int n;

	if ((n = socket(family, type, protocol)) < 0)
		perr_exit("socket error");

	return n;
}

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
	ssize_t n;

again:
	if ( (n = read(fd, ptr, nbytes)) == -1) {
		if (errno == EINTR)
			goto again;
		else
			return -1;
	}

	return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
	ssize_t n;

again:
	if ((n = write(fd, ptr, nbytes)) == -1) {
		if (errno == EINTR)
			goto again;
		else
			return -1;
	}
	return n;
}

int Close(int fd)
{
    int n;
	if ((n = close(fd)) == -1)
		perr_exit("close error");

    return n;
}

/*参三: 应该读取的字节数*/                          //socket 4096  readn(cfd, buf, 4096)   nleft = 4096-1500
ssize_t Readn(int fd, void *vptr, size_t n)
{
	size_t  nleft;              //usigned int 剩余未读取的字节数
	ssize_t nread;              //int 实际读到的字节数
	char   *ptr;

	ptr = vptr;
	nleft = n;                  //n 未读取字节数

	while (nleft > 0) {
		if ((nread = read(fd, ptr, nleft)) < 0) {
			if (errno == EINTR)
				nread = 0;
			else
				return -1;
		} else if (nread == 0)
			break;

		nleft -= nread;   //nleft = nleft - nread 
		ptr += nread;
	}
	return n - nleft;
}

ssize_t Writen(int fd, const void *vptr, size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;

	ptr = vptr;
	nleft = n;
	while (nleft > 0) {
		if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
			if (nwritten < 0 && errno == EINTR)
				nwritten = 0;
			else
				return -1;
		}
		nleft -= nwritten;
		ptr += nwritten;
	}
	return n;
}

static ssize_t my_read(int fd, char *ptr)
{
	static int read_cnt;
	static char *read_ptr;
	static char read_buf[100];

	if (read_cnt <= 0) {
again:
		if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {   //"hello\n"
			if (errno == EINTR)
				goto again;
			return -1;
		} else if (read_cnt == 0)
			return 0;

		read_ptr = read_buf;
	}
	read_cnt--;
	*ptr = *read_ptr++;

	return 1;
}

/*readline --- fgets*/    
//传出参数 vptr
ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
	ssize_t n, rc;
	char    c, *ptr;
	ptr = vptr;

	for (n = 1; n < maxlen; n++) {
		if ((rc = my_read(fd, &c)) == 1) {   //ptr[] = hello\n
			*ptr++ = c;
			if (c == '\n')
				break;
		} else if (rc == 0) {
			*ptr = 0;
			return n-1;
		} else
			return -1;
	}
	*ptr = 0;

	return n;
}

       注意慢速系统调用的函数需要进行特殊处理。

  • read函数返回值

        1) > 0 表示实际读到的字节数 （当buf =1024的时候， 当读到的字节数小于1024的时候，说明已经读到文件末尾）

        2）=0 表示数据读完（读到文件，管道，socket末尾）

        3）-1 表示出现了异常，这个时候可以通过errno对异常进行细分。（errno = EINTER 表示被信号中断，这个时候可以重启或停止；errno = EAGAIN（EWOLDBLOCK）表示以非阻塞方式读，并且没有数据；errno = 其他值的时候表示出现了错误）

  •  Readn(自己封装的函数)函数，可以指定读取字节的个数
  • Readline函数是自己封装的从套接字里面读取一行的函数

wrap.h的代码如下：

#ifndef __WRAP_H_
#define __WRAP_H_

void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);

#endif

3，客户端代码如下：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#define SERV_IP "127.0.0.1"
#define SERV_PORT 9527

int main(void)
{
    int sfd, len;
    struct sockaddr_in serv_addr;
    char buf[BUFSIZ]; 

    /*创建一个socket 指定IPv4 TCP*/
    sfd = socket(AF_INET, SOCK_STREAM, 0);

    /*初始化一个地址结构:*/
    bzero(&serv_addr, sizeof(serv_addr));                       //清零
    serv_addr.sin_family = AF_INET;                             //IPv4协议族
    inet_pton(AF_INET, SERV_IP, &serv_addr.sin_addr.s_addr);    //指定IP 字符串类型转换为网络字节序 参3:传出参数
    serv_addr.sin_port = htons(SERV_PORT);                      //指定端口 本地转网络字节序

    /*根据地址结构链接指定服务器进程*/
    connect(sfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

    while (1) {
        /*从标准输入获取数据*/
        fgets(buf, sizeof(buf), stdin);
        /*将数据写给服务器*/
        write(sfd, buf, strlen(buf));       //写个服务器
        /*从服务器读回转换后数据*/
        len = read(sfd, buf, sizeof(buf));
        /*写至标准输出*/
        write(STDOUT_FILENO, buf, len);
    }

    /*关闭链接*/
    close(sfd);

    return 0;
}

 

哎呦，帅小伙哦
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 系统应用编程——网络编程（I/O模型）
知秋一叶
01-14 2726
Unix下可用的5种I/O模型： 阻塞I/O 非阻塞I/O I/O复用(select和poll) 信号驱动I/O(SIGIO) 异步I/O(POSIX的aio_系列函数) 前四种都是同步，只有最后一种才是异步IO。   一个输入操作通常包括两个不同的阶段： 1）等待数据准备好； 2）从内核向进程复制数据；   对于一个套接字的输入操作，第一步通常涉及等待数据从网络中
Linux网络编程——协议(C/S模型进行TCP通信)
Strive_LiJiaLe的博客
01-16 698
笔记
Linux下的网络编程——C/S模型 UDP（三）
妄北y
09-23 2361
UDP（User Datagram Protocol，用户数据报协议）是一种在计算机网络中常用的传输层协议。与TCP（传输控制协议）相比，UDP是一种无连接的协议，不具备可靠性和流量控制等特性，但由于其简单、高效的特点，被广泛应用于实时性要求较高、对数据完整性要求较低的应用场景。下面让我们一起对UDP进行一个简单的学习吧。
Linux进程间通信_socket（套接字）
最新发布
liuning1985622的博客
05-13 1036
socket是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。传输层实现端到端的通信，因此，每一个传输层连接有两个端点。那么，传输层连接的端点是什么呢？不是主机，不是主机的IP地址，不是应用进程，也不是传输层的协议端口。传输层连接的端点叫做套接字（socket）。根据RFC793的定义：端口号拼接到IP地址就构成了套接字。
Linux 15：基于C/S架构——微云盘
小柒的秃头之路
11-04 579
基于C/S架构模型——微云盘（2）项目环境：Linux,vim,gcc上传功能：将文件从客户端上传到服务器，显示百分比，实现文件校验，秒传下载功能：将文件从服务器端下载到客户端，显示下载文件百分比，断点续传，文件校验断点续传：当文件在下载中中断，下次可接着上次中断地方继续下载秒传：当服务器已经存在某个文件时，当别的用户再次上传时，服务器直接返回下载成功一个散列函数，比如 MD5，是一个将任意长度的数据字符串转化成短的固定长度的值的单向操作。
Linux系统——I/O模型
一坨小橙子的博客
02-20 1655
I/O模型（Input，Output）同步异步、阻塞非阻塞
Linux使用C语言实现Socket编程
qq_61585528的博客
04-11 1197
Linux使用C语言实现Socket编程
（四十九）socket编程——网络套接字函数及建立C/S模型(TCP)
FadeFarAway的博客
01-22 4923
一、网络套接字函数1）socket#include <sys/types.h> #include <sys/socket.h>int socket(int domain, int type, int protocol); domain: AF_INET 这是大多数用来产生socket的协议，使用TCP或UDP来传输，用IPv4的地址 AF_INET6 与上面类似，不过是来用IPv6的
Java后端自顶向下方法——TCP编程与I/O模型
物是人非，结局始终不美
09-27 2601
Java后端自顶向下方法——网络编程初步（TCP与HTTP编程） （一）简述 这是讲Tomcat高级篇的前奏曲，因为网络编程是Tomcat高级篇的基础之一，同时是我们必须要掌握的一项基本技能。很多人不重视网络编程，因为感觉他离我们很遥远，认为做开发不需要去关注这些过于底层的东西。其实不然，了解网络编程，可以帮助我们更好的理解Tomcat乃至于其他的WEB服务器的原理。 我们经常会看到类似这种层次图，其中Socket、TCP和部分IP的功能都是由操作系统提供的，不同的编程语言只是提供了对操作系统调用的简单的
Linux 网络编程学习笔记——六、高级 I/O 函数
热门推荐
BeZer0的学习笔记
03-23 1万+
pipe 函数的参数是一个包含两个 int 型整数的数组指针。该函数成功时返回 0 ，并将一对打开的文件描述符值填入其参数指向的数组。如果失败，则返回 -1 并设置 errno。通过 pipe 函数创建的这两个文件描述符 fd[0] 和 fd[1] 分别构成管道的两端，往 fd[1] 写入的数据可以从 fd[0] 读出。并且，fd[0] 只能用于从管道读出数据，fd[1] 则只能用于往管道写入数据，而不能反过来使用。如果要实现双向的数据传输，就应该使用两个管道。默认情况下，这一对文件描述符都是阻塞的。
Linux学习之网络编程2（socket，简单C/S模型）
yourgrandfather_的博客
01-11 1107
Linux网络编程系列的第二篇。主要介绍了套接字socket，把上一章的理论应用到实践中，介绍了怎么建立网络通信，分别从语法，功能，参数，返回值多个方面详细讲解了建立通信的几个函数。最后写了个小demo，建立简单C/S模型来把上面学的知识学以致用，附有完整源代码。
Linux——网络编程（epoll、epoll反应堆、心跳、线程池）
一个小孩
04-07 4184
1，epoll函数 epoll是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率，因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的...
Linux系统中查找当前目录下指定的文件内容
一个小孩
06-30 3971
linux命令
Linux命令——uptime
一个小孩
10-16 2684
这个命令的用法比较简单，但是很实用，可以查看系统的负载，以及机器运行的时间。 从左向右： 11：01：42 当前时间 up 2 days，15：49 当前机器运行了2天15个小时49分钟 3 users 当前机器有3个用户真正使用 load average：0.06，0.04，0.05 当前机器的一分钟内，三分钟，十五分钟内的平均负载分别是0.06，0.04，0.05 注意：uptime可以查看系统负载！！...
鸟哥私房菜第3章——主机规划与磁盘分区
一个小孩
02-26 2165
1，在Linux系统中，每个设备都被当成一个文件对待。在linux系统中，几乎所有的设备文件都在/dev（device）这个目录内。所以你会看到/dev/hda，/dev/fd0等的文件名。下面的图片可见常见的设备与其在Linux当中的文件名。 对于SATA接口来说，由于SATA/USB/SCSI等磁盘接口都使用SCSI模块来驱动，因此这些接口的磁盘设备文件都是 /dev/sd[a-p]的格式。但是与IDE接口不同的是，SATA/USB接口的磁盘根本没有一定的顺序，怎么决定设备文件名呢？这
Linux面试常问命令
一个小孩
10-10 1394
1，rm 命令 -r 递归的删除文件夹下的内容 -f 强制删除，如果文件夹下没有指定的文件，也不会进行提示。例如，rm -f file0。如果当前文件夹下没有file0这个文件，不会报错。 2，mkdir 命令 -p 使用这个参数可以建立多级目录。 3，cp，mv命令 cp /test1/file1 /test3/file2 如将/test1目录下的file1复制到/test3目录，并将文件名改为file2 mv /test1/f...
Linux——基础（vim，gcc编译，静态库，动态库）
一个小孩
03-11 647
1，vim基本使用介绍 vim被称为编辑器之神，vim是可以打造成IDE的，现阶段水平的作者用到，这里不再详述。只介绍简单的使用。 vim的三种模式 1）命令模式 -- 打开文件之后，默认进入命令模式，vi 文件名字 2）编辑模式/输入模式 --需要输入一些命令，切换到编辑模式 3）末行模式 --在末行模式中可以输入一些命令(不...
Linux——网络编程（UDP、广播、组播、domain）
一个小孩
04-07 608
1，UDP协议 在计算机网络的文章中已经进行了详细介绍，这里不再描述。 注意：UDP也有可能出现缓冲区被填满后，再接收数据时丢包的现象。由于它没有TCP滑动窗口的机制，通常采用如下两种方法解决：1）服务器应用层设计流量控制，控制发送数据速度。 2）借助setsockopt函数改变接收缓冲区大小。如： #include <sys/socket.h> i...
Linux——子进程回收
一个小孩
03-18 523
exec函数族 fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。 将当前进程的.text、.data替...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值