【计算机网络】2. 网络编程socket1（TCP与UDP的简单特性、网络字节序、UDPsocket、TCPsocket）

已于 2022-03-23 10:29:04 修改
阅读量1.3k 收藏 5
点赞数
分类专栏： 怎样学好网络 文章标签： 网络 udp tcp/ip
于 2022-01-02 15:52:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WL0616/article/details/122217449
版权

目录

1. 网络进程间通信

本地进程可通过进程号（Process ID, PID）唯一标识，网络中如何进行进程间通信呢？
首先要解决的问题是如何唯一标识一个进程，其实网络中TCP/IP已经解决了这个问题。

网络层 IP地址可以唯一标识网络中的主机
传输层 “协议+端口”可以唯一标识主机中的应用程序（进程）
“IP地址+协议+端口”可以标识网络的进程，网络中进程通信即可实现。

网络五组元信息：一条网络数据一定包含5部分信息
（1）源 IP 地址：表示该条信息来自于哪个机器
（2）源端口：表示该条信息来自于哪个进程
（3）目的 IP 地址：表示该条信息去往哪一个机器
（4）目的端口：表示该条信息去往哪一个进程
（5）协议：双方网络数据采用的具体网络协议

2. UDP的简单特性

UDP的简单特性：无连接，不可靠，面向数据报
（1）无连接：UDP客户端给服务端发送消息的时候，不需要和服务端先建立连接，直接发送（客户端也不清楚服务端是否真正在线）
（2）不可靠：UDP并不会保证数据是可靠有序到达对端
（3）面向数据报：UDP数据不管是和应用层还是网络层，都是整条数据交付
在这里插入图片描述

3. TCP的简单特性

TCP的简单特性：面向连接、可靠传输、面向字节流
（1）面向连接：双方在发送网络数据之前必须先建立连接，再进行发送
（2）可靠传输：保证数据是可靠并且有序的到达对端
（3）面向字节流：多次发送的数据在网络传输过程当中没有明显的数据边界。比如先发123，再发456，另一端收到的就是123456，它没有间隔。

4. 字节序

4.1 概念

小端字节序：低位存储在低地址
大端字节序：低位存储在高地址

网络字节序：采用的是大端字节序
主机字节序：根据机器本身的字节序
                     机器是大端：主机字节序为大端
                     机器是小端：主机字节序为小端

  1. 发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出
  2. 接收主机把从网络上接到的字节依次保存在接收缓冲区中,也是按内存地址从低到高的顺序保存
  3. 因此,网络数据流的地址应这样规定:先发出的数据是低地址,后发出的数据是高地址
  4. TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节.
  5. 不管这台主机是大端机还是小端机, 都会按照这个TCP/IP规定的网络字节序来发送/接收数据
  6. 如果当前发送主机是小端, 就需要先将数据转成大端; 否则就忽略, 直接发送即可
    在这里插入图片描述

4.2 主机字节序与网络字节序的转换

头文件：#include<arpa/inet.h>

（1）主机字节序转换为网络字节序

端口：
     unit16_t htons(unit16_t hostshort); 

IP：
     in_addr_t  inet_addr(const char *cp);

将点分十进制的IP字符串转换成为unit32_t的整数，再将unit32_t的整数从主机字节序转换成为网络字节序
addr.sin_addr.s_addr 中的 s_addr 的返回值是一个无符号32位整数

（2）网络字节序转换为主机字节序

端口：
     unit16_t ntohs(unit16_t netshort);

IP：
     char *inet_ntoa(struct in_addr in); //“ntoa"的含义是"network to ascii”

将IP地址从网络字节序转换成为主机字节序，将unit32_t的整数转换成为点分十进制的字符串

inet_ntoa不是线程安全的函数

inet_ntoa()将结构体in_addr作为一个参数，不是长整形。同样需要注意的是它返回的是一个指向一个字符的指针。它是一个由inet_ntoa()控制的静态的固定的指针，所以每次调用 inet_ntoa()，它就将覆盖上次调用时所得的IP地址。例如：

char *a1, *a2;

……

a1 = inet_ntoa(ina1.sin_addr); /* 这是198.92.129.1 */

a2 = inet_ntoa(ina2.sin_addr); /* 这是132.241.5.10 */

printf("address 1: %s\n",a1);

printf("address 2: %s\n",a2);

输出如下：

address 1: 132.241.5.10

address 2: 132.241.5.10

5. UDPsocket

5.1 什么是socket？

socket被称为套接字，用来实现网络进程之间的通信
socket 是在应用层和传输层之间的一个抽象层，socket把TCP/IP层复杂的操作抽象为简单的接口供应用层调用，以实现进程在网络中的通信
socket用于描述IP地址和端口，是一个通信链的句柄，用来实现不同虚拟机或物理机之间的通信。应用程序通过socket向网络发出请求或应答请求。网络中两个进程通过一个双向的通信连接实现数据的交换，建立网络通信连接至少需要一对socket，连接的一端称为一个socket。

5.2 socket常见的API函数

5.2.1 创建套接字

头文件：#include <sys/socket.h>
int socket(int domain, int type, int protocol);
domain：地址域
指定网络层使用什么样的协议
AF_INET：使用ipv4版本的ip协议
AF_INET6：使用ipv6版本的ip协议
AF_UNIX：本地域套接字（适用于一台机器的两个进程，进行进程间通信）
type：创建套接字的类型
UDP：SOCK_DGRAM：用户数据报套接字
TCP：SOCK_STREAM：流式套接字
protocol：表示使用的协议
0：采用套接字类型对应的默认协议
SOCK_DGRAM：默认的协议是UDP
SOCK_STREAM：默认的协议是TCP
宏定义：IPPROTO_UDP：UDP协议
宏定义：IPPROTO_TCP：TCP协议
返回值：返回套接字描述符，本质上就是文件描述符

5.2.2 绑定地址信息

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockfd：套接字描述符，socket函数的返回值
addr：地址信息结构
struct sockaddr：通用的结构体类型，具体采用的是各个协议自己的数据结构
返回值：返回套接字描述符，本质上就是文件描述符

在使用bind函数之前，需要创建协议所需要的地址信息结构体
struct sockaddr_in addr; //ipv4所用的结构体是struct sockaddr_in 
addr.sin_family = AF_INET; //地址域信息
addr.sin_port = htons(20001); //端口
addr.sin_addr.s_addr = inet_addr("0.0.0.0");  //ip地址

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5.2.3 UDP发送数据

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
sockfd：套接字描述符
buf：待要发送的数据
len：发送数据的长度
flags：0：表示阻塞接受
dest_addr：当前消息的目标地址信息结构（消息要发送到哪里去）
addr_len：地址信息结构长度
返回值：成功：返回发送的字节数
失败：-1

5.2.4 UDP接受数据

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
sockfd：套接字描述符
buf：将接受的数据存放到buf中
len：最大接受能力
flags：0：表示阻塞接受
src_addr：表示数据从哪一个地址信息结构发来的（消息从哪一个ip和端口来的）
addr_len：地址信息结构长度
返回值：成功：返回接收的字节数
失败：-1

5.3 UDPsocket编程流程

在这里插入图片描述
客户端不需要绑定地址信息（ip地址+端口），让操作系统（即sendto函数）自己去绑定，因为自己绑定客户地址信息会导致当前客户端程只能在一台机器中运行一个进程，不能多开

5.4 UDPsocket编程

5.4.1 服务端

#include <stdio.h>
#include <unistd.h>
#include <string.h>

//socket编程需要包含的头文件
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main()
{
    int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);//创建套接字
    if(sockfd < 0)
    {
    	//判断
        perror("socket");
        return 0;
    }

    printf("socket : %d\n", sockfd);//socket的返回值是int类型，用%d输出

	//ipv4使用的结构体
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;//地址域信息，这里采用ipv4的ip协议
    addr.sin_port = htons(28989);//端口
    addr.sin_addr.s_addr = inet_addr("172.21.0.9");//私网ip地址，私网ip地址才是描述这台机器的，发送消息需要公网ip
    //sin_addr 和 sin_port 分别封装在包的 IP 和 UDP 层。因此，它们必须要是网络字节顺序

    int ret = bind(sockfd, (struct sockaddr*)&addr, sizeof(addr));//绑定地址信息
    if(ret < 0)
    {
        perror("bind");
        return 0;
    }
    
    while(1)
    {
        char buf[1024] = {0};
        struct sockaddr_in peer_addr;
        socklen_t len = sizeof(peer_addr);
        ssize_t recv_size = recvfrom(sockfd, buf, sizeof(buf) - 1, 0, (struct sockaddr*)&peer_addr, &len);
        if(recv_size < 0)
        {
            continue;
        }

        printf("recv msg \"%s\" from %s:%d\n", buf, inet_ntoa(peer_addr.sin_addr), ntohs(peer_addr.sin_port));

        memset(buf, '\0', sizeof(buf));//内存初始化
        sprintf(buf, "welcome client %s:%d", inet_ntoa(peer_addr.sin_addr), ntohs(peer_addr.sin_port));
        sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr*)&peer_addr, sizeof(peer_addr));
    }

    close(sockfd);
    return 0;
}

5.4.2 客户端

#include <stdio.h>
#include <unistd.h>
#include <string.h>

//socket编程需要包含的头文件
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main()
{
    int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if(sockfd < 0)
    {
        perror("socket");
        return 0;
    }

    printf("socket : %d\n", sockfd);

    while(1)
    {
        char buf[1024] = "i am client";

        struct sockaddr_in dest_addr;
        dest_addr.sin_family = AF_INET;
        dest_addr.sin_port = htons(28989);
        dest_addr.sin_addr.s_addr = inet_addr("82.157.94.99");//发送消息需要公网ip

        sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr*)&dest_addr, sizeof(dest_addr));

        memset(buf, '\0', sizeof(buf));

        struct sockaddr_in peer_addr;
        socklen_t len = sizeof(peer_addr);
        ssize_t recv_size = recvfrom(sockfd, buf, sizeof(buf) - 1, 0, (struct sockaddr*)&peer_addr, &len);
        if(recv_size < 0)
        {
            continue;
        }

        printf("recv msg %s from %s:%d\n", buf, inet_ntoa(peer_addr.sin_addr), ntohs(peer_addr.sin_port));
        sleep(1);
    }

    close(sockfd);
    return 0;
}

在这里插入图片描述
UDP无需建立连接，只能客户端给服务端发送消息（因为服务端不知道客户端的ip地址信息的）
需要先启动服务端，客户端才能发消息
在这里插入图片描述
在这里插入图片描述

6. TCPsocket

6.1 TCPsocket编程流程

在这里插入图片描述

6.2 TCP发送接收缓冲区

在这里插入图片描述

6.3 编程接口

6.3.1 socket：创建套接字

头文件：#include <sys/socket.h>
int socket(int domain, int type, int protocol);

domain：地址域，指定网络层使用什么样的协议
               AF_INET：使用ipv4版本的ip协议
               AF_INET6：使用ipv6版本的ip协议
               AF_UNIX：本地域套接字（适用于一台机器的两个进程，进行进程间通信）

type：创建套接字的类型
          UDP：SOCK_DGRAM：用户数据报套接字
          TCP：SOCK_STREAM：流式套接字

protocol：表示使用的协议
                0：采用套接字类型对应的默认协议
                      SOCK_DGRAM：默认的协议是UDP
                      SOCK_STREAM：默认的协议是TCP
                宏定义：IPPROTO_UDP：UDP协议
                宏定义：IPPROTO_TCP：TCP协议

返回值：返回套接字描述符，本质上就是文件描述符

6.3.2 bind：绑定地址信息

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockfd：套接字描述符，socket函数的返回值
addr：地址信息结构
struct sockaddr：通用的结构体类型，具体采用的是各个协议自己的数据结构
返回值：成功则返回0 ，失败返回-1，错误原因存于 errno 中

在使用bind函数之前，需要创建协议所需要的地址信息结构体
struct sockaddr_in addr; //ipv4所用的结构体是struct sockaddr_in 
addr.sin_family = AF_INET; //地址域信息
addr.sin_port = htons(20001); //端口
addr.sin_addr.s_addr = inet_addr("0.0.0.0");  //ip地址

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

6.3.3 listen：监听接口

int listen(int sockfd, int backlog);
sockfd：侦听套接字，socket函数的返回值
backlog：指定内核当中已完成连接队列的大小
返回值：成功则返回0 ，失败返回-1

在这里插入图片描述
结论：已完成连接队列的大小决定了服务端的并发连接数（指的是在同一时刻服务端能够处理的连接数量上限，并不是服务端能够接收连接的上限）
引申的问题：TCP服务端最大接收多少连接？
取决于操作系统对进程当中打开文件描述符的限制
可以用命令：ulimit -a进行查看和修改
在这里插入图片描述
core file size core文件的最大值为 0 blocks，
data seg size 进程的数据段可以任意大
file size 文件可以任意大
pending signals 最多有 7269 个待处理的信号
max locked memory 一个任务锁住的物理内存的最大值为64kB
max memory size 一个任务的常驻物理内存的最大值
open files 一个任务最多可以同时打开100001个文件
pipe size 管道的最大空间为4096字节(512×8)
POSIX message queues POSIX的消息队列的最大值为819200字节
stack size 进程的栈的最大值为8192字节
cpu time 进程使用的CPU时间
max user processes 当前用户同时打开的进程(包括线程)的最大个数为7269
virtual memory 没有限制进程的最大地址空间
file locks 所能锁住的文件的最大个数没有限制

6.3.4 connect：客户端的连接接口

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockfd：套接字描述符
adr：要连接的服务端的地址信息结构
         服务端的ip地址
         服务端的端口
addrlen：地址信息结构长度
返回值：0：成功
              -1：失败

6.3.5 accept：服务端接收连接

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

sockfd：侦听套接字（socket函数的返回值）

addr：客户端的地址信息结构（出参：由accept函数返回客户端的地址信息结构）

addrlen：客户端的地址信息结构长度（出参：由accept函数返回客户端的地址信息结构长度）

返回值：返回新连接的套接字描述符
               >= 0：成功
               < 0：失败

6.3.6 send：TCP发送数据接口

ssize_t send (int sockfd, const void *buf, size_t len, int flags);
sockfd：套接字描述符
              客户端：socket函数的返回值
              服务端：accept函数的返回值（切记不是侦听套接字）
buf：待要发送的数据
len：数据长度
flages：标志位
0：阻塞发送
MAG_PEEK：发送紧急数据（带外数据）
返回值：-1：发送失败
              > 0：实际发送的字节数量

6.3.7 recv：TCP接收数据

ssize_t recv (int sockfd, void *buf, size_t len, int flags);
sockfd：套接字描述符
              客户端：socket函数的返回值
              服务端：accept函数的返回值（切记不是侦听套接字）
buf：将从TCP接收缓冲区当中接收的数据保存在buf当中
len：buf最大的接受能力
flags：0：阻塞接受
返回值：< 0：函数调用出错了
              == 0：对端关闭连接
              > 0：接收到的字节数量

6.3.8 closed：关闭连接

closed(int sockfd);

6.4 单线程TCPsocket编程

6.4.1 服务端

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

int main()
{
    int listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(listen_sock < 0)
    {
        perror("socket");
        return 0;

    }

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(28989);
    //0.0.0.0 : 本地所有的网卡地址
    addr.sin_addr.s_addr = inet_addr("0.0.0.0");

    int ret = bind(listen_sock, (struct sockaddr*)&addr, sizeof(addr));
    if(ret < 0)
    {
        perror("bind");
        return 0;
    }

    ret = listen(listen_sock, 1);
    if(ret < 0)
    {
        perror("listen");
        return 0;
    }
    struct sockaddr_in cli_addr;
    socklen_t cli_addrlen = sizeof(cli_addr);
    int newsockfd = accept(listen_sock, (struct sockaddr*)&cli_addr, &cli_addrlen);
    if(newsockfd < 0)
    {
        perror("accept");
        return 0;
    }

    printf("accept new connect from client %s:%d\n", inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
    while(1)
    {


        //接收
        char buf[1024] = {0};
        ssize_t recv_size = recv(newsockfd, buf, sizeof(buf) - 1, 0);
        if(recv_size < 0)
        {
            perror("recv");
            continue;
        }
        else if(recv_size == 0)
        {
            printf("peer close connect\n");
            close(newsockfd);
            continue;
        }

        printf("%s\n", buf);

        memset(buf, '\0', sizeof(buf));
        strcpy(buf, "i am server!!!");
        send(newsockfd, buf, strlen(buf), 0);
    }

    close(listen_sock);
    return 0;
}

6.4.2 客户端

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

int main()
{
    int sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(sockfd < 0)
    {
        perror("socket");
        return 0;

    }

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(28989);
    // 0.0.0.0 : 本地所有的网卡地址
    addr.sin_addr.s_addr = inet_addr("82.157.94.99");//必须使用公网ip

    int ret = connect(sockfd, (struct sockaddr*)&addr, sizeof(addr));
    if(ret < 0)
    {
        perror("connect");
        return 0;
    }


    while(1)
    {

        char buf[1024] = "i am client1111222";

        send(sockfd, buf, strlen(buf), 0);

        memset(buf, '\0', sizeof(buf));
        //接收
        ssize_t recv_size = recv(sockfd, buf, sizeof(buf) - 1, 0);
        if(recv_size < 0)
        {
            perror("recv");
            continue;
        }
        else if(recv_size == 0)
        {
            printf("peer close connect\n");
            close(sockfd);
            continue;
        }

        printf("%s\n", buf);

        sleep(1);
    }

    close(sockfd);
    return 0;
}

若出现连接被拒绝的错误，客户端需要更改自己的公网ip

6.4.3 单线程代码存在的问题

在这里插入图片描述
第一种情况：将accept放在while循环的外面，则整个tcp的服务端只能接受一个客户端的新连接（并不代表只能有一个客户端与服务端建立tcp连接）

第二种情况：将accept放在while循环的里面，则整个tcp的服务端可以接受多个客户端的新连接，但是每一个连接只能收发一次（每次循环的时候，都是去接受新的客户端连接了）

7. 公网ip与私网ip

在这里插入图片描述
（1）在socket编程当中，绑定的是本地网的ip地址（不需要关心的是公网ip还是私网ip）
（2）在互联网连接云服务器的时候，需要使用公网ip（云服务器厂商会帮助进行转换的）

半醒半醉日复日，花落花开年复年
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TCP UDP.zip
06-14
就是一款基本的通讯
Python29 Socket1
weixin_34067049的博客
12-15 128
socket 基本信息 socket 封装了TCP/IP、UDP、FTP、SSH、DHCP等多个协议。 由于socket封装了TCP/IP所以在建立连接的时候，不需要手动去写三次握手/四次握手等代码。 socket IP地址 socket.AF_INET　表示IPV4　 socket.AF_INET6 表示IPV6 socket 类型 socket.SOCK_STREAM # tcp协...
socket1
weixin_34138521的博客
09-27 74
<?php//@time 9/27 /* 要写网路程序就必须使用Socket,这是程序员都知道的.而且面试的时候,我们也会问对方会不会Socket编程??? 一般来说,很多人都会说,Socket编程基本上就是Listen,accept,send以及write等几个基本的操作. 对于网络编程,我们必言TCP/IP协议.似乎其他的网络协议都不存在了.对于TCP/IP,我们还知道TCP和UDP,...
socket(1)
qq_53558968的博客
11-06 263
目录理解源IP地址和目的IP地址套接字本质上就是进程间通信。 认识IP地址，端口号，网络字节序等网络编程中的基本概念。 学习socket、api的基本用法。 能够实现一个简单的udp客户端/服务器。 能够实现一个简单的tcp客户端/服务器(单连接版本，多进程版本，多线程版本。) 理解tcp服务器建立连接，发送数据，断开连接的流程。 接口都是系统调用接口，程序都是用户级程序。自定义协议，所有接口都是传输层接口。 应用层接口，使用传输层接口。 理解源IP地址和目的IP地址 在IP数
TCP UDP
article的专栏
04-23 466
TCP（Transmission Control Protocol，传输控制协议）是基于连接的协议，也就是说，在正式收发数据前，必须和对方建立可靠的连接。一个TCP连接必须要经过三次“对话”才能建立起来，其中的过程非常复杂，我们这里只做简单、形象的介绍，你只要做到能够理解这个过程即可。我们来看看这三次对话的简单过程：主机A向主机B发出连接请求数据包：“我想给你发数据，可以吗？”，这是第一次对话；主...
如何基于C语言socket编程实现TCP通信
01-01
TCP/IP协议...套接字（socket）：在网络中用来描述计算机中不同程序与其他计算机程序的通信方式。socket其实是一种特殊的IO借口，也是一种文件描述符。 套接字分为三类： 流式socket（SOCK_STREAM）：流式
基于Socket的UDP和TCP编程介绍
01-19
　TCP：传输控制协议，一种面向连接的协议，给用户进程提供可靠的全双工的字节流，TCP套接口是字节流套接口(STream socket)的一种。 　UDP：用户数据报协议。UDP是一种无连接协议。UDP套接口是数据报套接口...
TCP/UDP Socket调试工具
06-12
★ 全面集成 TCP服务器/客户端; UDP服务器/客户端; UDP广播/组播 功能 ★ 支持多Socket并行测试, 采用树状Socket可视化界面,所有Socket句柄一目了然 ★ 在一个程序内可进行多句柄/多类型的Socket的创建/删除/以及...
EDA/PLD中的基于Socket的UDP和TCP编程介绍
11-09
　TCP（传输控制协议）和UDP（用户数据报协议是网络体系结构TCP/IP模型中传输层一层中的两个不同的通信协议。 　TCP：传输控制协议，一种面向连接的协议，给用户进程提供可靠的全双工的字节流，TCP套接口是字节流套...
UE4 Simple UDP TCP Socket Server
03-10
通过UDP和TCP发送和接收字节或文本（UTF-8*） 在自己的线程中异步运行（不影响游戏性能） 独立于蓝图 多台服务器同时可用 IPv4和IPv6 AES加密和解密 通过TCP发送和接收文件（无RAM消耗） RCON协议 不同的目录和文件...
UDP socket（一）
sooolo的专栏
09-17 1270
1、设计UDP server类         人们通常用电话连线来说明TCP协议，而UDP协议，则常常用邮递来做比喻。与TCP有连接的信息传输方式不同，UDP协议被认为是对底层IP协议简单的扩展：协议并不保证每个数据包都会到达目的地，也不保证到达的顺序，而仅仅就是“尽力”的发送每一个数据包。我在这篇教程中有时候使用“数据包” 有时候使用“数据报”，广义的说，这两个词意思类似，有代表一个有大
网络编程socket1
06-01 143
TCP/IP协议 IP协议负责把数据从一台计算机通过网络发送到另一台计算机。数据被分割成一小块一小块，然后通过IP包发送出去。由于互联网链路复杂，两台计算机之间经常有多条线路，因此，路由器就负责决定如何把一个IP包转发出去。IP包的特点是按块发送，途径多个路由，但不保证能到达，也不保证...
1.什么是 socket？
良之才的专栏
09-24 264
socket 的原意是“插座”，在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。 UNIX/Linux中的 socket 是什么？ 在 UNIX/Linux 系统中，为了统一对各种硬件的操作，简化接口，不同的硬件设备也都被看成一个文件。对这些文件...
Windows Socket1.1 程序设计
深之JohnChen的专栏
12-11 1815
一、简介　　Windows Sockets 是从 Berkeley Sockets 扩展而来的，其在继承 Berkeley Sockets 的基础上，又进行了新的扩充。这些扩充主要是提供了一些异步函数，并增加了符合WINDOWS消息驱动特性的网络事件异步选择机制。　　Windows Sockets由两部分组成：开发组件和运行组件。　　开发组件：Windows Sockets 实现文档、应用程序接口
TCP和UDP各有什么特点，两者有什么区别？
Mark66890620
03-23 305
TCP是面向连接的，使用TCP连接需要经过三次握手，断开连接需要经过四次挥手。相比于TCP，UDP则是面向无连接的，它像一个随时可以进行通信的协议，只要接收方创建了Socket，设置了监听端口，就能接收到到达的UDP包，并且能随时建立Socket进行发包。 TCP可以对数据的发送速率作控制，它具有流量控制和拥塞控制机制，通过控制滑动窗口的大小控制数据的发送速率。而UDP理论上是可以无限地向网络中发数据包的，它的发送速率取决它的应用程序设置。 TCP保证可靠的数据传输，它根据速率控制，重传控制，还有数据校
20、TCP与UDP的概念，相互的区别及优劣
谢语天
04-27 3382
1、TCP（Transmission Control Protocol）的概念      TCP是一种面向连接的，提供可靠交付服务和全双工通信的，基于字节流的端到端的传输层通信协议。 TCP在传输数据之前必须先建立连接，数据传输结束后要释放连接。每一条TCP连接只能有2个端点，故TCP不提供广播或多播服务。TCP提供可靠交付，通过TCP连接传输的数据，无差错、不丢失、不重复、并且按序到
TCP/UDP
weixin_zz的博客
03-06 126
IOS七层模型：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层。tcp/ip协议五层模型：应用层       传输层        网络层      数据链路层       物理层。TCP是一种面向连接的、可靠的、基于字节流的传输层（Transport layer）通信协议。是专门为了在不可靠的互联网络上提供一个可靠的端到端字节流而设计的。每一次TCP连接都需要三个阶段：连接建立、数据...
TCP、UDP
爱上在路上
07-07 1100
1、TCP协议 1、1 TCP的工作过程     首先TCP是一种面向连接的，可靠的，基于字节流的传输层通信协议。TCP的工作过程可以分为三个阶段：一、连接的建立；  二、传输数据； 三、断开连接 1、1、1 连接的建立     TCP的连接建立就像打电话一样，我们打电话时，拨一个号码并不是立即就可以接通的，期间会有一个“嘟 嘟”的呼叫过程， 这就好比是TCP协议的连接的建立阶段。当我
socket是一个编程接口
qq_37464479的博客
12-30 385
它可以用于实现网络编程，它提供了一种简单的方法来编写网络应用程序，如Web服务器、FTP服务器、电子邮件服务器等。在C语言中，可以使用套接字库函数来创建套接字，并使用它来发送和接收数据。Socket通常由客户端和服务器构成，客户端发出请求，服务器接收请求并处理它，然后将结果返回给客户端。listen()：监听套接字，等待客户端连接。connect()：连接到服务器的套接字。bind()：将套接字与一个端口号绑定。socket()：创建一个套接字。close()：关闭套接字。recv()：接收数据。
基于java socket tcp和udp实现一个简易的网络文件服务程序,包含服务器端fileserve
最新发布
10-14
基于Java Socket TCP和UDP实现一个简易的网络文件服务程序，包含服务器端fileserve，可以按照以下步骤进行： 1. 首先，创建一个服务器端程序fileserve，使用TCP Socket连接。创建一个ServerSocket对象，并绑定指定...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值