Linux网络编程2

最新推荐文章于 2023-06-06 16:02:30 发布
最新推荐文章于 2023-06-06 16:02:30 发布
阅读量76 收藏
点赞数 1
文章标签： 网络 linux tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41597303/article/details/127391830
版权

Day2

TCP是面向连接的安全的数据传输, 在客户端与服务端建立建立的时候要经过三次握手的过程, 在客户端与服务端断开连接的时候要经历四次挥手的过程, 下图是客户端与服务端三次握手建立连接, 数据传输和断开连接四次挥手的全过程.

(1) 三次握手

  • TCP时序
    在这里插入图片描述
    上图中ACK表示确认序号, 确认序号的值是对方发送的序号值+数据的长度, 特别注意的是SYN和FIN本身也会占用一位.
    注: SYS----->synchronous
    ACK----->acknowledgement
    FIN------>finish
    SYN: 表示请求, ACK:表示确认
    服务端发送的SYN和客户端发送的SYN本身也会占1位.
    图中发送的ACK确认包表示给对方发送数据的一个确认, 表示你发送的数据我都收到了, 同时告诉对方下次发送该序号开始的数据.
    由于每次发送数据都会收到对方发来的确认包, 所以可以确认对方是否收到了, 若没有收到对方发来的确认包, 则会进行重发.
    mss: 最大报文长度, 告诉对方我这边最多一次能收多少, 你不能超过这个长度.
    win: 表示告诉对方我这边缓存大小最大是多少.
  • TCP数据报格式
    在这里插入图片描述
    ps：csdn设置图片大小方法<图片(英文) src=“链接” width=“70%”>
    三次握手
    通信的时候不再需要SYN标识位了, 只有在请求连接的时候需要SYN标识位.
    传输数据的时候的随机序号seq就是最近一次对方发送给自己的ACK的随机序号值, 而发给对方的ACK就是上次刚刚发给对方的ACK的值.

(2) 滑动窗口

主要作用: 滑动窗口主要是进行流量控制的.
见下图:如果发送端发送的速度较快，接收端接收到数据后处理的速度较慢，而接收缓冲区的大小是固定的，就会导致接收缓冲区满而丢失数据。TCP协议通过“滑动窗口（Sliding Window）”机制解决这一问题。
在这里插入图片描述
图中win表示告诉对方我这边缓冲区大小是多少, mss表示告诉对方我这边最多一次可以接收多少数据, 你最好不要超过这个长度.

在客户端给服务端发包的时候, 不一定是非要等到服务端返回响应包, 由于客户端知道服务端的窗口大小, 所以可以持续多次发送, 当发送数据达到对方窗口大小了就不再发送, 需要等到对方进行处理, 对方处理之后可继续发送.

数据发送到接收方的读缓冲区

mss和MTU

  1. MTU: 最大传输单元
    MTU:通信术语最大传输单元（Maximum Transmission Unit，MTU）是指一种通信协议的某一层上面所能通过的最大数据包大小（以字节为 单位). 最大传输单元这个参数通常与通信接口有关（网络接口卡、串 口等), 这个值如果设置为太大会导致丢包重传的时候重传的数据量较大, 图中的最大值是1500, 其实是一个经验值.
  2. mss: 最大报文长度, 只是在建立连接的时候, 告诉对方我最大能够接收多少数据, 在数据通信的过程中就没有mss了.
  3. 粘包：多次数据发送, 收尾相连, 接收端接收的时候不能正确区分第一次发 送多少, 第二次发送多少.
    对方发送数据连续发了两次，然后读数据的时候第一次没有读完，剩余数据在第二次读走，这种情况属于粘包。
  4. 粘包解决方法：
    包头+数据
    如4位的数据长度+数据 -----------> 00101234567890
    其中0010表示数据长度, 1234567890表示10个字节长度的数据.另外, 发送端和接收端可以协商更为复杂的报文结构, 这个报文结 构就相当于双方约定的一个协议.

（3）代码块

  1. wrap.c
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <strings.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;

	if ((n = connect(fd, sa, salen)) < 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;
}

/*参三: 应该读取的字节数*/
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;

	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;
		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) {
			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;
}

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++ = c;
			if (c  == '\n')
				break;
		} else if (rc == 0) {
			*ptr = 0;
			return n - 1;
		} else
			return -1;
	}
	*ptr  = 0;

	return n;
}

int tcp4bind(short port,const char *IP)
{
    struct sockaddr_in serv_addr;
    int lfd = Socket(AF_INET,SOCK_STREAM,0);
    bzero(&serv_addr,sizeof(serv_addr));
    if(IP == NULL){
        //如果这样使用 0.0.0.0,任意ip将可以连接
        serv_addr.sin_addr.s_addr = INADDR_ANY;
    }else{
        if(inet_pton(AF_INET,IP,&serv_addr.sin_addr.s_addr) <= 0){
            perror(IP);//转换失败
            exit(1);
        }
    }
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port   = htons(port);
    Bind(lfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
    return lfd;
}
  1. wrap.h
#ifndef __WRAP_H_
#define __WRAP_H_
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <strings.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);
int tcp4bind(short port,const char *IP);
#endif

  1. 多进程方案
    多进程版本开发流程
    1 创建socket, 得到一个监听的文件描述符lfd—socket()
    2 将lfd和IP和端口port进行绑定-----bind();
    3 设置监听----listen()
    4 进入while(1)
    {
    //等待有新的客户端连接到来
    cfd = accept();

    //fork一个子进程, 让子进程去处理数据
pid = fork();
if(pid<0)
{
	exit(-1);
}
else if(pid>0)
{
	//关闭通信文件描述符cfd
	close(cfd);
}
else if(pid==0)
{
	//关闭监听文件描述符
	close(lfd);
	
	//收发数据
	while(1)
	{
		//读数据
		n = read(cfd, buf, sizeof(buf));
		if(n<=0)
		{
			break;
		}
		
		//发送数据给对方
		write(cfd, buf, n);
	}
	
	close(cfd);
	
	//下面的exit必须有, 防止子进程再去创建子进程
	exit(0);
}

    }
    close(lfd);

还需要添加的功能: 父进程使用SIGCHLD信号完成对子进程的回收
注意点: accept或者read函数是阻塞函数, 会被信号打断, 此时不应该视为一个错误.
errno=EINTR

父子进程能够共享的:
文件描述符(子进程复制父进程的文件描述符)
mmap共享映射区

#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>
#include "wrap.c"

//信号处理函数
void waitchild(int signo)
{
	pid_t wpid;
	while(1)//while目的防止多个子进程同时使用
	{
		wpid = waitpid(-1, NULL, WNOHANG);
		if(wpid > 0)
		{
			printf("child exit, wpid==[%d]\n", wpid);
		}
		else if(wpid == 0 || wpid == -1)
		{
			break;
		}
	}
}


int main() {
    //创建socket
    int lfd = Socket(AF_INET, SOCK_STREAM, 0);
	
	//设置端口复用
	int opt = 1;
	setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));

    //绑定
    struct sockaddr_in serv;
    bzero(&serv, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8888);
    serv.sin_addr.s_addr = htonl(INADDR_ANY);
    Bind(lfd, (struct sockaddr *)&serv, sizeof(serv));

    //设置监听
    Listen(lfd, 128);
	
	//阻塞SIGCHLD信号
	sigset_t = mask;
	sigemptyset(&mask);
	sigaddset(&mask, SIGCHLD);
	sigprocmask(SIG_BLOCK, &mask, NULL);

    pid_t pid;
    int cfd;
    char sIP[16];
    socklen_t len;
    struct sockaddr_in client;

    while(1) {
        //接受新的连接
        len = sizeof(client);
        memset(sIP, 0x00, sizeof(sIP));
        cfd = Accept(lfd, (struct sockaddr*)&client, &len);
        printf("client:[%s], [%d]\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));

        pid = fork();
        if(pid < 0) {
            perror("fork error");
            exit(-1);
        }
        else if(pid > 0) {
            //关闭通信文件描述符cfd
            close(cfd);
			
			//注册SIGCHLD信号处理函数
			struct sigaction act;
			act.sa_handler = waitchild;
			act.sa_flags = 0;
			sigemptyset(&act.sa_mask);
			sigaction(SIGCHLD, &act, NULL);
			
			//解除对SIGCHLD信号的阻塞
			sigprocmask(SIG_UNBLOCK, &mask, NULL);
        }
        else if(pid == 0) {
            //关闭监听文件描述符
            close(lfd);
            
            int i = 0;
            int n;
            char buf[1024];

            while(1) {
                //读数据
                n = Read(cfd, buf, sizeof(buf));
                if( n<=0 ){
                    printf("read error or client closed, n == [%d]\n", n);
                    break;
                }

               // printf("client:[%s], [%d]\n", inet_ntop(AF_INET, client.sin_addr.s_add    r, sIP, sizeof(sIP), ntohs(client.sin_port)));父子进程的client互不影响
                printf("[%d]--->, n==[%d], buf==[%s]\n", ntohs(client.sin_port),  n, buf);

                //将小写转换为大写
                for(i = 0; i < n; i++) {
                    buf[i] = toupper(buf[i]);
                }

                //发送数据
                Write(cfd, buf, n);
            }

            //关闭cfd
            close(cfd);
            exit(0);
        }
    }

    //关闭监听文件描述符
    close(lfd);
    return 0;
}

  1. 多线程方案
    多线程版本的服务器开发流程:
    {
    1 创建socket, 得到一个监听的文件描述符lfd—socket()
    2 将lfd和IP和端口port进行绑定-----bind();
    3 设置监听----listen()
    4 while(1)
    {
    //接受新的客户端连接请求
    cfd = accept();

    //创建一个子线程
pthread_create(&threadID, NULL, thread_work, &cfd);

//设置线程为分离属性
pthread_detach(threadID);

    }

    close(lfd);
    }

子线程执行函数:
void *thread_work(void *arg)
{
//获得参数: 通信文件描述符
int cfd = *(int *)arg;

	while(1)
	{
		//读数据
		n = read(cfd, buf, sizeof(buf));
		if(n<=0)
		{
			break;
		}
		
		//发送数据
		write(cfd, buf, n);
	}
	
	close(cfd);
}

问题:
1 子线程能否关闭lfd?
子线程不能关闭监听文件描述符lfd,原因是子线程和主线程共享文件描述符
而不是复制的.
2 主线程能否关闭cfd?
主线程不能关闭cfd, 主线程和子线程共享一个cfd, 而不是复制的, close之后cfd就会
被真正关闭.
3 多个子线程共享cfd, 会有什么问题发生?

struct INFO
{
int cfd;
pthread_t threadID;
struct sockaddr_in client;
};
struct INFO info[100];

//初始化INFO数组
for(i=0; i<100; i++)
{
info[i].cfd=-1;
}

for(i=0; i<100; i++)
{
if(info[i].cfd==-1)
{
//这块内存可以使用
}
}

if(i==100)
{
//拒绝接受新的连接
close(cfd);
}

#include <string.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <ctype.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"

typedef struct info
{
	int cfd;//若为-1表示可用，大于0表示已被占用
	int idx;
	pthread_t thread;
	struct sockaddr_in client;
}INFO;

INFO thInfo[1024];

//子线程回调函数
void *thread_work(void *arg)
{
	INFO *p = (INFO *)arg;
	printf("idx == [%d]\n", p->idx);
	
	char sIP[16];
	memset(sIP, 0x00, sizeof(sIP));
	printf("new client:[%s][%d]\n", inet_ntop(AF_INET, &p->client.sin_addr.s_addr, \
	        sIP, sizeof(sIP)), ntohs(p->client.sin_port));
			
	int n;
	int cfd = p->cfd;
	struct sockaddr_in client;
	memcpy(&client, &(p->client), sizeof(client));
	
    //int cfd = *(int *)arg;
    printf("cfd==[%d]\n", cfd);

    int i;
    char buf[1024];

    while(1)
    {
        //read数据
        memset(buf, 0x00, sizeof(buf));
        n = Read(cfd, buf, sizeof(buf));
        if(n<=0)
        {
            printf("read error or client closed, n==[%d]\n", n);
			Close(cfd);
			p->cfd = -1;//设置为-1表示该位置可用
            pthread_exit(NULL);
        }
        printf("n==[%d], buf==[%s]\n", n, buf);

        for(i = 0; i < n; i++)
        {
            buf[i] = toupper(buf[i]);
        }
        //发送数据给客户端
        Write(cfd, buf, n);
    }

    //关闭通信文件描述符
    close(cfd);

    pthread_exit(NULL);
}

void init_thInfo()
{
	int i = 0;
	for(i = 0; i < 1024; i++)
	{
		thInfo[i].cfd = -1;
	}
}

int findIndex()
{
	int i;
	for(i = 0; i < 1024; i++)
	{
		if(thInfo[i].cfd == -1)
		{
			break;
		}
	}
	if(i == 1024)
	{
		return -1;
	}
	
	return i;
}


int main() 
{
    //创建socket
    int lfd = Socket(AF_INET, SOCK_STREAM, 0);
	
	//设置端口复用
	int opt = 1;
	setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
    
    //绑定
    struct sockaddr_in serv;
    bzero(&serv, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8888);
    serv.sin_addr.s_addr = htonl(INADDR_ANY);
    Bind(lfd, (struct sockaddr *)&serv, sizeof(serv));

    //设置监听
    Listen(lfd, 128);
	
	//初始化
	init_thInfo();

    int cfd;
	int ret;
	int idx;
	socklen_t len;
	struct sockaddr_in client;
    pthread_t thread;
    while(1)
    {
		len = sizeof(client);
		bzero(&client, sizeof(client));
        //接受的新的连接
        cfd = Accept(lfd, (struct sockaddr *)&client, &len);

		//找数组中的空闲位置
		idx = findIndex();
		if(idx == -1)
		{
			Close(cfd);
			continue;
		}
		
		//对空闲位置的元素成员赋值
		thInfo[idx].cfd = cfd;
		thInfo[idx].idx = idx;
		memcpy(&thInfo[idx].client, &client, sizeof(client));
		
		
        //创建子线程--该子线程完成对数据的收发
		ret = pthread_create(&thInfo[idx].thread, NULL, thread_work,&thInfo[idx]);
		if(ret != 0)
		{
			printf("create thread error:[%s]\n", strerror(ret));
			exit(-1);
		}
        

        //设置子线程为分离属性
        pthread_detach(thInfo[idx].thread);
    }

    //关闭监听文件描述符
    close(lfd);

    return 0;
}
冷漠文科生
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux 网络编程
qq_39855356的博客
09-16 3269
linux系统编程-网络编程
Linux网络编程(二)
simon曦的博客
02-11 257
目录目录 前言 链路层的一些概念 MTU 以太网帧格式 网络层的一些概念 与IP协议配套使用的协议 IP协议 分类IP地址 IP数据报格式 路由表 传输层的一些概念 传输控制协议TCP TCP的连接 TCP报文格式 三次握手 连接终止四次握手 TCP可靠性 滑动窗口协议 用户数据报协议UDP UDP的主要特点 总结 链接地址前言实体(entity)表示任何可发送或接受信息的硬件或软件进程。 协议是
2、TCP、多进程并发、多线程并发（linux网络编程）
伍粟的博客
05-01 402
三次握手和四次挥手的过程都是在内核实现的. 三次握手 通信的时候不再需要SYN标识位了, 只有在请求连接的时候需要SYN标识位. 传输数据的时候的随机序号seq就是最近一次对方发送给自己的ACK的随机序号值, 而发给对方的ACK就是上次刚刚发给对方的ACK的值. 四次挥手 函数封装思想 函数封装的思想-处理异常情况 结合man-page和errno进行封装. 在封装的时候起名可以把第一个函数名的字母大写, 如socket可以封装成Socket, 这样可以按shift+k进行搜索, shift+k搜索函数
Linux程序设计--线程
何亮5083的博客
10-21 372
什么是线程 线程的优点和缺点 第一个线程程序 信号量 互斥量 线程属性 多线程 1. 什么是线程 在一个程序中的多个执行路线就叫线程。更准确的说：线程就是一个进程内部的一个控制序列。弄清楚fork系统调用和创建新线程之间的区别非常重要。当进程执行fork调用时，将创建出该进程的一份新副本。这个新进程拥有自己的变量和之间的PID，它的时间调用也是独立的，他们的执行几乎完全独立与父进程。当在进
linux网络编程
m0_72749070的博客
09-03 5364
自学笔记整理，如有不对，请指正
Linux系统编程——网络编程
猪jio杆炖不耙丶的博客
05-12 1667
Linux系统编程--网络编程
linux网络编程（2）
硝烟过客
08-15 421
底层网络编程底层的编程主要是和TCP/IP协议紧密关联的，比如设置IP头信息，设置TCP、UDP头信息，设置ICMP数据包，ARP地址解析协议等。这一切能够实现的基础就是SOCK_RAW–原始套接字。原始套接字的使用对于学习和掌握TCP/IP协议时非常有帮助的。总的来说，有两种用法：Socket(AF_INET, SOCK_RAW, IPPROTO_TCP); // IPPROTO_UDP, IP
Linux网络编程.pdf
07-22
Linux网络编程
Linux网络编程.rar
07-26
linux网络编程
Linux网络编程，包括tcp/upd，select/poll/epoll/pdf
04-14
linux网络编程 pdf # Linux网络编程基础 Linux网络编程是指在Linux操作系统上开发网络应用程序的过程。它主要涉及到TCP/UDP协议以及select/poll/epoll等多路复用技术。 TCP/UDP协议是网络通信的基础，其中TCP协议...
作业2 Linux网络编程
12-08
使用TCP套接字来编写一个模拟用户远程登录的程序。采用多进程的方式实现服务器对多个客户端连接请求的响应，主程序创建套接字后将其绑定到4507端口，然后使套接字处于监听状态，调用accept等待来自客户端的连接请求...
Linux基础之网络编程
weixin_55374007的博客
08-27 1934
1）进程间通信的方式有**：管道，消息队列，共享内存，信号，信号量这么集中2）特点：依赖于linux内核，基本是通过内核来实现应用层的两个进程间的通信3）缺陷：无法多机通讯1）网络编程适用去不同的pc间的通信，可以实现多机运行地址和数据地址是指：IP地址和端口号。每台PC机连网够都有一个IP地址，那么每台联网的PC机可能跑多个服务器，然后每个服务器中对应的有很多进程。当客户端接入的时候，不知道去对接哪个服务器。那么这时端口号对应的就是每个服务器的端口。客户就可以通过端口号连接到对应的服务器了。
Linux网络编程
qq_41874746的博客
05-14 802
1 网络基础概念 1.1 协议 概念:协议实现约定好，大家共同遵守的一组规则，协议可以理解为数据传输和数据解释的规则。 1.2 分层模型 OSI 7层模型：物数网传会表应 应用层：主要就是应用程序，ftp ssh email http 表示层：进行编解码和翻译工作 会话层：建立会话和保持会话 传输层：定义了端到端的传输，TCP UDP协议 网络层：定义了点到点的传输，IP协议 --路由器 数据链路层：数据校验，定义了数据格式 --帧，ARP协议 RARP协议 物理层：通信介质-双绞线，光纤，调制解调器m
【Linux学习笔记】Linux网络编程
JLUzhourz的博客
06-06 562
(6)struct sockaddr 这个结构体是linux的网络编程接口中用来表示IP地址的标准结构体，bind、connect等函数中都需要这个结构体，这个结构体是兼容IPV4和IPV6的。(1)socket。(2)struct sockaddr，这个结构体是网络编程接口中用来表示一个IP地址的，注意这个IP地址是不区分IPv4和IPv6的（或者说是兼容IPv4和IPv6的）// 设置地址的端口号信息，将端口号信息转化为网络能接受的模式，统一大小端。
linux系统编程之网络编程
qq_53918454的博客
12-19 1731
函数原型：int socket(int domain, int type, int protocol);参数1：指明所使用的协议，通常为AF_INET，表示互联网协议族（TCP/IP协议族）；（AF_INET—IPv4因特网域、AF_INET6—IPv6因特网域、AF_UNIX—Unix域、AF_ROUTE—路由套接字、AF_KEY—密钥套接字、AF_UNSPEC—未指定）参数2：指定socket的类型；（SOCK_STREAM：流式套接字提供可靠的、面向连接的通信流；
Linux系统编程-网络编程
番茄的博客
03-30 344
前面几篇文章的进程间通讯均基于同一台Linux内核实现的，因此无法实现多机（和手机、单片机、X86架构等）通讯，因此引入网络通讯，入门先学习Socket（又叫做套接字）网络编程。Socket服务器开发步骤1、创建套接字socket();2、为套接字添加信息（IP地址、端口号）bind();3、监听网络连接listen();4、监听到有客户接入，接受一个连接accept();5、数据交互 write()\read();6、关闭套接字，关闭连接close();Socket客户端开发步骤。
linux网络编程 pdf
最新发布
09-29
Linux网络编程是指在Linux操作系统下使用编程语言编写网络应用程序的技术。网络编程通常涉及到socket编程，而Linux操作系统提供了丰富的系统调用和库函数来支持网络编程。 《Linux网络编程》这本PDF书籍是一本介绍...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值