Linux系统编程 网络编程

TCP/UDP对比
1.TCP面向连接（如打电话要先拨号建立连接）；UDP是无连接的，即发送数据之前，不需要建立连接。
2.TCP提供可靠的服务，也就是说，通过TCP连接传送的数据，无误差，不丢失，不重复，且按序到达；UDP尽最大努力交付，即不保证可靠交付。
3.TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流；UDP是面向报文的，UDP没有拥塞控制，因此网络出现拥塞不会使电源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）。
4.每一条TCP连接只能是点到点的；UDP支持1对1，1对多，多对1和多对多的交互通信。
6.TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道。

端口号作用
一台拥有IP地址的主机可以提供许多服务，比如Web服务、FTP服务、SMTP服务等。

这些服务完全可以通过一个IP地址来实现。那么，主机是怎么区分不同的网络服务呢？显然不能只靠IP地址，因为IP地址与网络服务的关系是一对多的关系。

实际上是通过”IP+端口号“来区分不同的个服务的。

端口提供了一种访问通道。

服务器一般都是通过知名端口号来识别的。例如，对于每个TCP/IP实现来说，FTP服务器的TCP端口号都是21，每个Talnet服务器的端口号都是23，每个TFTP（简单文件传送协议）服务器的UDP端口号都是69。

一、字节序

字节序，即字节在电脑中存放时的序列与输入（输出）时的序列是先到的在前还是后到的在前。
字节序是指多字节数据在计算机内存中存储或者网络传输时各字节的存储顺序。
1． Little endian：将低序字节存储在起始地址
2． Big endian：将高序字节存储在起始地址
LE little-endian
最符合人的思维的字节序，地址低位存储值的低位，地址高位存储值的高位
怎么讲是最符合人的思维的字节序，是因为从人的第一观感来说低位值小，就应该放在内存地址小的地方，也即内存地址低位
反之，高位值就应该放在内存地址大的地方，也即内存地址高位
BE big-endian
最直观的字节序，地址低位存储值的高位，地址高位存储值的低位
为什么说直观，不要考虑对应关系，只需要把内存地址从左到右按照由低到高的顺序写出把值按照通常的高位到低位的顺序写出
两者对照，一个字节一个字节的填充进去
例子：在内存中双字0x01020304(DWORD)的存储方式
内存地址
4000&4001&4002&4003
LE 04 03 02 01
BE 01 02 03 04

二、socket

1.socket()函数

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

调用该函数前，先要加载winsock，wsastartup（）.socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。

如果成功就返回生成的SOCKET，如果失败就返回INVALID_SOCKET(-1).
正如可以给fopen的传入不同参数值，以打开不同的文件。创建socket的时候，也可以指定不同的参数创建不同的socket描述符，socket函数的三个参数分别为：

domain：即协议域，又称为协议族（family）。常用的协议族有，AF_INET、AF_INET6、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。
type：指定socket类型。常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等（socket的类型有哪些？）。
类型 解释 SOCK_STREAM 提供有序的、可靠的、双向的和基于连接的 字节流，使用
带外数据传送机制，为Internet地址族使用TCP。 SOCK_DGRAM 支持无连接的、不可靠的和使用固定大小（通常很小）缓冲区的
数据报服务，为Internet地址族使用UDP。
SOCK_STREAM类型的套接口为全双向的字节流。对于流类套接口，在接收或发送数据前必需处于已连接状态。用
connect()调用建立与另一套接口的连接，连接成功后，即可用
send()和recv()传送数据。当会话结束后，调用closesocket()。 带外数据根据规定用send()和recv()来接收。
原始套接字（SOCK_RAW）：原始套接字与标准套接字（标准套接字指的是前面介绍的流套接字和数据包套接字）的
区别在于：原始套接字可以读写内核没有处理的IP数据包，而流套接字只能读取TCP协议的数据，数据包套接字只能读取UDP协议的数据。因此，如果要访问其他协议发送数据必须使用原始套接字。
实现SOCK_STREAM类型
套接口的通讯协议保证数据不会丢失也不会重复。如果终端协议有缓冲区空间，且数据不能在一定时间成功发送，则认为连接中断，其后续的调用也将以WSAETIMEOUT错误返回。
SOCK_DGRAM类型套接口允许使用 sendto()和recvfrom()从任意端口发送或接收数据报。如果这样一个套接口用
connect()与一个指定端口连接，则可用 send()和recv()与该端口进行数据报的发送与接收。
protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议

2.bind()函数
正如上面所说bind()函数把一个地址族中的特定地址赋给socket。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。

地址转换API

int inet_aton(const char*straddr,struct in_addr*addrp);
把字符串形式的“192.168.1.123”转为网络能识别的格式
char *inrt_ntoa(struct in_addr inaddr);
把网络格式的ip地址转为字符串格式

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

函数的三个参数分别为：
sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。
addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，
如
ipv4对应的是：

端口号要转换为网络字节序

struct sockaddr_in {
    sa_family_t    sin_family; /* address family: AF_INET */
    in_port_t      sin_port;   /* port in network byte order */
    struct in_addr sin_addr;   /* internet address */
};

/* Internet address. */
struct in_addr {
    uint32_t       s_addr;     /* address in network byte order */
};

ipv6对应的是：

struct sockaddr_in6 { 
    sa_family_t     sin6_family;   /* AF_INET6 */ 
    in_port_t       sin6_port;     /* port number */ 
    uint32_t        sin6_flowinfo; /* IPv6 flow information */ 
    struct in6_addr sin6_addr;     /* IPv6 address */ 
    uint32_t        sin6_scope_id; /* Scope ID (new in 2.4) */ 
};

struct in6_addr { 
    unsigned char   s6_addr[16];   /* IPv6 address */ 
};

Unix域对应的是：

#define UNIX_PATH_MAX    108

struct sockaddr_un { 
    sa_family_t sun_family;               /* AF_UNIX */ 
    char        sun_path[UNIX_PATH_MAX];  /* pathname */ 
};

addrlen：对应的是地址的长度。
通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

3.listen()、connect()函数
如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。

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

listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。

connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。

4.accept()函数
TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。

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

accept函数的第一个参数为服务器的socket描述字，第二个参数为指向struct sockaddr *的指针，用于返回客户端的协议地址，第三个参数为协议地址的长度。如果accpet成功，那么其返回值是由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接。

5.read()、write()等函数
万事具备只欠东风，至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写操作了，即实现了网咯中不同进程之间的通信！网络I/O操作有下面几组：

read()/write()
recv()/send()
readv()/writev()
recvmsg()/sendmsg()
recvfrom()/sendto()

我推荐使用recvmsg()/sendmsg()函数，这两个函数是最通用的I/O函数，实际上可以把上面的其它函数都替换成这两个函数。它们的声明如下：

 #include <unistd.h>

       ssize_t read(int fd, void *buf, size_t count);
       ssize_t write(int fd, const void *buf, size_t count);

       #include <sys/types.h>
       #include <sys/socket.h>

       ssize_t send(int sockfd, const void *buf, size_t len, int flags);
       ssize_t recv(int sockfd, void *buf, size_t len, int flags);

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

       ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
       ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

6.close()函数
在服务器与客户端建立连接之后，会进行一些读写操作，完成了读写操作就要关闭相应的socket描述字，好比操作完打开的文件要调用fclose关闭打开的文件。

#include <unistd.h>
int close(int fd);

close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数。

引用：https://blog.csdn.net/qq_26399665/article/details/52421723?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-3.no_search_link&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-3.no_search_link

例子
服务器

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <string.h>
int main(int argc,char **argv)
{
        int c_fd;
        int n_read;
        char readbuf[128];
        char msg[128];
        int mark = 0;
        
        struct sockaddr_in s_addr;
        struct sockaddr_in c_addr;
        
        memset(&s_addr,0,sizeof(struct sockaddr_in));
        memset(&c_addr,0,sizeof(struct sockaddr_in));

        //socket
        int s_fd;
        s_fd = socket(AF_INET,SOCK_STREAM,0);
        if(s_fd == -1)
        {
                perror("socket");
                exit(-1);
        }
        //bind
        s_addr.sin_family = AF_INET;
        s_addr.sin_port = htons(atoi(argv[2]));
        inet_aton(argv[1],&s_addr.sin_addr);
        bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));
        //listen
        listen(s_fd,10);
        //accept
        int c_len = sizeof(struct sockaddr_in);
        while(1)
        {
                c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&c_len);
                if(c_fd == -1)
                {
                        perror("accept");
                }
                mark++;
                printf("connet\n");
                printf("get connect %s\n",inet_ntoa(c_addr.sin_addr));
                if(fork() == 0)
                {

                        if(fork() == 0)
                        {
                                while(1)
                                {
                                        sprintf(msg,"Welcome No %d client",mark);
                                        write(c_fd,msg,strlen(msg));
                                        sleep(3);
                                }
                        }
                        //read
                        while(1)
                        {
                                memset(readbuf,0,sizeof(readbuf));
                                n_read = read(c_fd,readbuf,128);
                                if(n_read == -1)
                                {
                                        perror("read");
                                }else
                                {
                                        printf("get data:%d,%s\n",n_read,readbuf);
                                }
                        }
                }
        }
        return 0;
}

客户端

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <string.h>
int main(int argc,char **argv)
{
        int n_read;
        int c_fd;
        char readbuf[128];
        char msg[128];
        struct sockaddr_in c_addr;

        memset(&c_addr,0,sizeof(struct sockaddr_in));
        //socket
        c_fd = socket(AF_INET,SOCK_STREAM,0);
        if(c_fd == -1)
        {
                perror("socket");
                exit(-1);
        }
        c_addr.sin_family = AF_INET;
        c_addr.sin_port = htons(atoi(argv[2]));
        inet_aton(argv[1],&c_addr.sin_addr);

        //connect
        if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr_in)) == -1)
        {
                perror("connect");
                exit(-1);
        }
        //write
        while(1)
        {
                if(fork() == 0)
                {
                        while(1)
                        {
                                memset(msg,0,sizeof(msg));
                                printf("input :");
                                gets(msg);
                                write(c_fd,msg,strlen(msg));
                        }
                }
                //read
                while(1)
                {
                        memset(readbuf,0,sizeof(readbuf));
                        n_read = read(c_fd,readbuf,128);
                        if(n_read == -1)
                        {
                                perror("read");
                        }else
                        {
                                printf("get message from sever:%d,%s\n",n_read,readbuf);
                        }
                }
        }
        return 0;
}