socket.h.bak

自己编写的SOCKET程序 源码有详尽的注释 可以用来学习C/S程序的编写方法

/*
 *	Copyleft Abelworkshop.	
 *	文件名称：socket.h
 *	摘    要：sokcet应用辅助功能，完成一些处理工作
 *	单    位：信息学院
 *	作    者：罗涛,2120060434
 *	完成日期：2006年11月20日
 */

#include "stdafx.h"
//#include <WINSOCK2.H>
//#include <WS2TCPIP.H>
//#include <stdlib.h>
//#include <stdio.h>
//#include <fstream>
//#include <windows.h>

using namespace std;

//#pragma comment(lib,"Ws2_32.lib")

#define ARP		0x0806

#define IP		0x00
#define ICMP	0x01
#define IGMP	0x02
#define IPinIP	0X04
#define TCP		0x06
#define EGP		0x08
#define UDP		0x11
#define IPv6	0x29
#define RSVP	0x2E
#define OSPF	0x59

#define BUFFER_SIZE 20
#define BUFFERSIZE	24
#define	SIO_RCVALL _WSAIOW(IOC_VENDOR,1)

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

typedef unsigned char uchar;
typedef unsigned short usint;
typedef unsigned long ulint;

#pragma pack(1)					//进入字节对齐方式，方便后边的类型强制转换20061030

typedef struct FrameHeader_t {	//帧首部
    BYTE	DesMAC[6];			// 目的地址
    BYTE 	SrcMAC[6];			// 源地址
    WORD	FrameType;			// 帧类型
} FrameHeader_t;

typedef struct IPHeader_t {		//IP首部
	BYTE	Ver_HLen;
	BYTE	TOS;
	WORD	TotalLen;
	WORD	ID;
	WORD	Flag_Segment;
	BYTE	TTL;
	BYTE	Protocol;
	WORD	Checksum;
	ULONG	SrcIP;
	ULONG	DstIP;
} IPHeader_t;

typedef struct Data_t {			//包含帧首部和IP首部的数据包
	FrameHeader_t	FrameHeader;
	IPHeader_t		IPHeader;
} Data_t;

#pragma pack()					//恢复缺省对齐方式
//以上定义因为是众所周知，所以在理解的基础上自互联网获取20061030
/*根据以上定义提取源IP地址和目的IP地址的方法比较简洁(如下)，便比较浪费CPU操作时间
Data_t		* IPPacket;
ULONG		SourceIP,DestinationIP;
……
IPPacket = (Data_t *) pkt_data;
……
SourceIP = ntohl(IPPacket->IPHeader.SrcIP);
DestinationIP = ntohl(IPPacket->IPHeader.DstIP);
……*/

struct cap_pack										//存放监控结果链表结点结构
{
	ulint	SrcIP;									//源IP
	ulint	DstIP;									//目的IP
	BYTE	Protocol;								//协议类型
	ulint	Count;									//统计数量
	cap_pack* next;									//链表，指向下一个节点
};

#define IPTOSBUFFERS 12
char* ipTostr(ulint ulIP){								// 将一个无符号长整型的机器IP地址转换为字符串类型的用户友好IP格式
	static char output[IPTOSBUFFERS][3 * 4 + 3 + 1];
	static short which;									//定义两个静态数组，可容纳最多12组IP类地址，最大程度防止指针越界！
	uchar* chIP;
	chIP = (uchar*)&ulIP;								//取ulIP的地址，并强制转化为无符号字符型指针
	which = (which + 1 == IPTOSBUFFERS ? 0 : which + 1); 
	sprintf(output[which], "%d.%d.%d.%d", chIP[0], chIP[1], chIP[2], chIP[3]); 
	return output[which];
}

int countCh(char* chIn){								//计算字符数组长度
	int i = 0;
	while (chIn[i++] != 0);
	return i;
}

ulint ulSeleIP = 0;
int threadHandle = 0;
int in_thread = 0;
int finish_msg = 1;
cap_pack* capHeader = NULL;
cap_pack* curPoint_R = NULL;
cap_pack* curPoint_T = NULL;

void addPackItem(ulint SrcIP, ulint DstIP, BYTE Protocol, char RorT){
	cap_pack* p = capHeader;							//capHeader.next=.SrcIP=.Count = 4277075694(0xfeeefeee),.Portocol = 238(0xee)
	if (RorT) {											//增加RorT标志，以识别接收还是发送，可以少N次比较20061106
		if (curPoint_R) {
			if (curPoint_R->SrcIP == SrcIP) {
				if (curPoint_R->Protocol == Protocol) {
					curPoint_R->Count++;
					return;
				}
			}
		}
		while (p){
			if (p->SrcIP == SrcIP) {					//0xfeeefeee,CXX0030:Error:expression cannot be evaluated//SrcIP:192.168.0.254
				//if (p->DstIP == DstIP){
				if (p->Protocol == Protocol){
					p->Count++;
					curPoint_R = p;						//保留最后一次操作指针，因为完全同一类型的包再次出现的机率比较大20061108
					//AfxGetApp()->m_pMainWnd->MessageBox("modify one");
					return;
				}
				//}
			}
			if (!p->next) break;						//如果next为空则跳出，准备将新的结点赋于之20061103
			p = p->next;
		}
	}
	else{
		if (curPoint_T) {
			if (curPoint_T->DstIP == DstIP) {
				if (curPoint_T->Protocol == Protocol) {
					curPoint_T->Count++;
					return;
				}
			}
		}
		while (p){
			//if (p->SrcIP == SrcIP) {
			if (p->DstIP == DstIP){
				if (p->Protocol == Protocol){
					p->Count++;
					curPoint_T = p;
					//AfxGetApp()->m_pMainWnd->MessageBox("modify one");
					return;
				}
			}
			//}
			if (!p->next) break;						//如果next为空则跳出，准备将新的结点赋于之20061103
			p = p->next;
		}
	}
	cap_pack* capItem = (cap_pack*)malloc(sizeof(cap_pack));
	capItem->SrcIP = SrcIP;
	capItem->DstIP = DstIP;
	capItem->Protocol = Protocol;
	capItem->Count = 1;
	capItem->next = NULL;
	if (capHeader) {									//将链表接上20061103
		p->next = capItem;
	}
	else {
		capHeader = capItem;							//初始化时此头为空，此处第一次会同赋值20061103
	}
	if (RorT) {											//在TCP连接中，一来一回会同时出现两次变化，一个指针高速缓存反而成为累赘，所以调收与发两个指针20061108
		curPoint_R = capItem;
	}
	else {
		curPoint_T = capItem;
	}
	//AfxGetApp()->m_pMainWnd->MessageBox("add one");
	return;
}

void freePackItem(cap_pack* cHeader){					//将整个链表所占空间释放
	//AfxGetApp()->m_pMainWnd->MessageBox("free begin");
	cap_pack* P = cHeader;
	cap_pack* Pnext;
	//AfxGetApp()->m_pMainWnd->MessageBox("free continue");
	while (P){
		Pnext = P->next;
		free(P);
		P = Pnext;
		//AfxGetApp()->m_pMainWnd->MessageBox("free one");
	}
	capHeader = NULL;									//将链表头指针及传入、传出包高速缓冲指针置空20061108
	curPoint_R = NULL;
	curPoint_T = NULL;
	//AfxGetApp()->m_pMainWnd->MessageBox("free all");
}

string proToCh(BYTE Protocol){							//将协议字段转为字符串可读
	switch(Protocol) {
	case IP:
		return "IP    ";
	case ICMP:
		return "ICMP  ";
	case IGMP:
		return "IGMP  ";
	case IPinIP:
		return "IPinIP";		
	case TCP:
		return "TCP   ";	
	case EGP:
		return "EGP   ";
	case UDP:
		return "UDP   ";
	case IPv6:
		return "IPv6  ";
	case RSVP:
		return "RSVP  ";
	case OSPF:
		return "OSPF  ";
	default:
		return "UNKNOW";
	}
}