Linux网络——套接字编程

最新推荐文章于 2024-06-06 21:42:28 发布
最新推荐文章于 2024-06-06 21:42:28 发布
阅读量339 收藏 10
点赞数
分类专栏： # Linux网络编程系列 文章标签： 套接字编程 HTTP TCP UDP
来自Coolnaut的原创，欢迎在下方指出错误和评论，转载链接为：
本文链接：https://blog.csdn.net/Void_leng/article/details/94176289
版权

前面的概念学习完了，就应该来实践一下了，所以下面开始敲代码，我们来看一看网络编程。

目录

前情概要

套接字

网络字节序

struct sockaddr

客户端与服务端

UDP编程

流程

接收与发送

实战演练

TCP编程

流程

建立连接

接收与发送

实战演练

HTTP应用

HTTP服务器

结束

前情概要

在说编程时，我们先把准备工作做好，就像做饭，我们先把原料弄好，毕竟磨刀不误砍柴功。

  • 套接字

既然是套接字编程，我们先理解什么是套接字。

套接字是是一个文件描述符，描述为socket，而socket的中文意思又是插座。所以你可以把socket当作一个三孔插座。为什么是三孔，请看下面的一个调用接口。

#include <sys/socket.h>//头文件

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

//返回值：成功返回套接字，失败返回-1

这个是创建socket套接字的接口，其中有三个参数：

  1. domain：中文意思，领域，这个在这里叫地址域，它有多种取值，AF_INET：IPv4，AF_INET6：IPv6。我们用AF_INET就好。
  2. type：类型，常见套接字有流式套接字（SOCK_STREAM）和数据报套接字（SOCK_DGRAM）。流式套接字就是TCP用的，数据报套接字是UDP用的。
  3. protocol：协议，有常用的三种取值，数字0 使用默认协议，就是前面的类型是啥，后面的协议就是啥，所以一般就是0；IPPROTO_TCP 或者 数字6就是TCP协议；IPPROTO_UDP或者数字17就是UDP协议。

其实这个套接字就是一个文件的描述符，而文件里面写入了一个IP协议和一个传输协议。后续还会写上更多的东西，就类似我们的IO操作。

这是domian的取值

  • 网络字节序

在C语言阶段，我们学习了字节序。字节序就是数据的每个字节在我们内存上的存储顺序。记得C语言阶段我们这样说的，数据的高位存在低地址上，称为大端序，相反则是小端序。以前我们是通过一个4个字节int型的数据，用一个字节的char来取一个字节来验证机器是什么字节序。在复习一下，例如：

字节序取决于CPU架构，除了我们平时所见的英特尔，还有其他的牌子，如AMD等。所以CPU的存取顺序不一样，在网络上传输过去后，本来是“123456”，结果变成“563421”，这还只是数字，所以在网络上，我们需要统一一个字节序——网络字节序，然后发送的时候，由本机字节序转换成网络字节序，接受时由网络字节序转换为本机字节序，如果和网络字节序相同则不需要转换。当前约定网络字节序为大端序。不仅仅为了数据的一致性，也为了程序的可移植性。

对于转换，就出现了下面的调用接口：

//这是针对端口的
//将主机字节序转换为网络字节序 
unit32_t htonl (unit32_t hostlong); 
unit16_t htons (unit16_t hostshort);
//h: host(本地), n:net(网络) l: long(长整型) s: short (短整型)

//将网络字节序转换为主机字节序 
unit32_t ntohl (unit32_t netlong); 
unit16_t ntohs (unit16_t netshort);

//这是针对IP地址的
in_addr_t inet_addr(const char *cp);
//将字符串点分十进制IP地址转换为网络字节序的整数IP地址

  • struct sockaddr

看名字就知道，给socket添加一个地址，但是不仅仅是添加地址，这个结构体是一个地址信息。现在给socket这个“文件”里面再添加这个地址信息，完善socket。看下面的调用接口：

#include <sys/socket.h>//头文件

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

//返回值：成功返回 0 ，失败返回 -1

这个接口的第一个参数就是前面创建的套接字，第三个参数就是第二个参数这个结构体的大小。重点要说的就是这个结构体。这个结构体struct sockaddr主要是为了接口的统一。

在地址域中我们有AF_INET、AF_INET6、AF_UNIX，对于它们都有自己的结构体。我们一起看了吧。

struct sockaddr { 
    __SOCKADDR_COMMON (sa_);      /* Common data: address family and length.  */
     char sa_data[14];            /* Address data.  */ 
};



/* /usr/include/netinet/in.h */ 
/* Structure describing an Internet socket address.  */
//IPv4
struct sockaddr_in {
     __SOCKADDR_COMMON (sin_);
     in_port_t sin_port; /* Port number.  */ 
    struct in_addr sin_addr; /* Internet address.  */ 

/* Pad to size of `struct sockaddr'.  */
     unsigned char sin_zero[sizeof (struct sockaddr)
     - __SOCKADDR_COMMON_SIZE
     - sizeof (in_port_t)
     - sizeof (struct in_addr)];
 };


 /* /usr/include/netinet/in.h */ 
#ifndef __USE_KERNEL_IPV6_DEFS 
/* Ditto, for IPv6.  */

 struct sockaddr_in6 {
    __SOCKADDR_COMMON (sin6_);
    in_port_t sin6_port;             /* Transport layer port # */
    uint32_t sin6_flowinfo;          /* IPv6 flow information */
    struct in6_addr sin6_addr;       /* IPv6 address */
    uint32_t sin6_scope_id;          /* IPv6 scope-id */
 };

三个结构体中都有一个__SOCKADDR_COMMON，其实就是一个unsigned short int。

typedef unsigned short int sa_family_t;

#define __SOCKADDR_COMMON(sa_prefix) sa_family_t sa_prefix##family

#define __SOCKADDR_COMMON_SIZE  (sizeof (unsigned short int))

下面对三个结构体画图。

由于接口要统一，所以第二个参数则是一个结构体指针，我们在使用的时候，则需要对我们的sockaddr_in等进行一个强转，但是对于sockaddr_in6它占的大小这么多，于是就有了第三个参数，我们需要传入结构体的大小，当sockaddr指针取到前两个字节就已经知道这是哪个地址信息了，因为前两个字节是地址域。具体怎么使用，我们在后面的代码上会有体现。

  • 客户端与服务端

首先我们要知道，对于网络通信，总是有一方先发起请求，另一方进行响应。于是我们把发起请求的一方称为客户端，响应的一方称为服务端。

在发起请求之前，服务端会告诉客户端，其IP地址和程序运行的端口。

UDP编程

  • 流程

有了上面的基础，下面我们把流程以及思路梳理清楚。对于UDP，它是无连接，不可靠的，所以它的流程较为简单。如图所示。

  • 接收与发送

在这里需要说明两个接口，由于UDP和TCP的数据接收和数据发送的两个接口不一样，因为UDP无连接的，而TCP是有连接的。所以这里分开来说。

#include <sys/socket.h>

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);

返回值：成功返回接收的字节数，，失败返回 -1，，为 0 时对端关闭

 看名字就已经知道这是，发送数据，参数虽然多，但是一看就可以明白的。

socked：套接字

buf：要接收的数据

len：接收数据长度

flags：调用方式，有很多种方式，多个时可以用 |，但通常置 0， 代表阻塞接收

src_addr：发送端的地址信息，这是输出型参数

addrlen：地址信息结构体的长度，输入型的参数，也就是说我们要接收多长的地址信息

#include <sys/socket.h>

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);

返回值：成功返回发送的字节数，失败返回 -1

socked：套接字

buf：要发送的数据

len：数据长度

flags：调用方式，通常置 0

src_addr：接收端的地址信息，这是输入型参数

addrlen：本端地址信息结构体的长度，输入型的参数

  • 实战演练

首先我们对socket API进行封装，方便我们调用。

  • udpsocket.h
#include<iostream>
#include<sys/socket.h>//创建套接字的头文件
#include<netinet/in.h>//地址信息结构体、IP字节序转换头文件
#include<arpa/inet.h>//端口号字节序转换
#include<string>
#include<string.h>
#include<unistd.h>//close的头文件
using namespace std;

#define CHECK_RET(q) if((q) == false){return -1;}
class UdpSocket
{
	public:
		UdpSocket()
			:socket_(-1)
		{
			//创建套接字不放在构造中，因为创建失败后无法处理
		}
		bool CreateSocket()
		{

			socket_ = socket(AF_INET,SOCK_DGRAM,0);
			if(socket_ < 0)
			{
				cout << "create error" << endl;
				return false;
			}
			return true;
		}
		bool Bind(string& ip, uint16_t& port)
		{
			struct sockaddr_in addr;
			addr.sin_family = AF_INET;
			addr.sin_port = htons(port);//这里就需要网络字节序
			addr.sin_addr.s_addr = inet_addr(ip.c_str());//同上
			socklen_t len = sizeof(addr);
			int ret = bind(socket_,(sockaddr*)&addr,len);
			if(ret < 0)
			{
				cout << "bind error" << endl;
				return false;
			}
			return true;
		}
		bool Recv(string& retmsg, struct sockaddr_in* cliaddr = NULL)
		{//如果用户没有给第二个参数则不管，是缺省的，如果给了，则返回发送端的地址
                    
			char buff[1024];
			struct sockaddr_in addr;
			socklen_t len = sizeof(addr);
			int ret = recvfrom(socket_,buff,1023,0,
                            (struct sockaddr*)&addr,&len);
			if(ret < 0)
			{
				cout << "recv error" << endl;
				return false;
			}
			if(ret == 0)
			{
				cout << "peer down" << endl;
				return false;
			}
			retmsg.assign(buff);
			if(cliaddr != NULL)
			{
				memcpy(cliaddr,&addr,len);
			}
			return true;
		}
		bool Send(string& buff, struct sockaddr_in& destaddr)
		{
			socklen_t len = sizeof(destaddr);
			int ret = sendto(socket_,buff.c_str(),buff.size()
                            ,0,(struct sockaddr*)&destaddr,len);

			if(ret < 0)
			{
				cout << "sned error" << endl;
				return false;
			}
			return true;
		}
		bool Close()
		{
			close(socket_);
			socket_ = -1;
			return true;
		}
	private:
		int socket_;
};
  • 服务端server.cpp
#include<iostream>
#include<stdio.h>
#include"udpsocket.h"
using namespace std;

int main()
{
	string ip = "192.168.138.135";
	uint16_t port = 9000;
	UdpSocket sock;
	CHECK_RET(sock.CreateSocket());
	CHECK_RET(sock.Bind(ip,port));
	while(1)
	{
		struct sockaddr_in client;//创建一个IPv4的结构体，用来获取客户端地址
		string buff;
		sock.Recv(buff,&client);
		cout << "client say: " << buff << endl;

		cout << "server.say: ";
		fflush(stdout);
		cin >> buff;
		sock.Send(buff,client);//有了客户端地址，就可以发送了
	}
	sock.Close();
	return 0;
}
  • 客户端 client.cpp
#include<iostream>
#include<stdio.h>
#include"udpsocket.h"
using namespace std;


int main()
{
	string ip = "192.168.138.135";
	UdpSocket client;
	CHECK_RET(client.CreateSocket());
	struct sockaddr_in seraddr;    //服务端的地址信息，客户端没有绑定地址的
	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(9000);
	seraddr.sin_addr.s_addr = inet_addr(ip.c_str());
	while(1)
	{
		string msg;
		cout << "client say: ";
		fflush(stdout);
		cin >> msg;
		client.Send(msg,seraddr);
		
		client.Recv(msg);
		cout << "server say: " << msg << endl;
	}
	client.Close();
	return 0;
}

TCP编程

  • 流程

对比UDO，TCP的流程就要多加三步操作了——开始监听、发起请求、建立连接

  • 建立连接

建立连接的过程，对比三次握手。这里有三个过程就是上面的三个过程。分别是下面的接口。

  • 开始监听
#include <sys/socket.h>

int listen(int s, int backlog);

//返回值：成功返回 0，失败返回 -1

 第一个参数是套接字，socket，第二个参数则指定了已经完成连接正等待应用程序接收的套接字队列的长度。也就是说，在内核中有两个队列。

  • 发起请求
#include <sys/socket.h>

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

//返回值：成功返回 0，失败返回 -1

这里参数和UDP是一样的。socked：套接字，addr：接收端地址信息，addrlen：地址信息长度

  • 建立连接
#include <sys/socket.h>

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

//返回值：成功返回与客户端通信的新套接字，失败返回 -1

addr：  用于存储客户端地址信息 

addrlen：用于设置想要的地址长度和保存实际的地址长度

  • 接收与发送

这里接收与发送就比较简单了，因为已经建立了连接，所以相对简单许多

  • 接收
#include <sys/socket.h>

//这里是recv，不再是recvfrom
ssize_t recv(int sockfd, void *buf, size_t len, int flags)

//返回值：实际接收的字节数/对端关闭连接返回0    错误：-1

sockfd:   套接字描述符
buf：     存储接收的数据
len：     想要接收的长度
flags:    0-阻塞接收   
MSG_PEEK-接收数据但是数据不从接收缓冲区移除 

  • 发送
#include <sys/socket.h>

//是send，不是sendto
int send(int s, const void *msg, size_t len, int flags);
//返回值：实际发送的字节数      失败：-1
//若连接已经断开，发送会触发异常

  • 实战演练

还是一样，先封装。

  • tcpsocket.h
#include<iostream>
#include<sys/socket.h>
#include<string>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include <arpa/inet.h>//htons的头文件
#include<string.h>
using namespace std;
#define CHECK_RET(q) if((q) == false){ return -1; }
class TcpSocket
{
	public:
		bool CreateSocket()
		{
			socket_ = socket(AF_INET, SOCK_STREAM, 6);
			if(socket_ < 0)
			{
				cout << "create error!" << endl;
				return false; 
			}
			return true;
		}
		bool Listen(int lisMax = 5)//开始监听，设置服务端的同一时间最大并发连接数
		{
			//int listen(int sockfd, int backlog);
			//sockfd:   套接字描述符
			//backlog： backlog设置内核中已完成连接队列的最大节点数量
			int ret = listen(socket_,lisMax);
			if(ret < 0)
			{
				cout << "listen error" << endl;
				return false;
			}
			return true;
		}
		bool SetFd(int fd)
		{
			socket_ = fd;
			return true;
		}
		bool Accept(TcpSocket& socket,struct sockaddr_in *addr = NULL)
		{	
    		        sockaddr_in add;
			socklen_t len = sizeof(sockaddr_in);
			int ret = accept(socket_,(sockaddr*)&add, &len);
                        //接下来与客户端的通信都是通过这个socket描述符实现的        
			if(ret < 0)
			{
				cout << "accept error" << endl;
				return false;
			}
			socket.SetFd(ret);
			if(addr)
			{
				memcpy(addr, &add, len);
			}
			return true;
		}
		客户端向服务端发起连接请求
		bool Connect(string& ip, uint16_t port)//建立连接
		{

			struct sockaddr_in addr;
			addr.sin_family = AF_INET;
			addr.sin_addr.s_addr = inet_addr(ip.c_str());
			addr.sin_port = htons(port);
			socklen_t len = sizeof(addr);
			int ret = connect(socket_,(sockaddr*)&addr,len);
			if(ret < 0)
			{
				cout << "connect error" << endl;
				return false;
			}
			return true;
		}
		bool Bind(string& ip,uint16_t&  port)
		{

			struct sockaddr_in  addr;
			addr.sin_family = AF_INET;

			addr.sin_port = htons(port);
			addr.sin_addr.s_addr = inet_addr(ip.c_str());

			socklen_t len = sizeof(addr);
			int ret = bind(socket_,(sockaddr*)&addr,len);
			if(ret < 0)
			{
				cout << "bind error" << endl;
				return false;
			}
			return true;
		}
		bool Recv(string& buff)
		{	
			char buf[1024] = {0};
			int ret = recv(socket_, buf, 1023, 0);
			if(ret < 0)
			{
				cout << "recive error!" << endl;
				return false;
			}
			else if(ret == 0)
			{
				cout << "peer down" << endl;
				return false;
			}
			buff.assign(buf);
			return true;
		}
		bool Send(string& buff)
		{
			int ret = send(socket_, buff.c_str(), buff.size(), 0);
			if(ret < 0)
			{
				cout << "send error" << endl;
				return false;
			}
			return true;
		}
		bool Close()
		{
			close(socket_);
			socket_ = -1;
			return true;
		}
	private:
		int socket_ = -1;
};
  • server.cpp
#include<iostream>
#include<pthread.h>
#include "tcpsocket.h"
using namespace std;
void* func(void* arg)
{
	TcpSocket* clisocket = ((TcpSocket*)arg);
	while(1)
	{
		string buff;
		clisocket->Recv(buff);
		cout << "client say:" << buff << endl;
		buff.clear();
		cout << "server say:";
		fflush(stdout);
		cin >> buff;
		clisocket->Send(buff);
	}
	clisocket->Close();
	return NULL;
}
int main()
{
	string ip("192.168.138.135");
	uint16_t port_ = 9000;
	TcpSocket socket;
	CHECK_RET(socket.CreateSocket());
	CHECK_RET(socket.Bind(ip,port_));
	CHECK_RET(socket.Listen());
	while(1)
	{
		TcpSocket* clisocket = new TcpSocket();
		if(socket.Accept(*clisocket) == false)
		{
			cout << "someone clienr accept error" << endl;
			continue;
                //一个客户端的失败，我们不能直接return false，因为还有其他客户端
		}
		pthread_t thread;
                //使用线程，可以和多个客户端通信
		pthread_create(&thread,NULL,func,(void*)clisocket);
		pthread_detach(thread);
	}
	socket.Close();
	return 0;	
}
  • client.cpp
#include<iostream>
#include"tcpsocket.h"
using namespace std;
int main()
{
	TcpSocket client;	
	CHECK_RET(client.CreateSocket());
	string ip("192.168.138.135");
	uint16_t port = 9000;
	CHECK_RET(client.Connect(ip,port));
	while(1)
	{
		string buff;
		cout << "client say: ";
		fflush(stdout);
		cin >> buff;
		client.Send(buff);
		buff.clear();
		client.Recv(buff);
		cout << "server say: " << buff << endl;

	}
	client.Close();
	return 0;
}

有了准备工作和UDP的练习，畅快了很多。

HTTP应用

  • HTTP服务器

既然有了TCP，就来实现一个简单的HTTP服务器，这样对HTTP协议会有更进一步的认知。

#include<iostream>
#include"tcpsocket.h"
#include<stdlib.h>
using namespace std;
int main()
{
	int i = 0;
	TcpSocket sersocket;
	string ip = "192.168.138.135";
	uint16_t port = 9000;
	CHECK_RET(sersocket.CreateSocket());
	CHECK_RET(sersocket.Bind(ip,port));
	CHECK_RET(sersocket.Listen());
	while(1)
	{
		TcpSocket client;
		if(sersocket.Accept(client) == false)
		{
			cout << "Accept Error" << endl;
			continue;
		}
		string recv;
		client.Recv(recv);//在服务器上，我们显示HTTP请求
		cout << "client[" << i++ << "]" << endl;
		cout << recv << endl;
		string resp,bodystr;
		const char* body = "<h1>hello world</h1>";
		char buff[1024];
		sprintf(buff,"HTTP/1.1 200 OK\nContent-Length:%lu\n\n%s",strlen(body),body);
		
		bodystr += buff;
		client.Send(bodystr);//根据HTTP协议发送数据
		client.Close();
	}
	sersocket.Close();
	return 0;
}

在虚拟机的Linux上，可能会访问失败，因为防火墙。根据下面的命令可以关闭和开启防火墙

关闭防火墙的命令：systemctl stop firewalld.service                                                               
启动防火墙的命令：systemctl start firewalld.service

 

  •  客户端则会出现下面的界面。

 

  • 服务端则是

结束

OK，到这里网络的学习就告一段落了，如果有小伙伴们读到这，衷心感谢您的耐心了。这一系列比较仓促，如果有不足或者错误的地方欢迎指正。

 

__MrCool
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程间通信——使用流套接字
09-15
【Linux进程间通信——使用流套接字】这篇文章主要介绍了如何利用socket进行进程间通信，尤其是跨网络的通信。Socket，又称套接字，是一种通信机制，它允许不同计算机或同一计算机上的进程通过网络进行通信。以下是...
LINUX网络编程 .zip
04-09
首先，我们要理解Linux网络编程的基础——套接字（Sockets）。套接字是进程间通信的一种方式，也是网络通信的核心接口。在Linux中，可以使用伯克利套接字API来创建、绑定、监听和连接套接字。套接字分为流式（TCP）...
Linux网络编程——原始套接字编程
m0_67401920的博客
08-20 706
网卡的混杂模式一般在网络管理员分析网络数据作为网络故障诊断手段时用到，同时这个模式也被网络黑客利用来作为网络数据窃听的入口。默认的情况下，我们接收数据，目的地址是本地地址，才会接收。有时候我们想接收所有经过网卡的所有数据流，而不论其目的地址是否是它，这时候我们需要。原始套接字编程和之前的 UDP 编程差不多，无非就是创建一个套接字后，通过这个套接字接收数据或者发送数据。protocol：协议类别，指定可以接收或发送的数据包类型，不能写 “0”，取值如下，成功( >0 )：套接字，这里为链路层的套接字。
网络编程套接字（ TCP ）
bit_zyx的博客
03-22 3221
目录 1、实现一个TCP网络程序（单进程版） 1.1、服务端serverTcp.cc文件 服务端创建套接字 服务端绑定 服务端监听 服务端获取连接 服务端提供服务 服务端main函数命令行参数 服务端serverTcp.cc总代码
Linux 网络编程——套接字的介绍
秋叶原 && Mike || 麦克
04-14 9705
套接字是一种通信机制（通信的两方的一种约定），凭借这种机制，不同主机之间的进程可以进行通信。我们可以用套接字中的相关函数来完成通信过程。 流套接字（SOCK_STREAM）： 流套接字用于提供面向连接、可靠的数据传输服务。该服务将保证数据能够实现无差错、无重复发送，并按顺序接收。流套接字之所以能够实现可靠的数据服务，原因在于其使用了传输控制协议，即TCP（The Transmission Control Protocol）协议。 数据报套接字（SOCK_DGRAM）： 数据报套接字提供了一种无连接的服务。该
Linux网络编程——Unix本地套接字
热门推荐
人人都懂物联网
10-26 1万+
概述　　今天，给大家讲解网络编程中的一个内容——Unix 本地套接字。 　　发现很多人不知道或者不太了解 Unix 本地套接字这个概念，这也难怪，socket API 原本就是为多台主机之间网络通信设计的，并且这种网络 socket 同样支持单台主机上的进程间通信，当然这样做的话，仍然需要 IP 地址和端口号（通过 loopback 地址 127.0.0.1）。Unix本地套接字，其实就是一种专门
Linux 网络编程——原始套接字SOCK_RAW
Hamlee67的博客
10-22 1858
通常情况下程序员接所接触到的套接字（Socket）为两类： （1）流式套接字（SOCK_STREAM）：一种面向连接的 Socket，针对于面向连接的TCP 服务应用； （2）数据报式套接字（SOCK_DGRAM）：一种无连接的 Socket，对应于无连接的 UDP 服务应用。 从用户的角度来看，SOCK_STREAM、SOCK_DGRAM 这两类套接字似乎的确涵盖了 TCP/IP 应用的全部，...
网络编程——流式套接字编程
LSYZWF的博客
04-24 2528
文章目录目的内容源代码及结果 目的 （1）熟悉Linux环境下流式套接字编程的基本模型、函数使用细节等，掌握Linux环境下流式套接字编程的具体过程。 （2）熟悉Windows环境下流式套接字编程的基本模型、函数使用细节等，掌握Windows环境下流式套接字编程的具体过程 内容 （1） 使用流式套接字实现一个Linux环境下的迭代回声服务器端(及客户端)； （2） 使用流式套接字实现一个Windows环境下的迭代回声服务器端(及客户端)。 （3） 使服务器端和客户端各传递1次字符串。考虑到使用TCP协议，
Linux——（十）网络编程套接字
graceyun的博客
04-04 1491
套接字编程网络通信编程、TCP和UDP协议的区别初识、tcpudpUDP通信程序的编写
【Linux取经路】网络套接字编程——初识篇
最新发布
春人.的博客
06-06 1253
本篇文章介绍了套接字编程的基础，介绍了常用的套接字编程 API
linux网络编程——配置套接字属性
u014687354的博客
08-05 468
linux网络编程——配置套接字属性
进程间通信(7)——套接字
私房菜
07-07 1586
进程通信的概念最初来源于单机系统。由于每个进程都在自己的地址范围内运行，为保证两个相互通信的进程之间既互不干扰又协调一致工作，操作系统为进程通信提供了相应设施，如：它们都仅限于本地进程间通信。而网络间通信要解决的是不同主机进程间的通信问题（可把同机进程间通信看成一个特例）。同一主机上，不同进程可用进程号（process ID）唯一标识。但在网络环境下，各主机独立分配的进程号不能唯一标识该进程。例如，主机A赋于某进程号5，在B机中也可以存在5号进程，因此，“5号进程”这句话就没有意义了。
linux C语言 网络编程教程及源码
05-12
4、Linux网络编程04——套接字 5、Linux网络编程05——C/S与B/S架构的区别 6、Linux网络编程06——UDP协议编程 7、Linux网络编程07——广播 8、Linux网络编程08——多播 9、Linux网络编程09——TCP编程之客户端 10、...
Linux 网络编程——TCP编程示例代码
05-12
总结一下，Linux上的TCP编程涵盖了套接字接口的使用、网络地址的表示、IO模型的选择、连接的建立与关闭、数据的传输以及异常处理等多个方面。通过学习和实践，开发者可以构建出稳定、高效的网络服务。参考链接提供的...
三次握手与四次挥手
Coulnaut的博客
08-03 1896
简介 传输层在前面的博文中已经详细的介绍了，以漫画 + 画图的方式，因此这里不在赘述。但是相关的细节叙述的不是太好，因此主针对TCP的三次握手和四次挥手再次进行叙述。联系上socket套接字编程进行说明。
Linux网络——传输层
Coulnaut的博客
06-27 1079
在我们传输层的下面就是运输层，传输层是整个网络体系结构中最重要的一层之一，因为传输层为数据的传输提供服务，这也是网络最基本的要求，数据的共享就需要数据的传输。当然本层设计的内容复杂且逻辑性强，博文将尽量以通俗易懂的方式传递对知识的个人理解。 目录 端口号 认识端口号 端口号和进程id 端口号的划分 实践 命令 UDP 认识UDP 特点 格式 TCP 认识TCP 特点 ...
Linux网络——网络层
Coulnaut的博客
06-28 603
终于来到了网络层，这一层就好好熟悉我们经常见到的IP地址。 目录 一、功能 二、IP协议格式 三、IP地址 IP地址 五类IP地址 ⼦网掩码 IP地址的进阶技术 私有IP地址和公网IP地址 四、路由 一、功能 网络层的功能主要在于路由功能，路由就是路径选择，也就是为数据包在复杂的网络环境中找一条合适的路径。 例如，某市的A大学的G同学和B大学的M同学在异地恋，每个周...
Linux网络——应用层
Coulnaut的博客
06-23 551
认识到网络后，从每个层来介绍网络，主要说的是每个层著名的协议。首先是离我们最近的应用层。 目录 认识应用层 概念 协议 DNS协议 介绍 域名的分层 DNS解析过程 HTTP协议 URL HTTP 认识应用层 概念 负责应⽤程序间沟通，如超文本传输（HTTP）、简单电⼦邮件传输（SMTP）、⽂件传输协议（FTP）、网络远程访问协议（Telnet）等.，它...
Linux网络——认识网络
Coulnaut的博客
06-22 456
Linux强大的地方就是它的网络了。后面将记录一系列网络编程的学习。先来认识一下网络吧。 目录 网络的历史 第一阶段——阿帕网 第二阶段——三级结构 第三阶段——多层次ISP 互联网的组成 边缘部分 核心部分 体系结构 协议 OSI 七层参考模型 TCP/IP四层体系结构 网络传输的基本流程 数据包的封装 数据包的分用 基本流程 总结 网络的历史 说到网...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值