Commit | Line | Data |
---|---|---|
9cfc7bd6 | 1 | /* Copyright (C) 2010-2012 B.A.T.M.A.N. contributors: |
c6c8fea2 SE |
2 | * |
3 | * Andreas Langer | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or | |
6 | * modify it under the terms of version 2 of the GNU General Public | |
7 | * License as published by the Free Software Foundation. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, but | |
10 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
12 | * General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * along with this program; if not, write to the Free Software | |
16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
17 | * 02110-1301, USA | |
c6c8fea2 SE |
18 | */ |
19 | ||
20 | #include "main.h" | |
21 | #include "unicast.h" | |
22 | #include "send.h" | |
23 | #include "soft-interface.h" | |
24 | #include "gateway_client.h" | |
25 | #include "originator.h" | |
26 | #include "hash.h" | |
27 | #include "translation-table.h" | |
28 | #include "routing.h" | |
29 | #include "hard-interface.h" | |
30 | ||
31 | ||
32 | static struct sk_buff *frag_merge_packet(struct list_head *head, | |
33 | struct frag_packet_list_entry *tfp, | |
34 | struct sk_buff *skb) | |
35 | { | |
36 | struct unicast_frag_packet *up = | |
37 | (struct unicast_frag_packet *)skb->data; | |
38 | struct sk_buff *tmp_skb; | |
39 | struct unicast_packet *unicast_packet; | |
704509b8 SE |
40 | int hdr_len = sizeof(*unicast_packet); |
41 | int uni_diff = sizeof(*up) - hdr_len; | |
c6c8fea2 SE |
42 | |
43 | /* set skb to the first part and tmp_skb to the second part */ | |
44 | if (up->flags & UNI_FRAG_HEAD) { | |
45 | tmp_skb = tfp->skb; | |
46 | } else { | |
47 | tmp_skb = skb; | |
48 | skb = tfp->skb; | |
49 | } | |
50 | ||
531c9da8 SE |
51 | if (skb_linearize(skb) < 0 || skb_linearize(tmp_skb) < 0) |
52 | goto err; | |
53 | ||
704509b8 | 54 | skb_pull(tmp_skb, sizeof(*up)); |
531c9da8 SE |
55 | if (pskb_expand_head(skb, 0, tmp_skb->len, GFP_ATOMIC) < 0) |
56 | goto err; | |
c6c8fea2 SE |
57 | |
58 | /* move free entry to end */ | |
59 | tfp->skb = NULL; | |
60 | tfp->seqno = 0; | |
61 | list_move_tail(&tfp->list, head); | |
62 | ||
63 | memcpy(skb_put(skb, tmp_skb->len), tmp_skb->data, tmp_skb->len); | |
64 | kfree_skb(tmp_skb); | |
65 | ||
66 | memmove(skb->data + uni_diff, skb->data, hdr_len); | |
40e0c4f5 | 67 | unicast_packet = (struct unicast_packet *)skb_pull(skb, uni_diff); |
76543d14 | 68 | unicast_packet->header.packet_type = BAT_UNICAST; |
c6c8fea2 SE |
69 | |
70 | return skb; | |
531c9da8 SE |
71 | |
72 | err: | |
73 | /* free buffered skb, skb will be freed later */ | |
74 | kfree_skb(tfp->skb); | |
75 | return NULL; | |
c6c8fea2 SE |
76 | } |
77 | ||
78 | static void frag_create_entry(struct list_head *head, struct sk_buff *skb) | |
79 | { | |
80 | struct frag_packet_list_entry *tfp; | |
81 | struct unicast_frag_packet *up = | |
82 | (struct unicast_frag_packet *)skb->data; | |
83 | ||
84 | /* free and oldest packets stand at the end */ | |
85 | tfp = list_entry((head)->prev, typeof(*tfp), list); | |
86 | kfree_skb(tfp->skb); | |
87 | ||
88 | tfp->seqno = ntohs(up->seqno); | |
89 | tfp->skb = skb; | |
90 | list_move(&tfp->list, head); | |
91 | return; | |
92 | } | |
93 | ||
94 | static int frag_create_buffer(struct list_head *head) | |
95 | { | |
96 | int i; | |
97 | struct frag_packet_list_entry *tfp; | |
98 | ||
99 | for (i = 0; i < FRAG_BUFFER_SIZE; i++) { | |
704509b8 | 100 | tfp = kmalloc(sizeof(*tfp), GFP_ATOMIC); |
c6c8fea2 | 101 | if (!tfp) { |
88ed1e77 | 102 | batadv_frag_list_free(head); |
c6c8fea2 SE |
103 | return -ENOMEM; |
104 | } | |
105 | tfp->skb = NULL; | |
106 | tfp->seqno = 0; | |
107 | INIT_LIST_HEAD(&tfp->list); | |
108 | list_add(&tfp->list, head); | |
109 | } | |
110 | ||
111 | return 0; | |
112 | } | |
113 | ||
114 | static struct frag_packet_list_entry *frag_search_packet(struct list_head *head, | |
747e4221 | 115 | const struct unicast_frag_packet *up) |
c6c8fea2 SE |
116 | { |
117 | struct frag_packet_list_entry *tfp; | |
118 | struct unicast_frag_packet *tmp_up = NULL; | |
119 | uint16_t search_seqno; | |
120 | ||
121 | if (up->flags & UNI_FRAG_HEAD) | |
122 | search_seqno = ntohs(up->seqno)+1; | |
123 | else | |
124 | search_seqno = ntohs(up->seqno)-1; | |
125 | ||
126 | list_for_each_entry(tfp, head, list) { | |
127 | ||
128 | if (!tfp->skb) | |
129 | continue; | |
130 | ||
131 | if (tfp->seqno == ntohs(up->seqno)) | |
132 | goto mov_tail; | |
133 | ||
134 | tmp_up = (struct unicast_frag_packet *)tfp->skb->data; | |
135 | ||
136 | if (tfp->seqno == search_seqno) { | |
137 | ||
138 | if ((tmp_up->flags & UNI_FRAG_HEAD) != | |
139 | (up->flags & UNI_FRAG_HEAD)) | |
140 | return tfp; | |
141 | else | |
142 | goto mov_tail; | |
143 | } | |
144 | } | |
145 | return NULL; | |
146 | ||
147 | mov_tail: | |
148 | list_move_tail(&tfp->list, head); | |
149 | return NULL; | |
150 | } | |
151 | ||
88ed1e77 | 152 | void batadv_frag_list_free(struct list_head *head) |
c6c8fea2 SE |
153 | { |
154 | struct frag_packet_list_entry *pf, *tmp_pf; | |
155 | ||
156 | if (!list_empty(head)) { | |
157 | ||
158 | list_for_each_entry_safe(pf, tmp_pf, head, list) { | |
159 | kfree_skb(pf->skb); | |
160 | list_del(&pf->list); | |
161 | kfree(pf); | |
162 | } | |
163 | } | |
164 | return; | |
165 | } | |
166 | ||
167 | /* frag_reassemble_skb(): | |
168 | * returns NET_RX_DROP if the operation failed - skb is left intact | |
169 | * returns NET_RX_SUCCESS if the fragment was buffered (skb_new will be NULL) | |
170 | * or the skb could be reassembled (skb_new will point to the new packet and | |
171 | * skb was freed) | |
172 | */ | |
88ed1e77 SE |
173 | int batadv_frag_reassemble_skb(struct sk_buff *skb, struct bat_priv *bat_priv, |
174 | struct sk_buff **new_skb) | |
c6c8fea2 SE |
175 | { |
176 | struct orig_node *orig_node; | |
177 | struct frag_packet_list_entry *tmp_frag_entry; | |
178 | int ret = NET_RX_DROP; | |
179 | struct unicast_frag_packet *unicast_packet = | |
180 | (struct unicast_frag_packet *)skb->data; | |
181 | ||
182 | *new_skb = NULL; | |
c6c8fea2 | 183 | |
7aadf889 ML |
184 | orig_node = orig_hash_find(bat_priv, unicast_packet->orig); |
185 | if (!orig_node) | |
c6c8fea2 | 186 | goto out; |
c6c8fea2 SE |
187 | |
188 | orig_node->last_frag_packet = jiffies; | |
189 | ||
190 | if (list_empty(&orig_node->frag_list) && | |
191 | frag_create_buffer(&orig_node->frag_list)) { | |
192 | pr_debug("couldn't create frag buffer\n"); | |
193 | goto out; | |
194 | } | |
195 | ||
196 | tmp_frag_entry = frag_search_packet(&orig_node->frag_list, | |
197 | unicast_packet); | |
198 | ||
199 | if (!tmp_frag_entry) { | |
200 | frag_create_entry(&orig_node->frag_list, skb); | |
201 | ret = NET_RX_SUCCESS; | |
202 | goto out; | |
203 | } | |
204 | ||
205 | *new_skb = frag_merge_packet(&orig_node->frag_list, tmp_frag_entry, | |
206 | skb); | |
207 | /* if not, merge failed */ | |
208 | if (*new_skb) | |
209 | ret = NET_RX_SUCCESS; | |
c6c8fea2 | 210 | |
7aadf889 ML |
211 | out: |
212 | if (orig_node) | |
7d211efc | 213 | batadv_orig_node_free_ref(orig_node); |
c6c8fea2 SE |
214 | return ret; |
215 | } | |
216 | ||
88ed1e77 SE |
217 | int batadv_frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, |
218 | struct hard_iface *hard_iface, const uint8_t dstaddr[]) | |
c6c8fea2 SE |
219 | { |
220 | struct unicast_packet tmp_uc, *unicast_packet; | |
32ae9b22 | 221 | struct hard_iface *primary_if; |
c6c8fea2 SE |
222 | struct sk_buff *frag_skb; |
223 | struct unicast_frag_packet *frag1, *frag2; | |
704509b8 SE |
224 | int uc_hdr_len = sizeof(*unicast_packet); |
225 | int ucf_hdr_len = sizeof(*frag1); | |
5c77d8bb | 226 | int data_len = skb->len - uc_hdr_len; |
32ae9b22 | 227 | int large_tail = 0, ret = NET_RX_DROP; |
c2f7f0e7 | 228 | uint16_t seqno; |
c6c8fea2 | 229 | |
32ae9b22 ML |
230 | primary_if = primary_if_get_selected(bat_priv); |
231 | if (!primary_if) | |
c6c8fea2 SE |
232 | goto dropped; |
233 | ||
ed7809d9 JJ |
234 | frag_skb = dev_alloc_skb(data_len - (data_len / 2) + ucf_hdr_len); |
235 | if (!frag_skb) | |
236 | goto dropped; | |
5c77d8bb | 237 | skb_reserve(frag_skb, ucf_hdr_len); |
c6c8fea2 | 238 | |
40e0c4f5 | 239 | unicast_packet = (struct unicast_packet *)skb->data; |
c6c8fea2 | 240 | memcpy(&tmp_uc, unicast_packet, uc_hdr_len); |
5c77d8bb | 241 | skb_split(skb, frag_skb, data_len / 2 + uc_hdr_len); |
c6c8fea2 | 242 | |
04b482a2 SE |
243 | if (batadv_skb_head_push(skb, ucf_hdr_len - uc_hdr_len) < 0 || |
244 | batadv_skb_head_push(frag_skb, ucf_hdr_len) < 0) | |
c6c8fea2 SE |
245 | goto drop_frag; |
246 | ||
247 | frag1 = (struct unicast_frag_packet *)skb->data; | |
248 | frag2 = (struct unicast_frag_packet *)frag_skb->data; | |
249 | ||
704509b8 | 250 | memcpy(frag1, &tmp_uc, sizeof(tmp_uc)); |
c6c8fea2 | 251 | |
76543d14 SE |
252 | frag1->header.ttl--; |
253 | frag1->header.version = COMPAT_VERSION; | |
254 | frag1->header.packet_type = BAT_UNICAST_FRAG; | |
c6c8fea2 | 255 | |
32ae9b22 | 256 | memcpy(frag1->orig, primary_if->net_dev->dev_addr, ETH_ALEN); |
704509b8 | 257 | memcpy(frag2, frag1, sizeof(*frag2)); |
c6c8fea2 | 258 | |
ae361ce1 SE |
259 | if (data_len & 1) |
260 | large_tail = UNI_FRAG_LARGETAIL; | |
261 | ||
262 | frag1->flags = UNI_FRAG_HEAD | large_tail; | |
263 | frag2->flags = large_tail; | |
c6c8fea2 | 264 | |
e6c10f43 | 265 | seqno = atomic_add_return(2, &hard_iface->frag_seqno); |
c2f7f0e7 SE |
266 | frag1->seqno = htons(seqno - 1); |
267 | frag2->seqno = htons(seqno); | |
c6c8fea2 | 268 | |
9455e34c SE |
269 | batadv_send_skb_packet(skb, hard_iface, dstaddr); |
270 | batadv_send_skb_packet(frag_skb, hard_iface, dstaddr); | |
32ae9b22 ML |
271 | ret = NET_RX_SUCCESS; |
272 | goto out; | |
c6c8fea2 SE |
273 | |
274 | drop_frag: | |
275 | kfree_skb(frag_skb); | |
276 | dropped: | |
277 | kfree_skb(skb); | |
32ae9b22 ML |
278 | out: |
279 | if (primary_if) | |
280 | hardif_free_ref(primary_if); | |
281 | return ret; | |
c6c8fea2 SE |
282 | } |
283 | ||
88ed1e77 | 284 | int batadv_unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv) |
c6c8fea2 SE |
285 | { |
286 | struct ethhdr *ethhdr = (struct ethhdr *)skb->data; | |
287 | struct unicast_packet *unicast_packet; | |
7b36e8ee | 288 | struct orig_node *orig_node; |
44524fcd | 289 | struct neigh_node *neigh_node; |
c6c8fea2 | 290 | int data_len = skb->len; |
44524fcd | 291 | int ret = 1; |
c6c8fea2 SE |
292 | |
293 | /* get routing information */ | |
43c70ad5 | 294 | if (is_multicast_ether_addr(ethhdr->h_dest)) { |
7cf06bc6 | 295 | orig_node = batadv_gw_get_selected_orig(bat_priv); |
43c70ad5 | 296 | if (orig_node) |
44524fcd ML |
297 | goto find_router; |
298 | } | |
c6c8fea2 | 299 | |
3d393e47 | 300 | /* check for tt host - increases orig_node refcount. |
9cfc7bd6 SE |
301 | * returns NULL in case of AP isolation |
302 | */ | |
08c36d3e SE |
303 | orig_node = batadv_transtable_search(bat_priv, ethhdr->h_source, |
304 | ethhdr->h_dest); | |
44524fcd | 305 | find_router: |
9cfc7bd6 | 306 | /* find_router(): |
d0072609 ML |
307 | * - if orig_node is NULL it returns NULL |
308 | * - increases neigh_nodes refcount if found. | |
309 | */ | |
30d3c511 | 310 | neigh_node = batadv_find_router(bat_priv, orig_node, NULL); |
44524fcd | 311 | if (!neigh_node) |
d0072609 | 312 | goto out; |
c6c8fea2 | 313 | |
04b482a2 | 314 | if (batadv_skb_head_push(skb, sizeof(*unicast_packet)) < 0) |
d0072609 | 315 | goto out; |
c6c8fea2 SE |
316 | |
317 | unicast_packet = (struct unicast_packet *)skb->data; | |
318 | ||
76543d14 | 319 | unicast_packet->header.version = COMPAT_VERSION; |
c6c8fea2 | 320 | /* batman packet type: unicast */ |
76543d14 | 321 | unicast_packet->header.packet_type = BAT_UNICAST; |
c6c8fea2 | 322 | /* set unicast ttl */ |
76543d14 | 323 | unicast_packet->header.ttl = TTL; |
c6c8fea2 SE |
324 | /* copy the destination for faster routing */ |
325 | memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN); | |
a73105b8 AQ |
326 | /* set the destination tt version number */ |
327 | unicast_packet->ttvn = | |
328 | (uint8_t)atomic_read(&orig_node->last_ttvn); | |
c6c8fea2 | 329 | |
3275e7cc AQ |
330 | /* inform the destination node that we are still missing a correct route |
331 | * for this client. The destination will receive this packet and will | |
332 | * try to reroute it because the ttvn contained in the header is less | |
333 | * than the current one | |
334 | */ | |
08c36d3e | 335 | if (batadv_tt_global_client_is_roaming(bat_priv, ethhdr->h_dest)) |
3275e7cc AQ |
336 | unicast_packet->ttvn = unicast_packet->ttvn - 1; |
337 | ||
c6c8fea2 | 338 | if (atomic_read(&bat_priv->fragmentation) && |
704509b8 | 339 | data_len + sizeof(*unicast_packet) > |
d0072609 | 340 | neigh_node->if_incoming->net_dev->mtu) { |
c6c8fea2 | 341 | /* send frag skb decreases ttl */ |
76543d14 | 342 | unicast_packet->header.ttl++; |
88ed1e77 SE |
343 | ret = batadv_frag_send_skb(skb, bat_priv, |
344 | neigh_node->if_incoming, | |
345 | neigh_node->addr); | |
44524fcd | 346 | goto out; |
c6c8fea2 | 347 | } |
c6c8fea2 | 348 | |
9455e34c | 349 | batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); |
44524fcd ML |
350 | ret = 0; |
351 | goto out; | |
c6c8fea2 | 352 | |
44524fcd ML |
353 | out: |
354 | if (neigh_node) | |
7d211efc | 355 | batadv_neigh_node_free_ref(neigh_node); |
44524fcd | 356 | if (orig_node) |
7d211efc | 357 | batadv_orig_node_free_ref(orig_node); |
44524fcd ML |
358 | if (ret == 1) |
359 | kfree_skb(skb); | |
360 | return ret; | |
c6c8fea2 | 361 | } |