hostap_filter.c

该系统是基于Linux平台的WLAN应用

				}else{//first node type is dst mac
				//	p_cfg_node->type = CFG_BLOCK_TYPE_DA;
					memcpy(p_cfg_node, &frame_mgmt_da, sizeof(cfg_block_t));
					printf("type is %d\n", p_cfg_node->type);
					memcpy(p_cfg_node->value.value_mac, filter.dst_mac, 6);
					p_cfg_node->left = cfg_false;
					p_cfg_node->right = cfg_true;
				}
			}else{//first node type is src mac
				memcpy(p_cfg_node, &frame_mgmt_sa, sizeof(cfg_block_t));
				printf("sa type is %d\n", p_cfg_node->type);
				memcpy(p_cfg_node->value.value_mac, filter.src_mac, 6);
				make_cfg_node(CFG_BLOCK_TYPE_SA, LEFT_SON, p_cfg_node);	
				make_cfg_node(CFG_BLOCK_TYPE_SA, RIGHT_SON, p_cfg_node);
			}
		}else{//first node type is frame type
			memcpy(p_cfg_node, &frame_type, sizeof(cfg_block_t));
			p_cfg_node->value.value_type = filter.type_num;
			make_cfg_node(CFG_BLOCK_TYPE_TYPE, LEFT_SON, p_cfg_node);
			make_cfg_node(CFG_BLOCK_TYPE_TYPE, RIGHT_SON, p_cfg_node);
		}
	}else{//this is not the first node
		if ((father_node_type == CFG_BLOCK_TYPE_TRUE) || (father_node_type == CFG_BLOCK_TYPE_FALSE)){
			return ;
		}
		current_node_type = get_current_node_type(father_node_type, left_or_right_son);
		printf("current node type is %d\n", current_node_type);
		if (current_node_type == -1){//father node is true or false nodeand no current node exist
			//not attach this node to father node here, do it afterwards for one time

			return ;
		}
		if ((p_cfg_node = (cfg_block_t *)malloc(sizeof(cfg_block_t))) == NULL){
			perror("not enough memory\n");
			return ;
		}
		switch (current_node_type){
			case CFG_BLOCK_TYPE_TYPE:
				memcpy(p_cfg_node, &frame_type, sizeof(cfg_block_t));
				p_cfg_node->value.value_type = filter.type_num;
				break;
			case CFG_BLOCK_TYPE_SA:
				//here we do mgmt and data's sa filter, so we must confirm which frame type is ,and so take measure accordingly
				if (filter.type_num == WLAN_FC_TYPE_MGMT){
					memcpy(p_cfg_node, &frame_mgmt_sa, sizeof(cfg_block_t));
					memcpy(p_cfg_node->value.value_mac, filter.src_mac, 6);
				}else if (filter.type_num == WLAN_FC_TYPE_DATA){
					memcpy(p_cfg_node, &frame_data_fromds_sa, sizeof(cfg_block_t));
					memcpy(p_cfg_node->value.value_mac, filter.src_mac, 6);
			
				}
				break;
			case CFG_BLOCK_TYPE_DA:
				if (filter.type_num == WLAN_FC_TYPE_MGMT){
					memcpy(p_cfg_node, &frame_mgmt_da, sizeof(cfg_block_t));
					memcpy(p_cfg_node->value.value_mac, filter.dst_mac, 6);
					
				}else{
					memcpy(p_cfg_node, &frame_data_fromds_da, sizeof(cfg_block_t));
					memcpy(p_cfg_node->value.value_mac, filter.dst_mac, 6);
				
				}
				break;
			case CFG_BLOCK_TYPE_STYPE:
				memcpy(p_cfg_node, &frame_stype, sizeof(cfg_block_t));
				p_cfg_node->value.value_type = filter.stype[filter.stype_num_tmp];
				break;
			case CFG_BLOCK_TYPE_FALSE:
				father_node->left = cfg_false;
				return ;
				break;
			case CFG_BLOCK_TYPE_TRUE:
				father_node->right = cfg_true;
				return ;
				break;
			default :
				printf("error exit\n");
				exit(0);
		}
		if (left_or_right_son == LEFT_SON){
			father_node->left = p_cfg_node;
		}else if (left_or_right_son == RIGHT_SON){
			father_node->right = p_cfg_node;
		}else{
			printf("invalid input\n");
		}
		printf("test..........................\n");
		make_cfg_node(current_node_type, LEFT_SON, p_cfg_node);
		make_cfg_node(current_node_type, RIGHT_SON, p_cfg_node);
		
	}
	return ;
}

//two cases, one for no type, one for type
int make_cfg(){
	printf("make cfg begin...\n");
	printf("init cfg...\n");
	if ((cfg_false = (cfg_block_t *)malloc(sizeof(cfg_block_t))) == NULL){
		perror("no enough memory\n");
		return -1;
	}
	if ((cfg_true = (cfg_block_t *)malloc(sizeof(cfg_block_t))) == NULL){
		perror("no enough memory\n");
		return -1;
	}
	
	cfg_false->type = CFG_BLOCK_TYPE_FALSE;
	cfg_true->type = CFG_BLOCK_TYPE_TRUE;
	printf("init cfg end\n");
	printf("form cfg...\n");
	make_cfg_node(-1, 0, NULL);
	if (filter.type_num = WLAN_FC_TYPE_NO){
		
	}
	printf("make cfg end\n");
	return 0;
}

void printf_cfg_node(cfg_block_t *cfg_node){
	int i = 0;
	if (cfg_node == NULL){
		return ;
	}
	printf("----------cfg_node's type is %d\n", cfg_node->type);
	if (cfg_node->type == CFG_BLOCK_TYPE_FALSE){
		printf("false\n");
		return ;
	}
	if (cfg_node->type == CFG_BLOCK_TYPE_TRUE){
		printf("true\n");
		return ;
	}
		
	if (cfg_node->byte_or_bit == BYTE_TYPE){
		printf("bit or byte is %d\n", cfg_node->byte_or_bit);
		printf("bytes offset is %d\n", cfg_node->byte_offset);
		printf("bytes len is %d\n", cfg_node->bytes);
		printf("cfg_node's mac is 0x");
		for (i = 0; i < 6; i++){
			printf("%0x ", cfg_node->value.value_mac[i]);
		}
		printf("\n");
	}else{
		printf("bit or byte is %d\n", cfg_node->byte_or_bit);
		
		printf("cfg node's value is %0x\n", cfg_node->value.value_type);
		
	}
	return ;
	
}

void show_cfg_node(cfg_block_t *cfg_node){
	if (cfg_node == NULL){
		return;
	}else{
		printf_cfg_node(cfg_node);
		show_cfg_node(cfg_node->left);
		show_cfg_node(cfg_node->right);
	}
	return ;
	
}

void show_cfg(){
	if (cfg == NULL){
		printf("error: no cfg\n");
		return; 
	}else{
		printf("\n----------------------------show cfg begin--------\n");
		show_cfg_node(cfg);
		printf("..........................\n");
		show_cfg_node(cfg);
		printf("\n----------------------------show cfg end----------\n");
	}
	return ;
}

int main(){
//	u8 src_mac[] = "111111111111";
//	u8 dst_mac[] = "222222222222";
	//init filter
	memset(&filter, 0, sizeof(filter_t));
	printf("hostap_filter\n");
	//test add_rules
//	add_rules(WLAN_FC_TYPE_MGMT, WLAN_FC_STYPE_BEACON, src_mac, dst_mac);
//	add_rules(WLAN_FC_TYPE_MGMT, WLAN_FC_STYPE_AUTH, NULL, NULL);
//	add_rules(WLAN_FC_TYPE_CTRL, WLAN_FC_STYPE_RTS, NULL, NULL);
//	add_rules(WLAN_FC_TYPE_DATA, WLAN_FC_STYPE_DATA, NULL, NULL);
//	show_filter();

	u8 stype[] = {
		WLAN_FC_STYPE_AUTH,
		WLAN_FC_STYPE_BEACON,
		WLAN_FC_STYPE_PROBE_RESP,
	};
	u8 src_mac[6] = {
		0x00,0x11,0xd8,0x22,0xac,0xee
	};
	u8 dst_mac[6] = {
		0x00,0x15,0xe9,0x32,0x02,0xb7

	};
//	memset(dst_mac, 0xff, 6);
	//printf("%0x\n", src_mac[0]);	
//	add_rule(WLAN_FC_TYPE_MGMT, stype, sizeof(stype)/sizeof(stype[0]), NULL, NULL);
//	add_rule(WLAN_FC_TYPE_MGMT, stype, 2, src_mac, dst_mac);
	add_rule(WLAN_FC_TYPE_MGMT, stype, 3, dst_mac, src_mac);
//	add_rule(WLAN_FC_TYPE_DATA, NULL, 0, NULL, NULL);
	printf("filter src mac is %0x\n", filter.has_src_mac);
	show_new_filter();
	make_cfg();
	show_cfg();

	/* filter packet here with a filter */
	char *pcap_file = "./pcap/auth12.pcap";
	start_to_filter(pcap_file);
	return 0;

 }
#define BIT_TYPE 1
#define BYTE_TYPE 0
void dispatch_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data){
	//we use cfg to store cfg and filter pkt_data
	static num = 0;
	static pass_num = 0;
	static block_num = 0;
	cfg_block_t *current_node;
	cfg_block_t *next_node;
	int i = 0;
	u_char frame_bit_value = 0;
	char result = 0;//0 for true , -1 for false
	/*
	if ( (current_node = (cfg_block_t *)malloc(sizeof(cfg_block_t))) == NULL){
		perror("not enough memeory");
		return ;
	}
	if ( (next_node = (cfg_block_t *)malloc(sizeof(cfg_block_t))) == NULL){
		perror("not enough memory");
		return ;
	}*/
	num++;
	current_node = cfg;
	next_node = cfg;
	int loop_num = 0;
	do {
		loop_num++;
		printf("loop_num = %d\n", loop_num);

		
		current_node = next_node;
		// bit or byte case
		if (current_node->byte_or_bit == BYTE_TYPE){
		//	printf("0x%0x: 0x%0x: 0x%0x: 0x%0x: 0x%0x: 0x%0x", );
			if (memcmp(&pkt_data[current_node->byte_offset], current_node->value.value_mac, 6) ==  0) {
				result = 0;
			} else
				result = -1;
			for (i = 0; i < current_node->bytes; i++){
			printf("0x%0x: ", pkt_data[current_node->byte_offset + i]);			

			printf("0x%0x: ", current_node->value.value_mac[i]);			

		if (pkt_data[current_node->byte_offset + i] != current_node->value.value_mac[i]){
//					result = -1;
				}
			}
		}else{
			if (current_node->bit_offset == 2){//type block
				frame_bit_value = WLAN_FC_GET_TYPE(pkt_data[0]);
				if (frame_bit_value == current_node->value.value_type){
					result = 0;
				}else{
					result = -1;
				}
			}else if (current_node->bit_offset == 4){//stype block
				frame_bit_value = WLAN_FC_GET_STYPE(pkt_data[0]);
				if (frame_bit_value == current_node->value.value_type){
					result = 0;
				}else{
					result = -1;
				}
				
			}
		} // if  (current_node->byte_or_bit == BYTE_TYPE){
		if (result == 0){
			printf("next node is right son\n");
			next_node = current_node->right;
		
		}else{
			printf("next node is left son\n");
			next_node = current_node->left;
			if (next_node == NULL)
				printf("null");
			printf(".................current node's type is %d\n", current_node->type);
		}
		printf("loop end\n");
			if (next_node == NULL)
				printf("null\n");

	} while( (next_node->type != CFG_BLOCK_TYPE_TRUE) && (next_node->type != CFG_BLOCK_TYPE_FALSE)  );

	if (next_node->type == CFG_BLOCK_TYPE_TRUE){
		pass_num++;
		printf("pass\n");
	}else{
		block_num++;
		printf("blocked\n");
	}
	printf("this is  num frame %d\n", num);
	printf("pass %d\n", pass_num);
	printf("block %d\n", block_num);
}
void start_to_filter(char *pcap_file){
	pcap_t *pd = NULL;
	char errstr[PCAP_ERRBUF_SIZE + 1];
	pd = pcap_open_offline(pcap_file, errstr);
	if (pd == NULL){
		perror("pcap open file error\n");
		return ;
	}
	pcap_loop(pd, 0, dispatch_handler, NULL);

	return ;
}