网络编程初学者必备：从零开始的详细教程与资源汇总

int socket(int domain, int type, int protocol);
头文件： #include <sys/types.h>   #include <sys/socket.h>
功能：创建套接字
参数：
   domain：协议族
     AF_UNIX, AF_LOCAL  本地通信
     AF_INET            ipv4
     AF_INET6           ipv6
   type：套接字类型
     SOCK_STREAM:流式套接字
     SOCK_DGRAM：数据报套接字
   protocol：协议 - 填0 自动匹配底层 ，根据type
      系统默认自动帮助匹配对应协议
       传输层：IPPROTO_TCP、IPPROTO_UDP、IPPROTO_ICMP
       网络层：htons(ETH_P_IP|ETH_P_ARP|ETH_P_ALL)
返回值：
    成功 文件描述符 0 -> 标准输入  1->标准输出  2->标准出错  3->socket
    失败 -1，更新errno

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
头文件： #include<sys/types.h>  #include<sys/socket.h> 
         #include<netinet/in.h>  #include<netinet/ip.h>
功能：绑定  协议？ ip？ 端口 ？ 让别人识别
参数：
    sockfd：套接字
    addr：用于通信结构体 (提供的是通用结构体，需要根据选择通信方式，填充对应结构体-通信当时socket第一个参数确定,需要强转)
         (结构体之间的强转,不可以直接使用普通数据类型强转,因为结构体字节对齐原则,具体大小不一致,会数据丢失,所以可使用结构体指针,对结构体地址进行强转)   
    addrlen：结构体大小   
返回值：成功 0   失败-1,更新errno
  
 通用结构体：
  struct sockaddr {
     sa_family_t  sa_family;
     char        sa_data[14];
 }
ipv4通信结构体：
struct sockaddr_in {
    sa_family_t    sin_family;  ----协议族
    in_port_t      sin_port;    ----端口
    struct in_addr sin_addr;    ----ip结构体
};
struct in_addr {
    uint32_t       s_addr;     --ip地址
};
本地通信结构体：
 struct sockaddr_un {
     sa_family_t sun_family;      /* AF_UNIX 本地通信 */
     char        sun_path[108];   /* 在本地创建的套接字路径 */
 };

int listen(int sockfd, int backlog);
功能:监听，将主动套接字变为被动套接字
参数：
 sockfd：套接字
 backlog：同一时间可以响应客户端请求链接的最大个数，不能写0.
  不同平台可同时链接的数不同，一般写6-8个
返回值：成功 0   失败-1,更新errno

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
功能：阻塞函数，阻塞等待客户端的连接请求，如果有客户端连接，
             则accept()函数返回，返回一个用于通信的套接字文件;
参数：
   Sockfd ：套接字
   addr： 链接客户端的ip和端口号
      如果不需要关心具体是哪一个客户端，那么可以填NULL;
   addrlen：结构体的大小
     如果不需要关心具体是哪一个客户端，那么可以填NULL;
返回值： 
     成功：文件描述符; //用于通信
     失败：-1，更新errno新errno

ssize_t recv(int sockfd, void *buf, size_t len, int flags);
功能: 接收数据 
参数： 
    sockfd： acceptfd ;
    buf  存放位置
    len  大小
    flags  一般填0，相当于read()函数
    MSG_DONTWAIT  非阻塞
返回值： 
   < 0  失败出错  更新errno
   ==0  表示客户端退出
   >0   成功接收的字节个数

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
          struct sockaddr *src_addr, socklen_t *addrlen);
功能：接收数据
参数：
  sockfd：套接字描述符
  buf:接收缓存区的首地址
  len：接收缓存区的大小
  flags：0  接收数据 并 阻塞
                 MSG_DONTWAIT: 设置非阻塞
  src_addr: 发送端的网络信息结构体的指针(对方的 caddr)
  addrlen：发送端的网络信息结构体的大小的指针(对方的 caddr)
返回值：
  成功接收的字节个数
       接收到的数据为0 : 0
  失败：-1
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  发送消息并阻塞
  src_addr:接收端的网络信息结构体的指针
  addrlen：接收端的网络信息结构体的大小
返回值： 
  成功发送的字节个数
  失败：-1

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/wait.h>
#include <pthread.h>
void *mythread(void *arg)//int acceptfd
{
    //先把void * 强转为 int *， 然后取该指针的值
     int acceptfd =  *((int *)arg); //acceptfd
     char buf[128] = "";
     int recvbyte;
     while(1)
     {
         recvbyte = recv(acceptfd,buf,sizeof(buf),0);
         if(recvbyte < 0)
         {
             perror("recv is err:");
             return NULL;
         }
         else if(recvbyte == 0)
         {
             printf("client is exit\n");
             break;
         }
         else
         {
            printf("%s\n",buf);
         }
     }
     close(acceptfd);
     //线程退出函数
     pthread_exit(NULL)
;}
int main(int argc, char const *argv[])
{
    if(argc != 2)
    {
        printf("please input %s <port>",argv[0]);
        return -1;
    }
    //1.创建流式套接字
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd < 0)
    {
        perror("sockfd is err:");
        return -1;
    }
    //2.填充ipv4结构体
    struct sockaddr_in saddr,caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    int len = sizeof(caddr);
    if(bind(sockfd,(struct sockaddr *)&saddr,sizeof(saddr)) < 0)
    {
        perror("bind is err:");  
        return -1;
    }
    //3.监听
    if(listen(sockfd,5)<0)
    {
        perror("listen is err:");
        return -1;
    }
    while(1)
    {
        int acceptfd = accept(sockfd,(struct sockaddr *)&caddr,&len);
        if(acceptfd < 0)
        {
            perror("accept is err:");
            return -1;
        }
        printf("client: ip %s  port %d\n",\
                            inet_ntoa(caddr.sin_addr),ntohs(caddr.sin_port));
        pthread_t tid;
        pthread_create(&tid,NULL,mythread,&acceptfd);
        //将子线程设置为游离态， 不阻塞等待该线程的退出；
        //一旦该线程退出， 则会自动回收自己的资源
        pthread_detach(tid);
    }
    close(sockfd);
    return 0;
}

·  unix网络编程最开始有的编程都是一台主机内进程和进程之间的编程。(本地通信)
·  socket可以用于本地间进程通信，创建套接字时使用本地协议AF_LOCAL或AF_UNIX
      本地通信不需要ip和端口，无法进行两个主机通信
·  分为流式套接字和数据报套接字    //可以使用流式套接字或者数据包套接字
·  和其他进程间通信相比使用方便、效率更高，常用于前后台进程通信。
·   unix域套接字编程，实现本间进程的通信，依赖的是s类型的文件；
核心流程
#include <sys/socket.h>
#include <sys/un.h>
struct sockaddr_un {
sa_family_t sun_family;               /* 本地协议 AF_UNIX */
char        sun_path[UNIX_PATH_MAX];  /* 本地路径 s类型的套接字文件 */
};
unix socket = socket(AF_UNIX, type, 0); //type可以为流式套接字或数据包套接字
                                        //unix 写为 int 就可以
struct sockaddr_un myaddr;
myaddr.sun_family = AF_UNIX; //填充UNIX域套接字
strcpy(saddr.sun_path,"./myunix"); // 创建套接字的路径
recv代码
#include <stdio.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdlib.h>
#include <stdio.h>
#include <poll.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    //1.创建套接字
    int sockfd = socket(AF_UNIX,SOCK_STREAM,0);
    if(sockfd < 0)
    {
        perror("sock is err:");
        return -1;
    }
    system("rm ./myunix -f");// 两者都是删除地址的，二选一即可
    unlink("./myunix");
    //2. 填充结构体
    struct sockaddr_un saddr;
    saddr.sun_family = AF_UNIX;
    strcpy(saddr.sun_path,"./myunix");
    if(bind(sockfd,(struct sockaddr *)&saddr,sizeof(saddr)) < 0)
    {
        perror("bind is err:");    return -1;
    }
    if(listen(sockfd,5) < 0)
    {
        perror("listen is err:");  return -1;
    }
    int acceptfd = accept(sockfd,NULL,NULL);
    if(acceptfd < 0)
    {
        perror("acceptfd < 0");    return -1;
    }
    char buf[128] = "";
    int recvbyte;
    while(1)
    {
          recvbyte = recv(acceptfd,buf,sizeof(buf),0);
        if(recvbyte < 0)
        {
            perror("recv is err:");   return -1;
        }
        else if(recvbyte == 0)
        {
            printf("exit\n");
            break;
        }
        else
        {
            printf("buf: %s\n",buf);
        }
    }
    close(sockfd);
    close(acceptfd);
    return 0;
}
send代码：
#include <stdio.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdlib.h>
#include <stdio.h>
#include <poll.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    //1.创建套接字
    int sockfd = socket(AF_UNIX,SOCK_STREAM,0);
    if(sockfd < 0)
    {
        perror("sock is err:");
        return -1;
    }
    //2. 填充结构体
    struct sockaddr_un saddr;
    saddr.sun_family = AF_UNIX;
    strcpy(saddr.sun_path,"./myunix");
    if(connect(sockfd,(struct sockaddr *)&saddr,sizeof(saddr)) < 0)
    {
        perror("connect is err:");
        return -1;
    }
    char buf[128] = "";
    int recvbyte;
    while(1)
    {
       fgets(buf,sizeof(buf),stdin);
         if(buf[strlen(buf) -1] == '\n')
            buf[strlen(buf) -1] = '\0';
      send(sockfd,buf,sizeof(buf),0);
    }
    close(sockfd);
    return 0;
}