2 * Copyright (C) 2010 B.A.T.M.A.N. contributors:
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 #include "soft-interface.h"
26 #include "gateway_client.h"
27 #include "originator.h"
29 #include "translation-table.h"
31 #include "hard-interface.h"
34 static struct sk_buff
*frag_merge_packet(struct list_head
*head
,
35 struct frag_packet_list_entry
*tfp
,
38 struct unicast_frag_packet
*up
=
39 (struct unicast_frag_packet
*)skb
->data
;
40 struct sk_buff
*tmp_skb
;
41 struct unicast_packet
*unicast_packet
;
42 int hdr_len
= sizeof(struct unicast_packet
),
43 uni_diff
= sizeof(struct unicast_frag_packet
) - hdr_len
;
45 /* set skb to the first part and tmp_skb to the second part */
46 if (up
->flags
& UNI_FRAG_HEAD
) {
53 skb_pull(tmp_skb
, sizeof(struct unicast_frag_packet
));
54 if (pskb_expand_head(skb
, 0, tmp_skb
->len
, GFP_ATOMIC
) < 0) {
55 /* free buffered skb, skb will be freed later */
60 /* move free entry to end */
63 list_move_tail(&tfp
->list
, head
);
65 memcpy(skb_put(skb
, tmp_skb
->len
), tmp_skb
->data
, tmp_skb
->len
);
68 memmove(skb
->data
+ uni_diff
, skb
->data
, hdr_len
);
69 unicast_packet
= (struct unicast_packet
*) skb_pull(skb
, uni_diff
);
70 unicast_packet
->packet_type
= BAT_UNICAST
;
75 static void frag_create_entry(struct list_head
*head
, struct sk_buff
*skb
)
77 struct frag_packet_list_entry
*tfp
;
78 struct unicast_frag_packet
*up
=
79 (struct unicast_frag_packet
*)skb
->data
;
81 /* free and oldest packets stand at the end */
82 tfp
= list_entry((head
)->prev
, typeof(*tfp
), list
);
85 tfp
->seqno
= ntohs(up
->seqno
);
87 list_move(&tfp
->list
, head
);
91 static int frag_create_buffer(struct list_head
*head
)
94 struct frag_packet_list_entry
*tfp
;
96 for (i
= 0; i
< FRAG_BUFFER_SIZE
; i
++) {
97 tfp
= kmalloc(sizeof(struct frag_packet_list_entry
),
100 frag_list_free(head
);
105 INIT_LIST_HEAD(&tfp
->list
);
106 list_add(&tfp
->list
, head
);
112 static struct frag_packet_list_entry
*frag_search_packet(struct list_head
*head
,
113 struct unicast_frag_packet
*up
)
115 struct frag_packet_list_entry
*tfp
;
116 struct unicast_frag_packet
*tmp_up
= NULL
;
117 uint16_t search_seqno
;
119 if (up
->flags
& UNI_FRAG_HEAD
)
120 search_seqno
= ntohs(up
->seqno
)+1;
122 search_seqno
= ntohs(up
->seqno
)-1;
124 list_for_each_entry(tfp
, head
, list
) {
129 if (tfp
->seqno
== ntohs(up
->seqno
))
132 tmp_up
= (struct unicast_frag_packet
*)tfp
->skb
->data
;
134 if (tfp
->seqno
== search_seqno
) {
136 if ((tmp_up
->flags
& UNI_FRAG_HEAD
) !=
137 (up
->flags
& UNI_FRAG_HEAD
))
146 list_move_tail(&tfp
->list
, head
);
150 void frag_list_free(struct list_head
*head
)
152 struct frag_packet_list_entry
*pf
, *tmp_pf
;
154 if (!list_empty(head
)) {
156 list_for_each_entry_safe(pf
, tmp_pf
, head
, list
) {
165 /* frag_reassemble_skb():
166 * returns NET_RX_DROP if the operation failed - skb is left intact
167 * returns NET_RX_SUCCESS if the fragment was buffered (skb_new will be NULL)
168 * or the skb could be reassembled (skb_new will point to the new packet and
171 int frag_reassemble_skb(struct sk_buff
*skb
, struct bat_priv
*bat_priv
,
172 struct sk_buff
**new_skb
)
174 struct orig_node
*orig_node
;
175 struct frag_packet_list_entry
*tmp_frag_entry
;
176 int ret
= NET_RX_DROP
;
177 struct unicast_frag_packet
*unicast_packet
=
178 (struct unicast_frag_packet
*)skb
->data
;
181 spin_lock_bh(&bat_priv
->orig_hash_lock
);
182 orig_node
= ((struct orig_node
*)
183 hash_find(bat_priv
->orig_hash
, compare_orig
, choose_orig
,
184 unicast_packet
->orig
));
187 pr_debug("couldn't find originator in orig_hash\n");
191 orig_node
->last_frag_packet
= jiffies
;
193 if (list_empty(&orig_node
->frag_list
) &&
194 frag_create_buffer(&orig_node
->frag_list
)) {
195 pr_debug("couldn't create frag buffer\n");
199 tmp_frag_entry
= frag_search_packet(&orig_node
->frag_list
,
202 if (!tmp_frag_entry
) {
203 frag_create_entry(&orig_node
->frag_list
, skb
);
204 ret
= NET_RX_SUCCESS
;
208 *new_skb
= frag_merge_packet(&orig_node
->frag_list
, tmp_frag_entry
,
210 /* if not, merge failed */
212 ret
= NET_RX_SUCCESS
;
214 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
219 int frag_send_skb(struct sk_buff
*skb
, struct bat_priv
*bat_priv
,
220 struct batman_if
*batman_if
, uint8_t dstaddr
[])
222 struct unicast_packet tmp_uc
, *unicast_packet
;
223 struct sk_buff
*frag_skb
;
224 struct unicast_frag_packet
*frag1
, *frag2
;
225 int uc_hdr_len
= sizeof(struct unicast_packet
);
226 int ucf_hdr_len
= sizeof(struct unicast_frag_packet
);
227 int data_len
= skb
->len
;
229 if (!bat_priv
->primary_if
)
232 unicast_packet
= (struct unicast_packet
*) skb
->data
;
234 memcpy(&tmp_uc
, unicast_packet
, uc_hdr_len
);
235 frag_skb
= dev_alloc_skb(data_len
- (data_len
/ 2) + ucf_hdr_len
);
236 skb_split(skb
, frag_skb
, data_len
/ 2);
238 if (my_skb_head_push(skb
, ucf_hdr_len
- uc_hdr_len
) < 0 ||
239 my_skb_head_push(frag_skb
, ucf_hdr_len
) < 0)
242 frag1
= (struct unicast_frag_packet
*)skb
->data
;
243 frag2
= (struct unicast_frag_packet
*)frag_skb
->data
;
245 memcpy(frag1
, &tmp_uc
, sizeof(struct unicast_packet
));
248 frag1
->version
= COMPAT_VERSION
;
249 frag1
->packet_type
= BAT_UNICAST_FRAG
;
251 memcpy(frag1
->orig
, bat_priv
->primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
252 memcpy(frag2
, frag1
, sizeof(struct unicast_frag_packet
));
254 frag1
->flags
|= UNI_FRAG_HEAD
;
255 frag2
->flags
&= ~UNI_FRAG_HEAD
;
257 frag1
->seqno
= htons((uint16_t)atomic_inc_return(
258 &batman_if
->frag_seqno
));
259 frag2
->seqno
= htons((uint16_t)atomic_inc_return(
260 &batman_if
->frag_seqno
));
262 send_skb_packet(skb
, batman_if
, dstaddr
);
263 send_skb_packet(frag_skb
, batman_if
, dstaddr
);
264 return NET_RX_SUCCESS
;
273 int unicast_send_skb(struct sk_buff
*skb
, struct bat_priv
*bat_priv
)
275 struct ethhdr
*ethhdr
= (struct ethhdr
*)skb
->data
;
276 struct unicast_packet
*unicast_packet
;
277 struct orig_node
*orig_node
;
278 struct batman_if
*batman_if
;
279 struct neigh_node
*router
;
280 int data_len
= skb
->len
;
283 spin_lock_bh(&bat_priv
->orig_hash_lock
);
285 /* get routing information */
286 if (is_multicast_ether_addr(ethhdr
->h_dest
))
287 orig_node
= (struct orig_node
*)gw_get_selected(bat_priv
);
289 orig_node
= ((struct orig_node
*)hash_find(bat_priv
->orig_hash
,
294 /* check for hna host */
296 orig_node
= transtable_search(bat_priv
, ethhdr
->h_dest
);
298 router
= find_router(bat_priv
, orig_node
, NULL
);
303 /* don't lock while sending the packets ... we therefore
304 * copy the required data before sending */
306 batman_if
= router
->if_incoming
;
307 memcpy(dstaddr
, router
->addr
, ETH_ALEN
);
309 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
311 if (batman_if
->if_status
!= IF_ACTIVE
)
314 if (my_skb_head_push(skb
, sizeof(struct unicast_packet
)) < 0)
317 unicast_packet
= (struct unicast_packet
*)skb
->data
;
319 unicast_packet
->version
= COMPAT_VERSION
;
320 /* batman packet type: unicast */
321 unicast_packet
->packet_type
= BAT_UNICAST
;
322 /* set unicast ttl */
323 unicast_packet
->ttl
= TTL
;
324 /* copy the destination for faster routing */
325 memcpy(unicast_packet
->dest
, orig_node
->orig
, ETH_ALEN
);
327 if (atomic_read(&bat_priv
->fragmentation
) &&
328 data_len
+ sizeof(struct unicast_packet
) >
329 batman_if
->net_dev
->mtu
) {
330 /* send frag skb decreases ttl */
331 unicast_packet
->ttl
++;
332 return frag_send_skb(skb
, bat_priv
, batman_if
,
335 send_skb_packet(skb
, batman_if
, dstaddr
);
339 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
This page took 0.037873 seconds and 6 git commands to generate.