Linux编程基础——Socket编程

最新推荐文章于 2024-04-23 14:49:43 发布
最新推荐文章于 2024-04-23 14:49:43 发布
阅读量490 收藏
点赞数
分类专栏： C++学习 Linux学习 计算机网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/okiwilldoit/article/details/48134607
版权

Linux下的Socket编程大体上包括Tcp Socket、Udp Socket即Unix Domain Socket这三种，其中TCP和UDP方式的Socket编程用于编写应用层的socket程序，是我们用得比较多的，Unix Domain Socket主要用于unix的本地通信。

TCP Socket

基于TCP协议的客户端/服务器程序的一般流程一般如下：

它基本上可以分为三个部分：

一、建立连接：

  1. 服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态
  2. 客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答
  3. 服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。

二、传输数据：

建立连接后，TCP协议提供全双工的通信管道，服务器端和客户端根据协议可以通过read和write的反复调用实现数据的传输

三、关闭连接：

当数据传输已经完成后，服务器和客户端可以调用Close关闭连接，一端关闭连接后，另一端read函数则会返回0，可以根据这个特征来感应另一端的退出。

下面就以一个简单的EchoServer演示一下如何创建服务器端和客户端代码，其中和socket相关api都会高亮显示。

服务器端步骤：

   1. socket(int domain,int type,int protocol):建立套接字；

   2 .bind(int sockid,struct sockaddr *addrp,socklen_t addrlen):把本机地址和端口跟上一步建立的socket绑定在一起；

   3. listen(int sockid,int qsize):监听某套接字;

   4. fd=accept(int sockid,struct sockaddr *callerid,socklen_t *addrlenp):等待某套接字接收信息；

   5. read(int fd,void *buf,size_t nbytes):从套接字接收数据;

   6. close(fd) 和close(sockid) 

#include <iostream>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

using namespace std;
 
#define MAXLINE 80
#define SERV_PORT 8000
 
int main()
{
 	//设置一个socket地址结构server_addr,代表服务器internet地址, 端口
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddr_len;
    int listenfd, connfd;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];

    //创建用于internet的流协议(TCP)socket,用server_socket代表服务器socket
    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));//把一段内存区的内容全部设置为0
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);

    bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    listen(listenfd, 20);

    cout<<"Accepting connections ..."<<endl;
    cliaddr_len = sizeof(cliaddr);
    
    while (1) 
    {
       connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
       int n = read(connfd, buf, MAXLINE);
       if(n>0){
          cout<<"received from "<<inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str))
          <<" at PORT "<<cliaddr.sin_port<<":"<<buf<<endl;
       }
         
       for (int i = 0; i < n; i++)//将从client接收到的字母转化为大写，回送给client
               buf[i] = toupper(buf[i]);
       n = write(connfd, buf, sizeof(buf));
    }
    close(connfd);
    close(listenfd);
 }

客户端步骤：

   1. socket():建立套接字；

   2.connect(int sockid,struct sockaddr *serv_addrp,socklen_t addrlen):连接到服务器；

   3. write(int sockfd,const void *buf,size_t nbytes):发送数据到服务器.

   4. close(sockid);

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

using namespace std;

#define MAXLINE 80
#define SERV_PORT 8000

int main(int argc, char *argv[])
{
    char buf[MAXLINE];

    int sockfd = socket(AF_INET, SOCK_STREAM, 0);

    sockaddr_in servaddr = {0};
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
    servaddr.sin_port = htons(SERV_PORT);

    if (0 != connect(sockfd, (sockaddr *)&servaddr, sizeof(servaddr)))
    {
        cout<<"connected failed"<<endl;
        return 1;
    }

    char message[20];
    cin>>message;
    
	int count = write(sockfd, message, sizeof(message));
	if(count > 0){
	  	cout<<"send to server:"<<message<<endl;
	}else{
	  	cout<<"fail send to server"<<endl;
	  	return 1;
	}
	  
	count = read(sockfd, buf, sizeof(message));
	if(count > 0){
	  	cout<<"response from server: "<<buf<<endl;
	}
    close(sockfd);
    return 0;
}
UDP Socket

典型的UDP客户端/服务器通讯过程如下图所示：

由于UDP不需要维护连接，程序逻辑简单了很多，但是UDP协议是不可靠的，实际上有很多保证通讯可靠性的机制需要在应用层实现，可能反而会需要更多代码。

服务端步骤：

1：加载套接字库，创建套接字(socket())；

2：绑定套接字到一个IP地址和一个端口上(bind())；

3：等待和接收数据(sendto()/recvfrom())；

4：关闭套接字，关闭加载的套接字库 (close())。 

#include <iostream>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

using namespace std;
 
#define MAXLINE 80
#define SERV_PORT 8888
 
int main()
{
 	  //设置一个socket地址结构server_addr,代表服务器internet地址, 端口
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];

    //创建用于internet的数据报协议(UDP)socket,用server_socket代表服务器socket
    int serverfd = socket(AF_INET, SOCK_DGRAM, 0);

    bzero(&servaddr, sizeof(servaddr));//把一段内存区的内容全部设置为0
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);
    
    int ret = bind(serverfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    if(ret < 0){
        cout<<"fail bind"<<endl;
        return 0;
    }
    
    /* 定义一个地址，用于捕获客户端地址 */
    struct sockaddr_in client_addr;
	socklen_t client_addr_length = sizeof(client_addr);

    while (1) 
    {   	
       int n = recvfrom(serverfd,buf,sizeof(buf),0,(struct sockaddr *)&client_addr,&client_addr_length);
       if(n>0){
          cout<<"received from "<<inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str))
          <<" at PORT "<<client_addr.sin_port<<":"<<buf<<endl;
          for(int i = 0; i < n; i++)//将从client接收到的字母转化为大写，回送给client
               buf[i] = toupper(buf[i]);
          sendto(serverfd,buf,sizeof(buf),0,(struct sockaddr *)&client_addr,sizeof(client_addr));
       }
    }
    close(serverfd);
    return 0;
}

客户端步骤：

1：创建一个套接字(socket)；

2：向服务器发送数据(sendto);

3：关闭套接字； 
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

using namespace std;

#define MAXLINE 80
#define SERV_PORT 8888

int main(int argc, char *argv[])
{
    char buf[MAXLINE];

    /* 服务端地址 */
    sockaddr_in servaddr = {0};
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
    servaddr.sin_port = htons(SERV_PORT);

    //定义一个client socket
    int client_fd = socket(AF_INET, SOCK_DGRAM, 0);

    cin>>buf;
    int count = sendto(client_fd,buf,sizeof(buf),0,(struct sockaddr *)&servaddr,sizeof(servaddr));
    if(count>0){
    	cout<<"success send to server"<<endl;
        socklen_t server_add_len = sizeof(servaddr);
    	int n = recvfrom(client_fd,buf,sizeof(buf),0,(struct sockaddr *)&servaddr,&server_add_len);
       	if(n>0){
          cout<<"response from server:"<<buf<<endl;
       	}
    }else{
    	cout<<"fail send to server"<<endl;
    } 
    close(client_fd);
    return 0;
}
UNIX Socket
socket API原本是为网络通讯设计的，但后来在socket的框架上发展出一种IPC机制，就是UNIXDomain Socket。虽然网络socket也可用于同一台主机的进程间通讯（通过loopback地址127.0.0.1），但是UNIX Domain Socket用于IPC更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。这是因为，IPC机制本质上是可靠的通讯，而网络协议是为不可靠的通讯设计的。UNIX Domain Socket也提供面向流和面向数据包两种API接口，类似于TCP和UDP，但是面向消息的UNIX Domain Socket也是可靠的，消息既不会丢失也不会顺序错乱。

使用UNIX Domain Socket的过程和网络socket十分相似，也要先调用socket()创建一个socket文件描述符，address family指定为AF_UNIX，type可以选择SOCK_DGRAM或SOCK_STREAM，protocol参数仍然指定为0即可。

UNIX Domain Socket与网络socket编程最明显的不同在于地址格式不同，用结构体sockaddr_un表示，网络编程的socket地址是IP地址加端口号，而UNIX Domain Socket的地址是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用创建，如果调用bind()时该文件已存在，则bind()错误返回。

下面是unix udp通信的例子：
服务器端： 
#include <iostream>
#include <sys/types.h>  
#include <sys/socket.h>  
#include <sys/un.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <stdio.h>  
using namespace std;

#define MAXLINE 60  

int main()  
{  
  /* delete the socket file */
  unlink("server_socket");
    
  /* create a UNIX socket */  
  int serverfd = socket(AF_UNIX, SOCK_DGRAM, 0);
    
  struct sockaddr_un server_addr;  
  server_addr.sun_family = AF_UNIX;  
  strcpy(server_addr.sun_path, "server_socket");
    
  /* bind with the local file */  
  bind(serverfd, (struct sockaddr *)&server_addr, sizeof(server_addr));     
    
  char buf[MAXLINE];
  struct sockaddr_un client_addr;  
  socklen_t len = sizeof(client_addr);  

  while(1)  
  {  
    int n = recvfrom(serverfd,buf,sizeof(buf),0,(struct sockaddr *)&client_addr,&len);
    if(n>0){
      cout<<"received:"<<buf<<endl;
    } 
  }  
  close(serverfd);  
  return 0;  
}
客户端： 
#include <iostream>
#include <sys/types.h>  
#include <sys/socket.h>  
#include <sys/un.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <stdio.h>  
using namespace std;

#define MAXLINE 60 
  
int main()  
{  
    /* create a socket */  
    int client_fd = socket(AF_UNIX, SOCK_DGRAM, 0);  
    
    /*server address*/
    struct sockaddr_un servaddr;  
    servaddr.sun_family = AF_UNIX;  
    strcpy(servaddr.sun_path, "server_socket");
    
    char buf[MAXLINE];
    cin>>buf;

    int count = sendto(client_fd,buf,sizeof(buf),0,(struct sockaddr *)&servaddr,sizeof(servaddr));  
    if(count>0){
      cout<<"send success:"<<buf<<endl;
    }
       
    /* close the socket */  
    close(client_fd);     
    return 0;  
}




okiwilldoit
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Linux的网络编程——网络聊天程序
09-02
网络聊天程序是目前应用极为广泛的一种网络软件，对于方便人们的交流沟通非常有效，同时，... 程序基于Linux系统开发，纯C语言Socket实现多个客户端之间通信，由服务器端进行数据处理，基本实现聊天功能的基础运用。
Linux下socket实现TCP网络通讯
06-10
在学习《UNIX网络编程》基础上自己动手实现TCP服务器和客户端通讯，程序包含了常规网络通讯的主要步骤，思路清晰，代码注释详细，适合入门或者有一定基础的人学习。代码已经无误通过测试。后面有进阶版程序——实现...
Linux网络编程——socket 通信基础
weixin_43412762的博客
03-02 1692
socket 本身有“ 插座 ”的意思，在 Linux 环境下，用于表示 进程间网络通信 的 特殊文件类型。本质为 内核 借助 缓冲区 形成的 伪文件。既然是文件，那么理所当然的，我们可以使用 文件描述符 引用套接字。与管道类似的，Linux 系统将其封装成文件的目的是为了 统一接口，使得 读写套接字 和 读写文件 的操作一致。区别是 管道 主要应用于 本地进程间通信，而 套接字 多应用于 网络进程间数据的传递。
Linux 网络编程——socket 网络编程
NRWHF的博客
11-11 2133
Linux 网络编程——socket 网络编程
Linux网络编程——socket编程
qq_37233070的博客
03-16 3407
一、socket socket 网络套接字 一个文件文件描述符指向一个套接字（该套接字内部由内核借助两个缓冲区实现（接收缓冲区和发送缓冲区）） 通讯过程中，套接字一定是 成对 出现的。 二、网络字节序 ...
Linux网络编程（一）——Socket网络编程基础
天山老妖
02-28 1667
一、Socket简介 1、网络中进程间通信 本机进程使用进程号区别不同的进程，进程间通信方式有管道、信号、消息队列、共享内存、信号量等。网络中进程间的通信，首先需要识别进程所在主机在网络中的唯一标识，即网络层的IP地址，主机上的进程可以通过传输层的协议与端口号识别。 2、Socket原理 Socket是应用层与TCP/IP协议族通信的中间软件抽象层，是一种编程接口。Socket屏蔽了不同网络协议的差异，支持面向连接(Transmission Control Protocol - TCPIP)和无连接
Linux下socket编程基础——socket地址API
Veaxen的博客
05-13 668
socket编程指的是一整套关于socket的API编程，不是只有socket()系统调用的使用，还有围绕着这一个系统调用的一整套函数。下面我们将从基础的地方开始，了解如何初步的编写socket程序。主机字节序和网络字节序要学习socket编程，首先先了解下什么是字节序。现代CPU的累加器一次都能装载（至少）4个字节（这里考虑32位机器，下同）。那么这4个字节在内存中的排列的顺序将影响它被累加器装载
Linux Socket编程入门——浅显易懂
凉、介熙
03-22 1371
Linux基础编程，文章很浅显，讲的不深，后面会一点一点的，由浅入深的讲解。
Linux网络编程 ——UDP 通信
weixin_43412762的博客
03-04 1571
Linux网络编程 ——UDP 通信 1. UDP 1.1 UDP 通信 1.2 广播 1.3 组播（多播） 2. 本地套接字
Linux系统编程5——Socket编程(网络通信)
m0_43424329的博客
12-06 1144
linux 网络编程详解
Linux系统编程——网络编程
最新发布
m0_60697583的博客
04-23 272
这个服务器是单线程的，对于每个连接它都创建一个子进程来处理，但是这个示例并不适用于生产环境，因为它没有考虑到并发连接和错误处理。：Socket是Linux网络编程中最基本的概念之一。以下是一个简单的C语言示例，演示了如何在Linux上实现一个基本的HTTP服务器。：除了直接使用底层的Socket API外，还有一些网络编程框架可以简化网络应用程序的开发，例如Boost.Asio和libevent等。：Linux提供了许多套接字选项，开发者可以使用这些选项来配置套接字的行为，例如设置超时、设置缓冲区大小等。
Boost无锁队列
热门推荐
罗布泊coding
03-24 1万+
在开发接收转发agent时，采用了多线程的生产者-消费者模式，用了加互斥锁的方式来实现线程同步。互斥锁会阻塞线程，所以压测时，效率并不高。所以想起用无锁队列来实现，性能确实提升了。一. 用互斥锁实现单生产者-单消费者#include &lt;string&gt; #include &lt;sstream&gt; #include &lt;list&gt; #include &lt;pthread.h&gt; #include &lt;i
用反射机制合并两个Protobuf
罗布泊coding
07-29 6040
对于protobuf的合并操作，官方api提供了MergeFrom函数。如： pd1.MergeFrom(pb2), 该方法对于非repeated类型，优先使用pb2，对于repeated类型，就是将两个字段的值取并集，并且无法去重。有时无法满足我们的项目需求。 我们可以使用protobuf的google::protobuf::Descriptor和google::protobuf::Reflection实现将两个相同类型的pb合并。代码如下： addressbook.proto文件： package zh
倒排索引C++实现
罗布泊coding
05-10 5866
倒排索引原理：根据属性的值来查找记录位置。 假设有3篇文章，file1, file2, file3，文件内容如下： file1 (单词1，单词2，单词3，单词4....) file2 (单词a，单词b，单词c，单词d....)  file3 (单词1，单词a，单词3，单词d....) 那么建立的倒排索引就是这个样子： 单词1 (file1,file3)   单词2 (fi
Arena内存池简介
罗布泊coding
11-25 3592
一. 什么是内存池？ 内存池（Memory Pool）是一种内存分配方式，又被称为固定大小区块规划（fixed-size-blocks allocation）。 通常我们习惯直接使用new、malloc等API申请分配内存，这样做的缺点在于：由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。 内存池是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点
Linux进程通信-信号量C++实现
罗布泊coding
10-31 2893
一、什么是信号量为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，信号量就可以提供这样的一种访问机制，让一个临界区同一时间只有一个进/线程在访问它，也就是说信号量是用来调协进程对共享资源的访问的。信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和释放（即V(信号变量))信息操作。最简单的信号量是只能取0和1的变量，这也是信号量最常见的一种形式，叫
blade构建protobuf小项目
罗布泊coding
08-27 1657
一.简介 google protobuf是一个灵活的、高效的用于序列化数据的协议。相比较XML和JSON格式，protobuf更小、更快、更便捷。google protobuf是跨语言的，并且自带了一个编译器(protoc)，只需要用它进行编译，可以编译成Java、python、C++、C#、Go等代码，然后就可以直接使用，不需要再写其他代码，自带有解析的代码。 更详细的介绍见: http...
用Blade构建glog和gflags小项目
罗布泊coding
08-27 1510
一.Blade介绍 Blade 是一个现代构建系统，期望的目标是强大而好用，把程序猿从构建的繁琐中解放出来。 Blade主要定位于linux下的大型C++项目，密切配合研发流程。比方单元測试。持续集成，覆盖率统计等。但像unix下的文本过滤程序一样，保持相对的独立性，能够单独执行。眼下重点支持i386/x86_64 Linux，未来能够考虑支持其他的类unix系统。 在腾讯公司“台风”云计算...
Linux编程基础实验
05-23
4. 学习Linux下的网络编程，包括Socket编程和TCP/IP协议。 5. 学习Linux下的文件系统操作，例如文件读写、文件锁、文件权限等。 6. 熟悉Linux下的Shell编程，包括Shell脚本的编写、调试和执行。 7. 学习Linux下的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值