embox

1
/**
2
 * @file
3
 * @brief Graph for priority NET initialization
4
 *
5
 * @date 31.10.11
6
 * @author Alexander Kalmuk
7
 */
8

9
#include <pnet/node/skbuff_match/netfilter/match_lin.h>
10
#include <pnet/core/core.h>
11
#include <pnet/core/types.h>
12
#include <pnet/core/node.h>
13
#include <lib/libds/array.h>
14
#include <embox/unit.h>
15
#include <ctype.h>
16
#include <framework/cmd/api.h>
17
#include <net/util/macaddr.h>
18
#include <arpa/inet.h>
19
#include <net/l2/ethernet.h>
20
#include <pnet/core/repo.h>
21
#include <util/member.h>
22
#include <stdio.h>
23
#include <pnet/core/graph.h>
24
#include <util/macro.h>
25

26
#define RULE_ELEMS_COUNT 6
27
#define NODES_COUNT 10
28

29
EMBOX_UNIT_INIT(init);
30

31
//TODO naming nodes as in file
32
struct __node {
33
	char *name;
34
	net_node_t node;
35
};
36

37
static struct __node nodes[NODES_COUNT];
38

39
static net_node_t get_node_by_name(char *name);
40
static char* parse_type(const char *rule);
41

42
static const char *rules[] = {
43
	#include <pnet_rules.inc>
44
};
45

46
static int form_rule(match_rule_t rule, const char *rule_elem, int num) {
47
	if ('*' == rule_elem[0]) {
48
		return 0;
49
	}
50

51
	switch (num) {
52
	case 1:
53
		macaddr_scan((unsigned char *) rule_elem,
54
				rule->skbuf->mac.ethh->h_source);
55
		break;
56
	case 2:
57
		if (strcmp("IP", rule_elem) == 0) {
58
			pnet_rule_set_pack_type(rule, ETH_P_IP);
59
		} else if (strcmp("ARP", rule_elem) == 0) {
60
			pnet_rule_set_pack_type(rule, ETH_P_ARP);
61
		}
62
		break;
63
	case 3:
64
		inet_aton(rule_elem,
65
				(struct in_addr *)&rule->skbuf->nh.iph->saddr);
66
		break;
67
	case 4:
68
		if (strcmp("ICMP", rule_elem) == 0) {
69
			pnet_rule_set_proto(rule, 0x1);
70
		} else if (strcmp("UDP", rule_elem) == 0) {
71
			pnet_rule_set_proto(rule, 0x11);
72
		}
73
		break;
74
	case 5:
75
		pnet_rule_set_src_udp_port(rule, *(uint16_t*) rule_elem);
76
		break;
77
	case 6:
78
		rule->next_node = get_node_by_name((char*)rule_elem);
79
		break;
80
	}
81

82
	return 0;
83
}
84

85
static char* parse_type(const char *rule) {
86
	char *cur;
87

88
	for(cur = (char*)rule; *cur != ':'; cur++)
89
		;
90

91
	*cur = '\0';
92
	cur++;
93

94
	return cur;
95
}
96

97
static net_node_t get_node_by_name(char *name) {
98
	for (size_t i = 0; i < NODES_COUNT; i++) {
99
		if (strcmp(nodes[i].name, name) == 0) {
100
			return nodes[i].node;
101
		}
102
	}
103

104
	return NULL;
105
}
106

107
static int init(void) {
108
	const char *rule_elem;
109
	char *tmp;
110
	int cur = 0;
111
	int node_cur = 0;
112
	size_t i = 0;
113
	match_rule_t new_rule;
114
	net_node_t src_node;
115
	net_node_t dst_node;
116
	net_node_t match_node;
117
	net_node_matcher_t match;
118
	struct pnet_graph *graph;
119

120
	new_rule = pnet_rule_alloc();
121

122
	graph = NULL;
123
	for(i = 0; i < ARRAY_SIZE(rules); i++) {
124
		rule_elem = rules[i];
125

126
		if(strncmp("TYPE", rule_elem, 4) == 0) {
127
			tmp = (char*)rule_elem;
128
			rule_elem = parse_type(rule_elem);
129
			nodes[node_cur].node = pnet_get_module(tmp + 5);
130
			nodes[node_cur].name = (char*)rule_elem;
131
			pnet_graph_add_node(graph, nodes[node_cur++].node);
132
		} else if(strncmp("GRAPH", rule_elem, 5) == 0) {
133
			graph = pnet_graph_create("lin_graph");
134
		} else if (strncmp("RULES", rule_elem, 5) == 0) {
135
			match_node =  get_node_by_name((char*)rule_elem + 6);
136
			match = (net_node_matcher_t) match_node;
137
			cur = 0;
138
		} else if(strncmp("LINK_SRC", rule_elem, 8) == 0) {
139
			src_node = get_node_by_name((char*)rule_elem + 9);
140
			rule_elem = rules[++i];
141
			dst_node = get_node_by_name((char*)rule_elem + 9);
142
			pnet_node_link(src_node, dst_node);
143
		} else {
144
			cur++;
145
			form_rule(new_rule, rule_elem, cur);
146

147
			if (cur > 0 && cur % RULE_ELEMS_COUNT == 0) {
148
				pnet_add_new_rx_rule(new_rule, match);
149
				new_rule = pnet_rule_alloc();
150
			}
151
		}
152
	}
153

154
	pnet_graph_start(graph);
155

156
	return 0;
157
}
158