linux下socket编程

1.创建socket

int listenfd;
listenfd = socket(AF_INET, SOCK_STREAM, 0); // 流式套接字
if(listenfd < 0)
{
  perror("socket");
  exit(1);    
}

2.绑定bind

struct sockaddr_in serv_addr, cli_addr;
bzero(&serv_addr, sizeof(serv_addr));  

sin.sin_family = AF_INET;
sin.sin_port = htons(6363); // 端口号
sin.sin_addr.s_addr = htonl(INADDR_ANY); // IP地址

// 设置端口复用
int on = 1;
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on , sizeof(int));

if( bind(listenfd,(struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
{
    perror("bind failed.
");
    exit(1);
}

其中:

解决 bind failed address already in use 问题

bind 普遍遭遇的问题是试图绑定一个已经在使用的端口。该陷阱是也许没有活动的套接字存在，但仍然禁止绑定端口（bind 返回 EADDRINUSE），它由 TCP 套接字状态 TIME_WAIT 引起。该状态在套接字关闭后约保留 2 到 4 分钟。在 TIME_WAIT 状态退出之后，套接字被删除，该地址才能被重新绑定而不出问题。

等待 TIME_WAIT 结束可能是令人恼火的一件事，特别是如果您正在开发一个套接字服务器，就需要停止服务器来做一些改动，然后重启。幸运的是，有方法可以避开 TIME_WAIT 状态。可以给套接字应用 SO_REUSEADDR 套接字选项，以便端口可以马上重用。

在绑定地址之前，我以 SO_REUSEADDR 选项调用 setsockopt。为了允许地址重用，我设置整型参数（on）为 1 （不然，可以设为 0 来禁止地址重用）。

按照IBM的做法，修改代码如下:

int on = 1;
if( (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0))
{
　　perror("setsockopt");
　　return 1;
}

3.监听listen

if(listen(listenfd, n) == -1) // n代表监听的数量
{
    perror("listen failed
");
    exit(1);
}

4.accept

int clientfd;
// struct sockaddr_in cli_addr;
int len = sizeof(struct sockaddr);
clientfd= accept(serverfd, (struct sockaddr*)&cli_addr, &len);
if(clientfd == -1)
{
    perror("accept failed
");
    exit(1);
}
else
    printf("accept succeed
");

5.连接connect

int sockfd;
struct sockaddr_in serv_addr;
host = gethostbyname("127.0.0.1");
sockfd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&serv_addr, sizeof(struct sockaddr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(port); // port端口号
serv_addr.sin_addr = *((struct in_addr *)host->h_addr);

if(connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr)) == -1)
{
    printf("connect failed
");
    exit(1);
}
else
    printf("connect succeed 
");

6.发送数据send // tcp

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

7.接收数据recv // tcp

int recvNum;
char buf[BUF_SIZE]; // define BUF_SIZE 1024
if((recvNum = recv(sockfd, buf, BUF_SIZE, 0)) > 0)
{
    printf("recv: %s
", buf);
}
else if(recvNum == -1)
{
    perror("recv -1");
    exit(1);
}

8.创建线程

1.添加头文件
#include <pthread.h>
2.编译时添加参数
gcc -g xxx.c -o xxx -pthread

3.
pthread_t pid;
int sockfd;
pthread_create(&pid, NULL, (void*)recv_data,(void*)&sockfd);
其中:
void *recv_data(void *fd)
{
  int sockfd = *((int *)fd );
  ...
    while(1)
    {
        recv(...);    
    }
  
}

此外，一些关于socket的操作:

namespace SocketOpt
{
    // 创建 面向连接的稳定数据传输，即TCP协议
    SOCKET CreateTCPSocket()
    {
        return socket(AF_INET, SOCK_STREAM, 0); // SOCK_STREAM： 提供面向连接的稳定数据传输，表明数据象字符流一样通过 socket,即TCP协议。
                                                                                                // SOCK_DGRAM： 使用不连续不可靠的数据包连接，表明数据将是数据报(datagrams)的形式,UDP协议
                                                                                                // PF_INET, AF_INET： Ipv4网络协议
                                                                                                // PF_INET6, AF_INET6： Ipv6网络协议。
    }
    
    // 设置非阻塞, 清除 I/O 阻塞标志
    bool Nonblocking(SOCKET fd)
    {
        UINT32 arg = 1;
        return (::ioctl(fd, FIONBIO, &arg) == 0); // 用 法: int ioctl(int handle, int cmd,[int *argdx, int argcx]); 返回值：成功为0，出错为-1
                                                                                                    // FIONBIO 设置/ 清除非阻塞I/O 标志
    }
    
    // 设置 IO 为阻塞
    bool Blocking(SOCKET fd)
    {
        UINT32 arg = 0;
        return (::ioctl(fd, FIONBIO, &arg) == 0);
    }

        // setsockopt用于设置任意类型、任意状态套接口的选项值
        // 返回值:若无错误发生，setsockopt()返回0。否则的话，返回SOCKET_ERROR错误
        // int setsockopt( SOCKET s, 套接口描述字
                // int level, 指定选项代码的类型.
                // int optname, 选项名称
                // const char* optval, 是一个指向变量的指针 类型：整形，套接口结构，其他结构类型:linger{}, timeval{ }
                // int optlen optval 的大小
                //);    
        // level包括:SOL_SOCKET: 基本套接口; IPPROTO_IP: IPv4套接口; IPPROTO_IPV6: IPv6套接口; IPPROTO_TCP: TCP套接口

    
    // 禁用Nagle缓冲算法
    bool DisableBuffering(SOCKET fd)
    {
        UINT32 arg = 1;
        return (setsockopt(fd, 0x6, 01, (const char*)&arg, sizeof(arg)) == 0); // 0x6代表什么???
                                                                                                                                                             // 0x1代表什么???
    }
    
    // 启用的Nagle算法缓冲
    bool EnablBuffering(SOCKET fd)
    {
        UINT32 arg = 0;
        return (setsockopt(fd, 0x6, 0x1, (const char*)&arg, sizeof(arg)) == 0);
    }
    
    // 设置socket内部 发送缓冲区 大小
    bool SetSendBufferSize(SOCKET fd, UINT32 size)
    {
        return (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const char*)&size, sizeof(size)) == 0); // SO_SNDBUF 发送缓冲区大小
    }
    
    // 设置socket内部 接收缓冲区 大小
    bool SetRecvBufferSize(SOCKET fd, UINT32 size)
    {
        return (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (const char*)&size, sizeof(size)) == 0); // SOL_SOCKET 基本套接口
                                                                                                                                                                                             // SO_RCVBUF 接收缓冲区大小
    }
    
    // 设置 (发送/接收)超时时间
    bool SetTimeOut(SOCKET fd, UINT32 timeout)
    {
        struct timeval to;
        to.tv_sec = timeout; // 传入的参数保存在这个结构体中.
        to.tv_usec = 0;
        if(setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (const char*)&to, (socket_t)sizeof(to)) != 0) // SO_SNDTIMEO 发送超时。 对应参数类型struct timeval
            return false;
        
        return (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&to, (socket_t)sizeof(to)) == 0); // SO_RCVTIMEO 接收超时。 对应参数类型struct timeval    
    }
    
    // 关闭socket
    void CloseSocket(SOCKET fd)
    {
        shutdown(fd, SHUT_RDWR); // int shutdown(int sockfd,int how); 指禁止在一个套接口上进行数据的接收与发送
                                                                  // how ->SHUT_RD(0): 关闭sockfd上的读功能; SHUT_WR(1): 关闭sockfd的写功能; SHUT_RDWR(2): 关闭sockfd的读写功能
        close(fd);
    }
    
    // 设置端口复用
    void ReuseAddr(SOCKET fd)
    {
        UINT32 option = 1;
        setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&option, sizeof(option)); // SO_REUSEADDR 端口复用，用来解决服务器出现意外而导致没有将这个端口释放,导致再次连接连接不上的情况
    }
    
}