Socket 相关的知识

1、关于PF_INET和AF_INET的区别

在写网络程序的时候,建立TCP socket:
 sock = socket(PF_INET, SOCK_STREAM,
0);

然后在绑定本地地址或连接远程地址时需要初始化sockaddr_in结构,其中指定address
family时一般设置为AF_INET,即使用IP。

相关头文件中的定义:AF = Address Family
                            PF = Protocol Family
                            AF_INET
= PF_INET

在windows中的Winsock2.h中,

#define AF_INET 0
                           #define PF_INET AF_INET

所以在windows中AF_INET与PF_INET完全一样.

而在Unix/Linux系统中,在不同的版本中这两者有微小差别.对于BSD,是AF,对于POSIX是PF.

理论上建立socket时是指定协议,应该用PF_xxxx,设置地址时应该用AF_xxxx。当然AF_INET和PF_INET的值是相同的,混用也不会有太大的问题。也就是说你socket时候用PF_xxxx,设置的时候用AF_xxxx也是没关系的,这点随便找个TCPIP例子就可以验证出来了。如下,不论是AF_INET还是PF_INET都是可行的,只不过这样子的话,有点不符合规范。

 /* 服务器端开始建立socket描述符 */
// if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
if((sockfd=socket(PF_INET,SOCK_STREAM,))==-)
{
fprintf(stderr,"Socket error:%s\n\a",strerror(errno));
exit();
} /* 服务器端填充 sockaddr结构 */
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
//server_addr.sin_family=PF_INET;
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
server_addr.sin_port=htons(portnumber);
在函数socketpair与socket的domain参数中有AF_UNIX,AF_LOCAL,AF_INET,PF_UNIX,PF_LOCAL,PF_INET.
这几个参数有AF_UNIX=AF_LOCAL, PF_UNIX=PF_LOCAL, AF_LOCAL=PF_LOCAL, AF_INET=PF_INET.
但是对于socketpair与socket的domain参数,使用PF_LOCAL系列,
而在初始化套接口地址结构时,则使用AF_LOCAL.
例如:
z = socket(PF_LOCAL, SOCK_STREAM, 0);
adr_unix.sin_family = AF_LOCAL;
Linux 下的address family定义
/* Supported address families. */
#define AF_UNSPEC 0
#define AF_UNIX 1 /* Unix domain sockets */
#define AF_LOCAL 1 /* POSIX name for AF_UNIX */
#define AF_INET 2 /* Internet IP Protocol */
#define AF_AX25 3 /* Amateur Radio AX.25 */
#define AF_IPX 4 /* Novell IPX */
#define AF_APPLETALK 5 /* AppleTalk DDP */
#define AF_NETROM 6 /* Amateur Radio NET/ROM */
#define AF_BRIDGE 7 /* Multiprotocol bridge */
#define AF_ATMPVC 8 /* ATM PVCs */
#define AF_X25 9 /* Reserved for X.25 project */
#define AF_INET6 10 /* IP version 6 */
#define AF_ROSE 11 /* Amateur Radio X.25 PLP */
#define AF_DECnet 12 /* Reserved for DECnet project */
#define AF_NETBEUI 13 /* Reserved for 802.2LLC project*/
#define AF_SECURITY 14 /* Security callback pseudo AF */
#define AF_KEY 15 /* PF_KEY key management API */
#define AF_NETLINK 16
#define AF_ROUTE AF_NETLINK /* Alias to emulate 4.4BSD */
#define AF_PACKET 17 /* Packet family */
#define AF_ASH 18 /* Ash */
#define AF_ECONET 19 /* Acorn Econet */
#define AF_ATMSVC 20 /* ATM SVCs */
#define AF_RDS 21 /* RDS sockets */
#define AF_SNA 22 /* Linux SNA Project (nutters!) */
#define AF_IRDA 23 /* IRDA sockets */
#define AF_PPPOX 24 /* PPPoX sockets */
#define AF_WANPIPE 25 /* Wanpipe API Sockets */
#define AF_LLC 26 /* Linux LLC */
#define AF_CAN 29 /* Controller Area Network */
#define AF_TIPC 30 /* TIPC sockets */
#define AF_BLUETOOTH 31 /* Bluetooth sockets */
#define AF_IUCV 32 /* IUCV sockets */
#define AF_RXRPC 33 /* RxRPC sockets */
#define AF_ISDN 34 /* mISDN sockets */
#define AF_PHONET 35 /* Phonet sockets */
#define AF_IEEE802154 36 /* IEEE802154 sockets */
#define AF_CAIF 37 /* CAIF sockets */
#define AF_MAX 38 /* For now.. */ /* Protocol families, same as address families. */
#define PF_UNSPEC AF_UNSPEC
#define PF_UNIX AF_UNIX
#define PF_LOCAL AF_LOCAL
#define PF_INET AF_INET
#define PF_AX25 AF_AX25
#define PF_IPX AF_IPX
#define PF_APPLETALK AF_APPLETALK
#define PF_NETROM AF_NETROM
#define PF_BRIDGE AF_BRIDGE
#define PF_ATMPVC AF_ATMPVC
#define PF_X25 AF_X25
#define PF_INET6 AF_INET6
#define PF_ROSE AF_ROSE
#define PF_DECnet AF_DECnet
#define PF_NETBEUI AF_NETBEUI
#define PF_SECURITY AF_SECURITY
#define PF_KEY AF_KEY
#define PF_NETLINK AF_NETLINK
#define PF_ROUTE AF_ROUTE
#define PF_PACKET AF_PACKET
#define PF_ASH AF_ASH
#define PF_ECONET AF_ECONET
#define PF_ATMSVC AF_ATMSVC
#define PF_RDS AF_RDS
#define PF_SNA AF_SNA
#define PF_IRDA AF_IRDA
#define PF_PPPOX AF_PPPOX
#define PF_WANPIPE AF_WANPIPE
#define PF_LLC AF_LLC
#define PF_CAN AF_CAN
#define PF_TIPC AF_TIPC
#define PF_BLUETOOTH AF_BLUETOOTH
#define PF_IUCV AF_IUCV
#define PF_RXRPC AF_RXRPC
#define PF_ISDN AF_ISDN
#define PF_PHONET AF_PHONET
#define PF_IEEE802154 AF_IEEE802154
#define PF_CAIF AF_CAIF
#define PF_MAX AF_MAX

2、linux之shutdown()与close()函数

1.close()函数

int close(int sockfd);     //返回成功为0,出错为-1.

close 一个套接字的默认行为是把套接字标记为已关闭,然后立即返回到调用进程,该套接字描述符不能再由调用进程使用,也就是说它不能再作为read或write的第一个参数,然而TCP将尝试发送已排队等待发送到对端的任何数据,发送完毕后发生的是正常的TCP连接终止序列。

在多进程并发服务器中,父子进程共享着套接字,套接字描述符引用计数记录着共享着的进程个数,当父进程或某一子进程close掉套接字时,描述符引用计数会相应的减一,当引用计数仍大于零时,这个close调用就不会引发TCP的四路握手断连过程。

2.shutdown()函数

int shutdown(int sockfd,int howto);  //返回成功为0,出错为-1.

该函数的行为依赖于howto的值

1.SHUT_RD:值为0,关闭连接的读这一半。

2.SHUT_WR:值为1,关闭连接的写这一半。

3.SHUT_RDWR:值为2,连接的读和写都关闭。

终止网络连接的通用方法是调用close函数。但使用shutdown能更好的控制断连过程(使用第二个参数)。

3.两函数的区别

close与shutdown的区别主要表现在:

close函数会关闭套接字ID,如果有其他的进程共享着这个套接字,那么它仍然是打开的,这个连接仍然可以用来读和写,并且有时候这是非常重要的,特别是对于多进程并发服务器来说。

而shutdown会切断进程共享的套接字的所有连接,不管这个套接字的引用计数是否为零,那些试图读得进程将会接收到EOF标识,那些试图写的进程将会检测到SIGPIPE信号,同时可利用shutdown的第二个参数选择断连的方式。

下面将展示一个客户端例子片段来说明使用close和shutdown所带来的不同结果:

客户端有两个进程,父进程和子进程,子进程是在父进程和服务器建连之后fork出来的,子进程发送标准输入终端键盘输入数据到服务器端,知道接收到EOF标识,父进程则接受来自服务器端的响应数据。

   s=connect(...); 

   if( fork() ){
while( gets(buffer) >)
write(s,buf,strlen(buffer));
close(s);
exit();
}
else {
while( (n=read(s,buffer,sizeof(buffer)){
do_something(n,buffer);

wait();
exit();
}

对于这段代码,我们所期望的是子进程获取完标准终端的数据,写入套接字后close套接字,并退出,服务器端接收完数据检测到EOF(表示数据已发送完),也关闭连接,并退出。接着父进程读取完服务器端响应的数据,并退出。然而,事实会是这样子的嘛,其实不然!子进程close套接字后,套接字对于父进程来说仍然是可读和可写的,尽管父进程永远都不会写入数据。因此,此socket的断连过程没有发生,因此,服务器端就不会检测到EOF标识,会一直等待从客户端来的数据。而此时父进程也不会检测到服务器端发来的EOF标识。这样服务器端和客户端陷入了死锁(deadlock)。如果用shutdown代替close,则会避免死锁的发生。

if( fork() ) {
while( gets(buffer)
write(s,buffer,strlen(buffer)); shutdown(s,);
exit();
}

 3、当客户端保持着与服务器端的连接,这时服务器端断开,再开启服务器时会出现: Address already in usr
      可以用netstat -anp | more 可以看到客户端还保持着与服务器的连接(还在使用服务器bind的端口)。这是由于client没有执行close,连接还会等待client的FIN包一段时间。解决方法是使用setsockopt,使得socket可以被重用,是最常用的服务器编程要点。具体的做法为是,在socket调用和bind调用之间加上一段对socket的设置:

int opt = ;
setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));

4、 指定网卡IP信息设置

/*----------------------------------------------------------------------------
Network Info
-----------------------------------------------------------------------------*/
static int gateway_info(char *dev, char *gateway, int set)
{
FILE *fp;
unsigned char buf[], gate[];
unsigned char *find; //# get gateway
sprintf(buf, "route -n | grep 'UG[ \t]' | grep %s | awk '{print $2}'", dev); fp = popen(buf, "r");
if(NULL == fp) {
eprintf("popen error (%s)\n", buf);
return -;
} if(!fgets(gate, , fp)) {
strcpy(gate, "0.0.0.0");
}
else {
find = strchr(gate,'\n'); //# remove '\n'
if(find) *find='\0';
}
pclose(fp); if(set) //# set gateway
{
if(strcmp(gate, "0.0.0.0")) {
sprintf(buf, "route del default gw %s %s", gate, dev);
system_user(buf);
}
sprintf(buf, "route add default gw %s %s", gateway, dev);
system_user(buf);
}
else
{
strcpy(gateway, gate);
} return ;
} int get_net_info(int devno, dvr_net_info_t *inet)
{
int ret, fd;
char dev[];
struct ifreq ifr; fd = socket(AF_INET, SOCK_DGRAM, ); /* I want to get an IPv4 IP address */
ifr.ifr_addr.sa_family = AF_INET; /* I want IP address attached to "eth0" */
sprintf(dev, "eth%d", devno);
strncpy(ifr.ifr_name, dev, IFNAMSIZ-); //# check up/down
ioctl(fd, SIOCGIFFLAGS, &ifr);
inet->state = ifr.ifr_flags & IFF_UP; #if 1
if(!inet->state) { //# down
close(fd);
strcpy(inet->ip, "0.0.0.0");
strcpy(inet->mask, "255.255.255.0");
strcpy(inet->gate, "0.0.0.0");
return ;
}
#endif ret = ioctl(fd, SIOCGIFADDR, &ifr);
if(ret<)
strcpy(inet->ip, "0.0.0.0");
else
sprintf(inet->ip, "%s", inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr)); ret = ioctl(fd, SIOCGIFNETMASK, &ifr);
if(ret<)
strcpy(inet->mask, "255.255.255.0");
else
sprintf(inet->mask, "%s", inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr)); close(fd); gateway_info(dev, inet->gate, ); return ;
} int set_net_info(int devno, dvr_net_info_t *inet)
{
int ret, fd;
char dev[], cmd[];
struct ifreq ifr;
struct sockaddr_in sin; if(!strcmp(inet->ip, "0.0.0.0"))
return -; sprintf(dev, "eth%d", devno); fd = socket(AF_INET, SOCK_DGRAM, );
strncpy(ifr.ifr_name, dev, IFNAMSIZ); //# check up/down
ioctl(fd, SIOCGIFFLAGS, &ifr);
inet->state = ifr.ifr_flags & IFF_UP;
if(!inet->state) { //# down
ifr.ifr_flags |= IFF_UP;
ioctl(fd, SIOCSIFFLAGS, &ifr);
sleep();
} if(inet->type == NET_DHCP)
{
sprintf(cmd, "udhcpc -n -i %s", dev);
ret = system_user(cmd);
}
else if(inet->type == NET_STATIC)
{
//memset(&sin, 0, sizeof(struct sockaddr));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = inet_addr(inet->ip);
memcpy(&ifr.ifr_addr, &sin, sizeof(struct sockaddr));
ioctl(fd, SIOCSIFADDR, &ifr); sin.sin_addr.s_addr = inet_addr(inet->mask);
memcpy(&ifr.ifr_addr, &sin, sizeof(struct sockaddr));
ret = ioctl(fd, SIOCSIFNETMASK, &ifr);
if(ret < )
dprintf("netmask: Invalid argument\n"); gateway_info(dev, inet->gate, );
} close(fd); return ret;
}

5、recv和recvform

  recv和recvfrom都可用TCP或者UDP,只是习惯性TCP用recv,因为基于连接的对方socket是已知的,UDP用recvfrom,因为一般用没有bind远端socket,接受到本地端口的所有数据,需要recvfrom识别远端地址。

  recv的recvfrom是可以替换使用的,只是recvfrom多了两个参数,可以用来接收对端的地址信息,这个对于udp这种无连接的,可以很方便地进行回复。而换过来如果你在udp当中也使用recv,那么就不知道该回复给谁了,如果你不需要回复的话,也是可以使用的。另外就是对于tcp是已经知道对端的,就没必要每次接收还多收一个地址,没有意义,要取地址信息,在accept当中取得就可以加以记录了

 6、gethostname和gethostbyname

  gethostname() -- 获取进程所在机器的计算机的名字。
  gethostbyname() -- 用域名或主机名获取IP地址,这个域名或主机名可以是本地机器的主机名/域名;也可以是远端节点的域名。

 7、Linux下端口复用(SO_REUSEADDR与SO_REUSEPORT) 

  只考虑AF_INET的情况(同一端口指ip地址与端口号都相同)
  1.freebsd支持SO_REUSEPORT和SO_REUSEADDR选项,而linux只支持SO_REUSEADDR选项。
  2.freebsd下,使用SO_REUSEPORT选项,两个tcp的socket可以绑定同一个端口;同样,使用SO_REUSEPORT选项,两个udp的socket可以绑定同一个端口。
  3.linux下,两个tcp的socket不能绑定同一个端口;而如果使用SO_REUSEADDR选项,两个udp的socket可以绑定同一个端口。
  4.freebsd下,两个tcp的socket绑定同一端口,只有第一个socket获得数据。
  5.freebsd下,两个udp的socket绑定同一端口,如果数据包的目的地址是单播地址,则只有第一个socket获得数据,而如果数据包的目的地址是多播地址,则两个socket同时获得相同的数据。
  6.linux下,两个udp的socket绑定同一端口,如果数据包的目的地址是单播地址,则只有最后一个socket获得数据,而如果数据包的目的地址是多播地址,则两个socket同时获得相同的数据。

  SO_REUSEADDR提供如下四个功能:
  1.SO_REUSEADDR允许启动一个监听服务器并捆绑其众所周知端口,即使以前建立的将此端口用做他们的本地端口的连接仍存在。这通常是重启监听服务器时出现,若不设置此选项,则bind时将出错。 
  2.SO_REUSEADDR允许在同一端口上启动同一服务器的多个实例,只要每个实例捆绑一个不同的本地IP地址即可。对于TCP,我们根本不可能启动捆绑相同IP地址和相同端口号的多个服务器。 
  3.SO_REUSEADDR允许单个进程捆绑同一端口到多个套接口上,只要每个捆绑指定不同的本地IP地址即可。这一般不用于TCP服务器。 
  4.SO_REUSEADDR允许完全重复的捆绑:当一个IP地址和端口绑定到某个套接口上时,还允许此IP地址和端口捆绑到另一个套接口上。一般来说,这个特性仅在支持多播的系统上才有,而且只对UDP套接口而言(TCP不支持多播)。

  SO_REUSEPORT选项有如下语义:
  此选项允许完全重复捆绑,但仅在想捆绑相同IP地址和端口的套接口都指定了此套接口选项才性。 
  如果被捆绑的IP地址是一个多播地址,则SO_REUSEADDR和SO_REUSEPORT等效。

  使用这两个套接口选项的建议:
  在所有TCP服务器中,在调用bind之前设置SO_REUSEADDR套接口选项; 
  当编写一个同一时刻在同一主机上可运行多次的多播应用程序时,设置SO_REUSEADDR选项,并将本组的多播地址作为本地IP地址捆绑。

8、UDP 调用 connect的作用 

  1.UDP中可以使用connect系统调用

  2.UDP中connect操作与TCP中connect操作有着本质区别。
    TCP中调用connect会引起三次握手,client与server建立连结.UDP中调用connect内核仅仅把对端ip&port记录下来。

  3.UDP中可以多次调用connect,TCP只能调用一次connect。
  UDP多次调用connect有两种用途:
    1,指定一个新的ip&port连结,指定新连结,直接设置connect第二个参数即可。
    2,断开和之前的ip&port的连结,断开连结,需要将connect第二个参数中的sin_family设置成 AF_UNSPEC即可。

  4.UDP中使用connect可以提高效率.原因如下:
  普通的UDP发送两个报文内核做了如下:
    #1:建立连结
    #2:发送报文
    #3:断开连结
    #4:建立连结
    #5:发送报文
    #6:断开连结
  采用connect方式的UDP发送两个报文内核如下处理:
    #1:建立连结
    #2:发送报文
    #3:发送报文另外一点, 每次发送报文内核都由可能要做路由查询。

  5.采用connect的UDP发送接受报文可以调用send,write和recv,read操作.当然也可以调用sendto,recvfrom.
  调用sendto的时候第五个参数必须是NULL,第六个参数是0,调用recvfrom,recv,read系统调用只能获取到先前connect的ip&port发送的报文。

  6.UDP中使用connect的好处:
  1:会提升效率.前面已经描述了.
  2:高并发服务中会增加系统稳定性.原因:
  假设client A 通过非connect的UDP与server B,C通信.B,C提供相同服务。为了负载均衡,我们让A与B,C交替通信。A 与 B通信IPa:PORTa <----> IPb:PORTb;A与 C通信IPa:PORTa' <---->IPc:PORTc 。假设PORTa与PORTa'相同了(在大并发情况下会发生这种情况),那么就有可能出现A等待B的报文,却收到了C的报文.导致收报错误.解决方法内就是采用connect的UDP通信方式.在A中创建两个udp,然后分别connect到B,C。

9、getsockname与getpeername

  getsockname()是返回套接口关联的本地协议地址。
  getpeername()是返回套接口关联的远程协议地址。

  getsockname和getpeername调度时机很重要,如果调用时机不对,则无法正确获得地址和端口。
  TCP:
  1>对于服务器来说,在bind以后就可以调用getsockname来获取本地地址和端口,虽然这没有什么太多的意义。getpeername只有在链接建立以后才调用,否则不能正确获得对方地址和端口,所以他的参数描述字一般是链接描述字而非监听套接口描述字。
  2>对于客户端来说,在调用socket时候内核还不会分配IP和端口,此时调用getsockname不会获得正确的端口和地址(当然链接没建立更不可能调用getpeername),当然如果调用了bind 以后可以使用getsockname。想要正确的到对方地址(一般客户端不需要这个功能),则必须在链接建立以后,同样链接建立以后,此时客户端地址和端口就已经被指定,此时是调用getsockname的时机。
  UDP:
  UDP分为链接和没有链接2种:
  1>没有链接的UDP不能调用getpeername,但是可以调用getsockname,和TCP一样,他的地址和端口不是在调用socket就指定了,而是在第一次调用sendto函数以后
  2>已经链接的UDP,在调用connect以后,这2个函数都是可以用的(同样,getpeername也没太大意义。如果你不知道对方的地址和端口,不可能会调用connect)。

10、用域名取得主机的ip地址(gethostbyname)

  使用gethostbyname()函数包含2个头文件:

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

  gethostbyname()函数定义:

struct hostent *gethostbyname(const char *name);

  这个函数的传入值是域名或者主机名,例如"www.google.com","wpc"等等;传出值,是一个hostent的结构(如下)。如果函数调用失败,将返回NULL

  hostent结构体定义:

struct hostent {
char *h_name; //表示的是主机的规范名。例如www.google.com的规范名其实是www.l.google.com。
char **h_aliases; // 表示的是主机的别名。www.google.com就是google他自己的别名。有的时候,有的主机可能有好几个别名,这些,其实都是为了易于用户记忆而为自己的网站多取的名字。
int h_addrtype; // 表示的是主机ip地址的类型,到底是ipv4(AF_INET),还是ipv6(AF_INET6)
int h_length; //表示的是主机ip地址的长度
char **h_addr_list; //表示的是主机的ip地址,注意,这个是以网络字节序存储的。千万不要直接用printf带%s参数来打这个东西,会有问题的哇。所以到真正需要打印出这个IP的话,需要调用inet_ntop()。
};

  inet_ntop()函数定义:

const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt) :

  这个函数,是将类型为af的网络地址结构src,转换成主机序的字符串形式,存放在长度为cnt的字符串中。
  这个函数,其实就是返回指向dst的一个指针。如果函数调用错误,返回值是NULL。

  下面是例程,就是通过给定一个主机名,然后调用gethostbyname(hostname),返回一个struct hostent类型的数据结构其中包含
char **h_addr_list(为ip地址列表),然后调用inet_ntoa(struct in_addr
in)打印出ip地址。

#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h> main(int argc,const char **argv)
{
long addr;
struct hostent *hp;
char **p; hp=gethostbyname(argv[]); /* 调用gethostbyname()。调用结果都存在hp中 注意有的获取IP地址的时候,需要去掉“://”前面的和“/”后面的*/
if(hp==NULL)
{
(void)printf("host information for %s not found\n",argv[]);
exit();
}
for(p=hp->h_addr_list;*p!=;p++)
{
struct in_addr in;
char **q;
memcpy(&in.s_addr,*p,sizeof(in.s_addr));
printf("%s\t%s",inet_ntoa(in),hp->h_name);/* 将刚才得到的所有地址都打出来。其中调用了inet_ntoa()函数 */
for(q=hp->h_aliases;*q!=;q++)
printf("%s",*q);
putchar('\n');
}
exit();
}

 11.udp数据发送

  udp数据发送的目标地址,一个固定值,一个接受到的地址,如果经过了路由器,那么这个接受地址变成了路由器地址,再次发送就不是已经的目标地址,而tcp的面向对象连接,建立了链路,所以远程的时候或者访问上级子网的时候,要么采取tcp的,要么采取udp 固定ip地址发送。

上一篇:eclipse对项目整理分类


下一篇:JQ插件ajaxFileUpload、php实现图片,数据同时上传