UNP_3_套接字编程简介

旧：inet_addr(),inet_ntoa()，支持ipv4
新：inet_ntop(),inet_pton()，同时支持ipv4，ipv6

// ipv4 套接字地址结构
// 使用单独的结构体存储 IP 地址有历史原因
struct in_addr{
	in_addr_t s_addr;  // 32 位的 IP 地址（uint32_t）
};

struct sockaddr_in{
	uint8_t        sin_len;      // 套接字地址的长度，并不是所有厂家都支持
	sa_family_t    sin_family;   // AF_INET（unsigned short）
	in_port_t      sin_port;     // 16 位的 ipv4 或 ipv6 端口号（uint16_t）
	struct in_addr sin_addr;     // 32 位 ipv4 地址
	char           sin_zero[8];
}；

struct sockaddr{
	uint8_t      sa_len;
	sa_family_t  sa_family;
	char         sa_data[14];
};

struct in6_addr{
	unit8_t s6_addr[16];  // 128bit IPV6 地址
};
#define SIN6_LEN
struct sockaddr_in6{
	uint8_t         sin6_len;
	sa_family       sin6_family;
	in_port_t       sin6_port;
	uint32_t        sin6_flowinfo;
	struct in6_addr sin6_addr;
	uint32_t        sin6_scope_id;
};

struct sockaddr_storage{
	uint8_t     ss_len;     // length
	sa_family_t ss_family;  // AF_XXX
	// 其余的字段对用户来说是透明的，转换为特定地址结构进行使用
};

eg: struct sockaddr_in serv;  
    connect(sockfd, (SA*) &serv, sizeof(serv)); //其中大小参数的类型是socklen_t(uint32_t) 

//大端小端测试函数
int main(int argc, char** argv){
	union{
		short s;
		char c[sizeof(short)];
	} un;
	un.s = 0x0102;
	if (sizeof(short) == 2){
		if(un.c[0] == 1 && un.c[1] == 2){
			printf("big endian\n");
		}
		else if(un.c[0] == 2 && un.c[1] == 1){
			printf("little endian\n");
		}
		else{
			printf("unknow");
		}
	}
	exit(0);
}

#include<netinet/in.h>
uint16_t htons(uint16_t );
uint32_t hton1(uint32_t );   //均返回，网络字节序的值
uint16_t ntohs(uint16_t );
uint32_t ntoh1(uint32_t );   //均返回，主机字节序的值

#include<strings.h> 
void bzero(void* dest, size_t nytes) .
void bcopy(const void* src, void* dest, size_t nbytes)
int bcmp(const void* ptrl, const void* ptr2, size_t nbytes)

void *memset(void* desk, int e, size_t len); 
void *memcpy(void* desk, const void* src, size_t nbytes); 
int memcpy(const void* ptrl, const void* ptr2, size_t nbytes); 

#include<arpa/inet.h>
int inet_aton(const char* strptr, struct in_addr* addr_ptr);   //若字符串有效则为1，否则为0
in_addr_t inet_addr(const char* strptr);     //若字符串有效，则返回32位二进制IPv4地址，否则为INADDR_NONE（通常为32位均为1的值）
char* inet_ntoa(struct in_addr inaddr);      //返回一个指向点分十进制的字符串指针

#include<arpa/inet.h>
// family 代表转换地址的类型
int inet_pton(int family, const char* strptr, void* addrptr);   //成功返回1，失败返回0，出错返回-1
const char* inet_ntop(int family, const void* addrptr, char* strptr, size_t len);     //成功返回指向字符串的指针，失败返回NULL

//IPv4调用格式
struct sockaddr_in addr;
inet_ntop(AF_INET, &addr.sin_addr, str, sizeof(str));
//IPv6调用格式
struct sockaddr_in6 addr6;
inet_ntop(AF_INET6, &addr6.sin6_addr, str, sizeof(str));

char* sock_ntop(const struct sockaddr* sa, socklen_t salen){
	char portstr[8];
	static char str[128];
	switch(sa->sa_family){
		case AF_INET: {
			struct sockaddr_in* sin = (struct sokaddr_in *) sa;

			if(inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str)) == NULL)
				return (NULL);
			if(ntohs(sin->sin_port) != 0){
				snprintf(portstr, sizeof(portstr), ":%d", ntohs(sin->sin_port));
				strcat(str, portstr);
			}
			return(str);
		}
	}
}

//UNP自定义的三个函数
ssize_t readn(int fd, void* vptr, size_t n){
	size_t nleft;
	ssize_t nread;
	char *ptr;
	ptr = vptr;
	nleft = n;
	// 循环读取
	while(nleft > 0){
		if( (nread = read(fd, ptr, nleft)) < 0){
			if(errno == EINTR){
				nread = 0;
			}
			else return -1;
		}
		else if (nread == 0){
			break;
		}
		nleft -= nread;
		ptr += nread;
	}
	return (n - left);
}

ssize_t writen(int fd, const void* vptr, size_t n){
	size_t nleft;
	ssize_t nwriten;
	const char* ptr;
	ptr = vptr;
	nleft = n;
	// 循环写入
	while(nleft > 0){
		if( (nwriten = write(fd, ptr, nleft)) <= 0){
			if(nwriten < 0 && errno == EINTR){
				nwriten= 0;
			}
			else return -1;
		}
		nleft -= nwriten;
		ptr += nwriten;
	}
	return n;
}

//readline书上提供了两个版本：第一个版本每次使用readn读取一个字节来判断是否遇到'\n'（效率极低）
//                          第二个版本用来建立一个缓冲区来进行提前缓存并进行判断