网络套接字与寻址

1 套接字描述

套接字是通信端点的抽象,创建一个套接字使用如下函数:

#include <sys/socket.h>

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

返回值：若成功，返回套接字描述符；若出错，返回-1.

参数：

domain: 指定通信的特征，包括地址格式，以AF_开头的常数表示地址族（address family）：

域	描述
AF_INET	IPv4因特网域
AF_INET6	IPv6因特网域
AF_UNIX	UNIX域
AF_UPSPEC	未指定（可以代表任何域）

type: 指定套接字的类型。如下为POSIX.1的套接字类型，也可以增加其他类型的支持：

类型	描述
SOCK_DGRAM	固定长度、无连接、不可靠
SOCK_RAM	IP协议的数据报接口
SOCK_SEQPACKET	固定长度、面向连接、有序、可靠
SOCK_STREAM	有序、可靠、双向、面向连接

protocol: 根据指定的domain和type所提供的默认协议，通常设为0即可。在AF_INET通信域中，SOCK_STREAM默认的协议为TCP；SOCK_DGRAM默认的协议为UDP.

使用无连接的数据报通信类似于邮寄信件，你不能保证传递的次序，信件可能会丢失，每封信都包含收信人地址；相反地，使用面向连接的通信协议类似于打电话，首先需要建立连接，连接建立好以后，彼此可以双向地通信，对话中不需要包含地址信息，连接本身指定了通话的源和目的，就像是端与端之间有一条虚拟链路一样。

SOCK_STREAM套接字提供了字节流服务，应用程序不能分辨出报文的界限；SOCK_SEQPACKET套接字提供了基于报文的服务，这意味着接受的数据量和发送的数据量完全一致；SOCK_RAW套接字提供了一个数据报接口，用于直接访问下面的网络层，使用该套接字时，必须有root用户权限，并且需要应用程序自己负责构造协议头。

套接字通信是双向的，可以使用shutdown函数来禁止一个套接字I/O：

#include <sys/socket.h>

int shutdown(int sockfd, int how);

返回值：若成功，返回0；若出错，返回-1.

参数：

how: SHUT_RD(关闭读)，SHUT_WR(关闭写)，SHUT_RDWR(关闭读写).

套接字本质上是一个文件描述符，如下为适用于文件描述符的函数在套接字中的表现行为：

文件描述符函数	使用套接字时的行为
close	释放套接字
dup / dup2	复制套接字
fchdir	失败，并且将errno设置为ENOTDIR
fchomod	未指定
fchown	由实现定义
fcntl	支持某些命令
fdatasync / fsync	由实现定义
fstat	支持一些stat结构成员，如何支持由实现定义
ftruncate	未指定
ioctl	依赖于底层设备驱动
lseek	由实现定义，失败时将errno设置为ESPIPE
mmap	未指定
poll	正常工作
pread / pwrite	失败时，将errno设置为ESPIPE
read / readv	与没有任何标志位的recv等价
select	正常工作
write / writev	与没有任何标志位的send等价

2 寻址

：： 不同的处理器架构有着不同的字节序，如果需要实现异构通信，必须统一字节序方式。网络协议指定了字节序（网络字节序），TCP/IP协议栈使用大端方式，对于使用TCP/IP的应用程序，有4个函数可以用来在处理器字节序和网络字节序之间进行转换：

#include <arpa/inet.h>

uint32_t htonl(uint32_t hostint32); // 32位主机-->32位网络

uint16_t htons(uint16_t hostint16); // 16位主机-->16位网络

uint32_t ntohl(uint32_t netint32); // 32位网络-->32位主机

uint16_t ntohs(uint16_t netint16); // 16位网络-->16位主机

说明：

h: 主机字节序

n: 网络字节序

l: 4字节的长整型

s: 2字节的短整型

#include <arpa/inet.h>
#include <stdio.h>

int main(void)
{
unsigned int bytes = 0x12345678;
const char* p = (const char*)&bytes;
printf("%x_%x_%x_%x\n", p[0], p[1], p[2], p[3]);

unsigned int netbytes = htonl(bytes);    /* 将主机字节序转换为网络字节序 */
p = (const char*)&netbytes;
printf("%x_%x_%x_%x\n", p[0], p[1], p[2], p[3]);

return 0;
}

由于地址格式与特定的通信域相关，因此，为了使得不同格式的地址都能够传入套接字函数，所有的地址必须先被强制转换为一个通用的地址结构sockaddr:

struct sockaddr

{

unsigned char sa_len; /* total length */

sa_family_t sa_family; /* address family */

char sa_data[14]; /* variable-length address */

};

因特网地址定义在<netinet/in.h>中：

struct in_addr

{

in_addr_t s_addr; /* IPv4 address */

};

struct sockaddr_in

{

sa_family_t sin_family; /* address_family */

in_port_t sin_port; /* port number */

struct in_addr sin_addr; /* IPv4 address */

};

数据类型in_port_t为uint16_t，in_addr_t为uint32_t，在<stdint.h>中定义了这些类型。

：： 如下函数可以在数值地址和文本格式字符串地址之间进行转换：

#include <arpa/inet.h>

/* 将数值地址转换为文本字符串格式 */

const char* inet_ntop(int domain,

　　　　　　　　　　　const void *restrict addr,

　　　　　　　　　　　char* restrict str, socklen_t size);

/* 将文本字符串格式转换为数值地址 */

int inet_pton(int domain,

　　　　　　　const char* restrict str,

　　　　　　　void* restrict addr);

参数：

domain: AF_INET或者AF_INET6.

size: 指定保存文本字符串缓冲区str的大小，该参数为INET_ADDRSTREAM或者INET6_ADDRSTREAM时，表明使用足够大的空间来存放该地址。

说明：

inet_pton的输出为网络字节序，inet_ntop的输入为网络字节序，要注意转换。

#include <arpa/inet.h>
#include <stdio.h>

int main(void)
{
char dotaddr[] = "192.168.8.128";
struct in_addr ipaddr;

inet_pton(AF_INET, dotaddr, (void*)&ipaddr);

ipaddr.s_addr = ntohl(ipaddr.s_addr);    /* 将网络字节序转换为主机字节序 */
printf("addr = %x\n", ipaddr.s_addr);

ipaddr.s_addr = htonl(ipaddr.s_addr);    /* 将主机字节序转换为网络字节序 */
inet_ntop(AF_INET, (void*)&ipaddr, dotaddr, 16);
printf("addr = %s\n", dotaddr);

return 0;
}

地址查询：

#include <netdb.h>

struct hostent* gethostent(void); /* 返回下一个文件 */

void sethostent(int stayopen); 　　 /* 打开文件 */

void endhostent(void); 　　/* 关闭文件 */

：： gethostent返回一个指向hostent结构体的指针，hostent结构如下：

struct hostent

{

char *h_name; 　　　/* 主机名 */

char **h_aliases; 　　　　/* 可选的别名列表 */

int h_addrtype; 　　 /* 地址类型，一般为AF_INET */

int h_length; 　　 /* 地址长度 */

char **h_addr_list; /* 网络地址列表 */

#define h_addr h_addr_list[0]; /* 第一个网络地址 */

};

说明：

之所以主机的地址是一个列表的形式，其原因是一个主机可能有多个网络接口。

返回的地址为网络字节序。

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

int main()
{
struct hostent* h;
h = gethostbyname("benxintuzi");
printf("host: %s\n", h->h_name);
printf("addr: %s\n", inet_ntoa(*((struct in_addr*)h->h_addr)));

return 0;
}

：： 如下函数用来获得网络名字和网络编号：

#include <netdb.h>

struct netent* getnetbyaddr(uint32_t net, int type);

struct netent* getnetbyname(const char* name);

struct netent* getnetent(void);

void setnetent(int stayopen);

void endnetent(void);

netent结构体如下定义：

struct netent

{

char* n_name; /* network name */

char** n_aliases; /* alternate network name array pointer */

int n_addrtype; /* net address type */

uint32_t n_net; /* network number*/

};

#include <stdio.h>
#include <netdb.h>

void printnet(struct netent* net)
{
char** p = net->n_aliases;
printf("net name: %s\n", net->n_name);

while(*p != NULL)
{
printf("alias name: %s\n", *p);
p++;
}

printf("address type: %d\n", net->n_addrtype);

printf("net number: %u\n", net->n_net);
}

int main()
{
struct netent* net = NULL;
setnetent(1);
while((net = getnetent()) != NULL)
{
printnet(net);
printf("\n");
}
endnetent();

return 0;
}

：： 如下函数用于操作协议名和协议编号：

#include <netdb.h>

struct protoent* getprotobyname(const char* name);

struct protoent* getprotobynumber(int proto);

struct protoent* getprotoent(void);

void setprotoent(int stayopen);

void endprotoent(void);

struct protoent

{

char *p_name; /* Official protocol name. */

char **p_aliases; /* Alias list. */

int p_proto; /* Protocol number. */

};

#include <netdb.h>

void printproto(struct protoent* proto)
{
char** p = proto->p_aliases;
printf("proto name: %s\n", proto->p_name);

while(*p != NULL)
{
printf("alias name: %s\n", *p);
p++;
}

printf("proto number: %d\n", proto->p_proto);
}

int main()
{
struct protoent* proto = NULL;
setprotoent(1);
while((proto = getprotoent()) != NULL)
{
printproto(proto);
printf("\n");
}
endprotoent();

return 0;
}

：： 如下函数用于操作服务于端口号：

#include <netdb.h>

struct servent* getservbyname(const char* name, const char* proto);

struct servent* getservbyport(int port, const char* proto);

struct servent* getservent(void);

void setservent(int stayopen);

void endservent(void);

struct servent

{

char *s_name; /* Official service name. */

char **s_aliases; /* Alias list. */

int s_port; /* Port number. */

char *s_proto; /* Protocol to use. */

};

#include <stdio.h>
#include <netdb.h>

void printservent(struct servent* serv)
{
char** p = serv->s_aliases;
printf("servent name: %s\n", serv->s_name);

while(*p != NULL)
{
printf("alias name: %s\n", *p);
p++;
}

printf("port number: %d\n", serv->s_port);

printf("proto to use: %s\n", serv->s_proto);
}

int main()
{
struct servent* serv = NULL;
setservent(1);
while((serv = getservent()) != NULL)
{
printservent(serv);
printf("\n");
}
endservent();

return 0;
}

：： POSIX.1中定义的函数getaddrinfo用来代替过时的gethostbyname和gethostbyaddr：

#include <sys/socket.h>

#include <netdb.h>

int getaddrinfo(const char* restrict host,

　　　　　　　　const char* restrict service,

　　　　　　　　const struct addrinfo* restrict hint,

　　　　　　　　struct addrinfo** restrict res);

　　　　　　　　void freeaddrinfo(sruct addrinfo* ai);

struct addrinfo

{

int ai_flags; /* Input flags. */

int ai_family; /* Protocol family for socket. */

int ai_socktype; /* Socket type. */

int ai_protocol; /* Protocol for socket. */

socklen_t ai_addrlen; /* Length of socket address. */

struct sockaddr *ai_addr; /* Socket address for socket. */

char *ai_canonname; /* Canonical name for service location. */

struct addrinfo *ai_next; /* Pointer to next in list. */

};

getaddrinfo函数根据提供的主机名或服务名返回一个addrinfo链表；freeaddrinfo用来释放一个addrinfo结构体。如果getaddrinfo失败了，必须调用gai_strerror将返回的错误码转换成错误消息：

const char* gai_strerror(int error);

如果host非空，则指向一个长度为hostlen字节的缓冲区，用于存放返回的主机名；同样，如果service非空，则指向一个长度为servlen字节的缓冲区，用于返回的服务名。

具体的flags参数如下：

标志	描述
NI_DGRAM	服务基于数据报而非基于流
NI_NAMEREQD	如果找不到主机名，将其作为一个错误对待
NI_NOFQDN	对于本地主机，仅返回全限定域名的节点名部分
NI_NUMERICHOST	返回主机地址的数字形式，而非主机名
NI_NUMERICSCOPE	对于IPv6，返回数字形式
NI_NUMERICSERV	返回服务地址的数字形式（即端口号）

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

int main(void)
{
struct addrinfo*        ailist, *aip;
struct addrinfo         hint;
struct sockaddr_in*     sinp;
const char*             addr;
int                     err;
char                    abuf[INET_ADDRSTRLEN];

hint.ai_flags   = AI_CANONNAME;
hint.ai_family  = 0;
hint.ai_socktype        = 0;
hint.ai_protocol        = 0;
hint.ai_addrlen         = 0;
hint.ai_canonname       = NULL;
hint.ai_addr            = NULL;
hint.ai_next            = NULL;

if((err = getaddrinfo("benxintuzi", "nfs", &hint, &ailist)) != 0)
printf("getaddrinfo error: %s", gai_strerror(err));
for(aip = ailist; aip != NULL; aip = aip->ai_next)
{
printf("host: %s\n", aip->ai_canonname ? aip->ai_canonname : "-");
if(aip->ai_family == AF_INET)
{
sinp = (struct sockaddr_in*)aip->ai_addr;
addr = inet_ntop(AF_INET, &sinp->sin_addr, abuf, INET_ADDRSTRLEN);
printf("address: %s\n", addr ? addr : "Unknown");

}
printf("\n");
}

return 0;
}

：： getnameinfo将一个地址转换为一个主机名和一个服务名：

#include <sys/socket.h>

#include <netdb.h>

int getnameinfo(const struct sockaddr* addr,

　　　　　　　　socklen_t alen,

　　　　　　　　char* restrict host,

　　　　　　　　socklen_t hostlen,

　　　　　　　　char* restrict service,

　　　　　　　　socklen_t servlen,

　　　　　　　　int flags);

struct sockaddr

{

unsigned short sa_family; /* address family, AF_xxx */

char sa_data[14]; /* 14 bytes of protocol address */

};

套接字与地址的关联：

给某个服务器关联一个众所周知的地址，使得客户端可以访问该服务器，最简单的一个办法是服务器保留一个地址并且将其注册在/etc/services中，使用bind函数：

#include <sys/socket.h>

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

地址中的端口号一般不小于1024，并且一般只能将一个套接字端口绑定在一个给定的地址上。

使用getsockname找到绑定到套接字上的地址：

int getsockname(int sockfd,

　　　　　　　　struct sockaddr* restrict addr,

　　　　　　　　socklen_t* restrict alenp);

alenp指向缓冲区addr的长度。返回时，该整数会被设置成返回地址的大小，如果地址和提供的缓冲区长度不匹配，则地址会被自动截断而不报错。

如果套接字已经和连接上，则可以使用getpeername来找到对方的地址：

int getpeername(int sockfd,

　　　　　　　　struct sockaddr* restrict addr,

　　　　　　　　socklen_t* restrict alenp);