通过socket获取图片并保存

网络操作的相关API

gethostbyname/gethostbyaddr/getservbyname

struct hostent *gethostbyname(const char *name);

传入值是域名或者主机名；传出值是一个hostent结构。如果调用失败，将返回NULL。

struct hostent
    {
        char    *h_name;     主机规范名
        char    **h_aliases; 主机别名
        int     h_addrtype;    主机IP地址类型，IPV4？IPV6？
        int     h_length;        主机IP地址长度
        char    **h_addr_list;  主机的IP地址，打印需要借助于inet_ntoa/inet_ntop
        #define h_addr h_addr_list[0]
    };

struct hostent *gethostbyaddr(const char *addr, int length, int type);

addr是一个指向存放IPv4地址的某个in_addr结构的指针，len参数是这个结构体的大小，IPv4为4，type参数为AF_INET。返回一个指向hostent结构指针。
struct servent *getservbyname(const char *name, const char *proto);

可以返回给定服务名和协议名的相关服务信息。

struct servent {
    char   *s_name;       /*official service name */
    char  **s_aliases;    /*other aliases */
    int     s_port;       /*port for this service */
    char  **s_proto;      /* protocol to use */
    };

使用gethostbyname的一个实例：

#include <netdb.h>
#include <sys/socket.h>
#include <stdio.h>

int main(int argc, char **argv)
{
    char   *ptr, **pptr;
    struct hostent *hptr;
    char   str[32];
    ptr = argv[1];

if((hptr = gethostbyname(ptr)) == NULL)
    {
        printf(" gethostbyname error for host:%s\n", ptr);
        return 0;
    }

printf("official hostname:%s\n",hptr->h_name);
    for(pptr = hptr->h_aliases; *pptr != NULL; pptr++)
        printf(" alias:%s\n",*pptr);

switch(hptr->h_addrtype)
    {
        case AF_INET:
        case AF_INET6:
            pptr=hptr->h_addr_list;
            for(; *pptr!=NULL; pptr++)
                printf(" address:%s\n",
                       inet_ntop(hptr->h_addrtype, *pptr, str, sizeof(str)));
            printf(" first address: %s\n",
                       inet_ntop(hptr->h_addrtype, hptr->h_addr, str, sizeof(str)));
        break;
        default:
            printf("unknown address type\n");
        break;
    }

return 0;
}

socket/bind/listen/connect/accept

socket

#include <sys/types.h> /* See NOTES */

#include <sys/socket.h>

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

参数说明

• domain:
  AF_INET 这是大多数用来产生socket的协议，使用TCP或UDP来传输，用IPv4的地址
  AF_INET6 与上面类似，不过是来用IPv6的地址
  AF_UNIX 本地协议，使用在Unix和Linux系统上，一般都是当客户端和服务器在同一台及其上的时候使用

• type:
  SOCK_STREAM 这个协议是按照顺序的、可靠的、数据完整的基于字节流的连接。这是一个使用最多的socket类型，这个socket是使用TCP来进行传输。
  SOCK_DGRAM 这个协议是无连接的、固定长度的传输调用。该协议是不可靠的，使用UDP来进行它的连接。
  SOCK_SEQPACKET 这个协议是双线路的、可靠的连接，发送固定长度的数据包进行传输。必须把这个包完整的接受才能进行读取。
  SOCK_RAW 这个socket类型提供单一的网络访问，这个socket类型使用ICMP公共协议。（ping、traceroute使用该协议）
  SOCK_RDM 这个类型是很少使用的，在大部分的操作系统上没有实现，它是提供给数据链路层使用，不保证数据包的顺序

• protocol:
  0 默认协议

函数返回值：
成功返回一个新的文件描述符，失败返回-1，设置errno

socket()打开一个网络通讯端口，如果成功的话，就像open()一样返回一个文件描
述符，应用程序可以像读写文件一样用read/write在网络上收发数据，如果socket()调用出错则返回-1。
对于IPv4，domain参数指定为AF_INET。
对于TCP协议，type参数指定为SOCK_STREAM，表示面向流的传输协议。
如果是UDP协议，则type参数指定为SOCK_DGRAM，表示面向数据报的传输协议。
protocol参数的介绍略，指定为0即可。

bind

#include <sys/types.h> /* See NOTES */

#include <sys/socket.h>

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

bind函数中的sockfd参数为调用socket函数后返回的文件描述符。my_addr参数为指向sockaddr结构体的指针（该结构体中保存有端口和IP地址信息）。addlen参数为结构体sockaddr的长度.

错误信息：
EACCES：地址受到保护，用户非超级用户。
EADDRINUSE：指定的地址已经在使用。
EBADF：sockfd参数为非法的文件描述符。
EINVAL：socket已经和地址绑定。
ENOTSOCK：参数sockfd为文件描述符。

bind函数用于将套接字与指定端口相连.本函数适用于未连接的数据报或流类套接口，在connect()或listen()调用前使用。当用socket()创建套接口后，它便存在于一个名字空间（地址族）中，但并未赋名。bind()函数通过给一个未命名套接口分配一个本地名字来为套接口建立本地捆绑（主机地址/端口号）。

参数说明：

• sockfd：
  socket文件描述符

• addr:
  构造出IP地址加端口号
• addrlen:
  sizeof(addr)长度

函数返回值：
成功返回0，失败返回-1, 设置errno

服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序
的地址和端口号后就可以向服务器发起连接，因此服务器需要调用bind绑定一个固定的网络地址和端口号。

bind()的作用是将参数sockfd和addr绑定在一起，使sockfd这个用于网络通讯的文件描述符监听addr所描述的地址和端口号。前面讲过，struct sockaddr *是一个通用指针类型，addr参数实际上可以接受多种协议的sockaddr结构体，而它们的长度各不相同，所以需要第三个参数addrlen指定结构体的长度。
如：

struct sockaddr_in servaddr;
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(8000);

首先将整个结构体清零，然后设置地址类型为AF_INET，网络地址为INADDR_ANY，这个宏表示本地的任意IP地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个IP地址，这样设置可以在所有的IP地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个IP地址，端口号为8000。

listen

#include <sys/types.h> /* See NOTES */

#include <sys/socket.h>

int listen(int sockfd, int backlog);返回：0──成功， -1──失败

listen函数在一般在调用bind之后-调用accept之前调用。

用户在调用socket函数之后，返回一个套接字sockfd. sockfd默认一个主动连接的套接字，也就是此时系统假设用户会对这个套接字调用connect函数，期待它主动与其它进程连接，然后在服务器编程中，用户希望这个套接字可以接受外来的连接请求，也就是被动等待用户来连接。由于系统默认时认为一个套接字是主动连接的，所以需要通过某种方式来告诉系统，用户进程通过系统调用listen来完成这件事。
listen函数可使得流套接字sockfd处于监听状态，使得一个进程可以接受其它进程的请求，从而成为一个服务器进程。在TCP服务器编程中listen函数把进程变为一个服务器，并指定相应的套接字变为被动连接。

处于监听状态的套接字sockfd将维护一个客户连接请求队列，该队列最多容纳backlog个用户请求。

参数说明：

• sockfd:
  socket文件描述符

• backlog:
  排队建立3次握手队列和刚刚建立3次握手队列的链接数和

查看系统默认backlog

cat /proc/sys/net/ipv4/tcp_max_syn_backlog
1
1

典型的服务器程序可以同时服务于多个客户端，当有客户端发起连接时，服务器调用的accept()返回并接受这个连接，如果有大量的客户端发起连接而服务器来不及处理，尚未accept的客户端就处于连接等待状态，listen()声明sockfd处于监听状态，并且最多允许有backlog个客户端处于连接待状态，如果接收到更多的连接请求就忽略。

返回值
listen()成功返回0，失败返回-1。

connect

#include <sys/types.h> /* See NOTES */

#include <sys/socket.h>

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

参数说明

• sockdf:
  socket文件描述符

• addr:
  传入参数，指定服务器端地址信息，含IP地址和端口号
• addrlen:
  传入参数,传入sizeof(addr)大小

函数返回值：
成功返回0，失败返回-1，设置errno

客户端需要调用connect()连接服务器，connect和bind的参数形式一致，区别在于
bind的参数是自己的地址，而connect的参数是对方的地址。

accept

#include <sys/types.h> /* See NOTES */

#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);返回：非负描述字——成功， -1——失败

accept默认会阻塞进程，直到有一个客户连接建立后返回，它返回的是一个新可用的套接字，这个套接字是连接套接字。此时我们需要区分两种套接字，一种套接字正如accept的参数sockfd，它是监听套接字，在调用listen函数之后，一个套接字会从主动连接的套接字变身为一个监听套接字；而accept返回是一个连接套接字，它代表着一个网络已经存在的点点连接。自然要问的是：为什么要有两种套接字？原因很简单，如果使用一个描述字的话，那么它的功能太多，使得使用很不直观，同时在内核确实产生了一个这样的新的描述字。
     参数sockfd就是上面解释中的监听套接字，这个套接字用来监听一个端口，当有一个客户与服务器连接时，它使用这个一个端口号，而此时这个端口号正与这个套接字关联。当然客户不知道套接字这些细节，它只知道一个地址和一个端口号。
    参数addr 是一个结果参数，它用来接受一个返回值，这返回值指定客户端的地址，当然这个地址是通过某个地址结构来描述的，用户应该知道这一个什么样的地址结构。如果对客户的地址不感兴趣，那么可以把这个值设置为NULL。
     参数len 也是结果的参数，用来接受上述addr的结构的大小的，它指明addr结构所占有的字节个数。同样的，它也可以被设置为NULL。

如果accept成功返回，则服务器与客户已经正确建立连接了，此时服务器通过accept返回的套接字来完成与客户的通信。

可以用下面的例子来作个总结：

你可以想象发生 这样的事情：有人从很远的地方通过一个你在侦听 (listen()) 的端口连接 (connect()) 到你的机器。它的连接将加入到等待接受 (accept()) 的队列 中。

你调用 accept() 告诉它你有空闲的连接。它将返回一个新的套接字文 件描述符！这样你就有两个套接字了，原来的一个还在侦听你的那个端口， 新的在准备发送 (send()) 和接收 ( recv()) 数据。这就是这个过程！ 

服务器编程中最重要的一步是等待并接受客户的连接，那么这一步在编程中如何完成，accept函数就是完成这一步的。它从内核中取出已经建立的客户连接，然后把这个已经建立的连接返回给用户程序，此时用户程序就可以与自己的客户进行点到点的通信了。

参数说明

• sockdf:
  socket文件描述符

• addr:
  传出参数，返回链接客户端地址信息，含IP地址和端口号
• addrlen:
  传入传出参数（值-结果）,传入sizeof(addr)大小，函数返回时返回真正接收到地址结构体的大小

函数返回值：
成功返回一个新的socket文件描述符，用于和客户端通信，失败返回-1，设置errno

三方握手完成后，服务器调用accept()接受连接，如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来。
addr是一个传出参数，accept()返回时传出客户端的地址和端口号。
addrlen参数是一个传入传出参数（value-result argument），传入的是调用者提供的缓冲区addr的长度以避免缓冲区溢出问题，传出的是客户端地址结构体的实际长度（有可能没有占满调用者提供的缓冲区）。
如果给addr参数传NULL，表示不关心客户端的地址。

我们的服务器程序结构是这样的：

while (1)
{
    cliaddr_len = sizeof(cliaddr);
    connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
    n = read(connfd, buf, MAXLINE);
    ......
    close(connfd);
}

整个是一个while死循环，每次循环处理一个客户端连接。
由于cliaddr_len是传入传出
参数，每次调用accept()之前应该重新赋初值。
accept()的参数listenfd是先前的监听文件描述符，而accept()的返回值是另外一个文件描述符connfd，之后与客户端之间就通过这个connfd通讯，最后关闭connfd断开连接，而不关闭listenfd，再次回到循环开头listenfd仍然用作accept的参数。
accept()成功返回一个文件描述符，出错返回-1。

参考文档：《socket编程 -- socket、bind、accept、connect函数》

read/recv/write/send

Ssize_t read(int fd, void *buf, size_t nbyte)

Write函数将buf中的nbytes字节内容写入到文件描述符中，成功返回写的字节数，失败返回-1.并设置errno变量。

Ssize_t write(int fd, const void *buf, size_t nbytes);

Read函数是负责从fd中读取内容，当读取成功时，read返回实际读取到的字节数，如果返回值是0，表示已经读取到文件的结束了，小于0表示是读取错误。

如果错误是EINTR表示在写的时候出现了中断错误，如果是EPIPE表示网络连接出现了问题。

recv/send提供了和read/write一样的的功能，不同的是他们提供了第四个参数。

int recv(int sockfd,void *buf, int len, int flags)

int send(int sockfd,void *buf, int len, int flags)

第四个参数可以是0(如果为0则和read/write是同样的功能)或者是以下组合：

MSG_DONTROUTE：不查找表

是send函数使用的标志，这个标志告诉IP，目的主机在本地网络上，没有必要查找表，这个标志一般用在网络诊断和路由程序里面。

MSG_OOB：接受或者发生带外数据

表示可以接收和发送带外数据。

MSG_PEEK：查看数据，并不从系统缓冲区移走数据

是recv函数使用的标志，表示只是从系统缓冲区中读取内容，而不清除系统缓冲区的内容。这样在下次读取的时候，依然是一样的内容，一般在有过个进程读写数据的时候使用这个标志。

MSG_WAITALL：等待所有数据

是recv函数的使用标志，表示等到所有的信息到达时才返回，使用这个标志的时候，recv返回一直阻塞，直到指定的条件满足时，或者是发生了错误。

参考文档：《socket网络编程中read与recv区别》

inet_addr/inet_ntoa/inet_ntop

htons

实例

int MAIN(int argc, char **argv)
{
    struct sockaddr_in address; 
    int client_sock; 
    int len,result; 
    int n,tmp; 
    char buffer[BUFSIZZ]; 
    unsigned char *host="admin.omsg.cn";
    short port = 80;
    struct hostent *he;
    struct in_addr **addr_list;
    int i;
    struct timeval tmstart;

#define REQUEST_STR "GET http://admin.omsg.cn/uploadpic/2016121034000012.png HTTP/1.1\r\nHost: admin.omsg.cn\r\nAccept: */*\r\nConnection: Keep-Alive\r\n\r\n"

if ((he = gethostbyname(host)) == NULL) {  // get the host info
        printf("gethostbyname error");
        return 1;
    }
    printf("Official name is: %s\n", he->h_name);
    printf("    IP addresses: ");
    addr_list = (struct in_addr **)he->h_addr_list;
    for(i = 0; addr_list[i] != NULL; i++) {
        printf("\t%s \n", inet_ntoa(*addr_list[i]));
    }

client_sock=socket(AF_INET,SOCK_STREAM,0); 
    address.sin_addr.s_addr=inet_addr(inet_ntoa(*addr_list[0]));   
    address.sin_family=AF_INET; 
    address.sin_port=htons(port); 
    len=sizeof(address); 
    printf("@@@@@ line=%d time consumption=%lf\n", __LINE__, tminterval(tmstart));
    result=connect(client_sock,(struct sockaddr *)&address,len); 
    if(result==-1){ 
        printf("error!"); 
        exit(-1); 
    } 
    printf("@@@@@ line=%d time consumption=%lf\n", __LINE__, tminterval(tmstart));
    n=write(client_sock,REQUEST_STR, strlen(REQUEST_STR)); 
    if(n<0){ 
        printf("error write/n"); 
    } 
    memset(buffer,0, sizeof(buffer)); 
    printf("@@@@@ line=%d time consumption=%lf\n", __LINE__, tminterval(tmstart));
    #if 0
    while(tmp=recv(client_sock,buffer,sizeof(buffer),0)){ 
        if(tmp==-1) break; 
        printf("@@@@@ line=%d mbuf_len=%d time consumption=%lf, buffer=%s\n", __LINE__, tmp, tminterval(tmstart), buffer);
    } 
    #else
    do {
        tmp = read(client_sock, buffer, sizeof(buffer));
        printf("@@@@@ line=%d mbuf_len=%d time consumption=%lf, buffer=%s\n", __LINE__, tmp, tminterval(tmstart), buffer);
    } while (tmp > 0);
    #endif
   
    return (EXIT_SUCCESS);     
}