This source file includes following definitions.
- skb_queue_empty
- skb_peek
- skb_queue_len
- skb_queue_head_init
- __skb_queue_head
- skb_queue_head
- __skb_queue_tail
- skb_queue_tail
- __skb_dequeue
- skb_dequeue
- __skb_insert
- skb_insert
- skb_append
- __skb_unlink
- skb_unlink
- skb_put
- skb_push
- skb_pull
- skb_headroom
- skb_tailroom
- skb_reserve
- skb_trim
1
2
3
4
5
6
7
8
9
10
11
12
13
14 #ifndef _LINUX_SKBUFF_H
15 #define _LINUX_SKBUFF_H
16 #include <linux/malloc.h>
17 #include <linux/wait.h>
18 #include <linux/time.h>
19 #include <linux/config.h>
20
21 #include <asm/atomic.h>
22
23 #define CONFIG_SKB_CHECK 0
24
25 #define HAVE_ALLOC_SKB
26 #define HAVE_ALIGNABLE_SKB
27
28
29 #define FREE_READ 1
30 #define FREE_WRITE 0
31
32 #define CHECKSUM_NONE 0
33 #define CHECKSUM_HW 1
34 #define CHECKSUM_UNNECESSARY 2
35
36 struct sk_buff_head
37 {
38 struct sk_buff * next;
39 struct sk_buff * prev;
40 __u32 qlen;
41
42 #if CONFIG_SKB_CHECK
43 int magic_debug_cookie;
44 #endif
45 };
46
47
48 struct sk_buff
49 {
50 struct sk_buff * next;
51 struct sk_buff * prev;
52 struct sk_buff_head * list;
53 #if CONFIG_SKB_CHECK
54 int magic_debug_cookie;
55 #endif
56 struct sk_buff *link3;
57 struct sock *sk;
58 unsigned long when;
59 struct timeval stamp;
60 struct device *dev;
61 union
62 {
63 struct tcphdr *th;
64 struct ethhdr *eth;
65 struct iphdr *iph;
66 struct udphdr *uh;
67 unsigned char *raw;
68
69 void *filp;
70 } h;
71
72 union
73 {
74
75 unsigned char *raw;
76 struct ethhdr *ethernet;
77 } mac;
78
79 struct iphdr *ip_hdr;
80 unsigned long len;
81 unsigned long csum;
82 __u32 saddr;
83 __u32 daddr;
84 __u32 raddr;
85 __u32 seq;
86 __u32 end_seq;
87 __u32 ack_seq;
88 unsigned char proto_priv[16];
89 volatile char acked,
90 used,
91 free,
92 arp;
93 unsigned char tries,
94 lock,
95 localroute,
96 pkt_type,
97 pkt_bridged,
98 ip_summed;
99 #define PACKET_HOST 0
100 #define PACKET_BROADCAST 1
101 #define PACKET_MULTICAST 2
102 #define PACKET_OTHERHOST 3
103 unsigned short users;
104 unsigned short protocol;
105 unsigned short truesize;
106
107 atomic_t count;
108 struct sk_buff *data_skb;
109 unsigned char *head;
110 unsigned char *data;
111 unsigned char *tail;
112 unsigned char *end;
113 void (*destructor)(struct sk_buff *this);
114 };
115
116 #ifdef CONFIG_SKB_LARGE
117 #define SK_WMEM_MAX 65535
118 #define SK_RMEM_MAX 65535
119 #else
120 #define SK_WMEM_MAX 32767
121 #define SK_RMEM_MAX 32767
122 #endif
123
124 #if CONFIG_SKB_CHECK
125 #define SK_FREED_SKB 0x0DE2C0DE
126 #define SK_GOOD_SKB 0xDEC0DED1
127 #define SK_HEAD_SKB 0x12231298
128 #endif
129
130 #ifdef __KERNEL__
131
132
133
134
135 #include <asm/system.h>
136
137 #if 0
138 extern void print_skb(struct sk_buff *);
139 #endif
140 extern void kfree_skb(struct sk_buff *skb, int rw);
141 extern void skb_queue_head_init(struct sk_buff_head *list);
142 extern void skb_queue_head(struct sk_buff_head *list,struct sk_buff *buf);
143 extern void skb_queue_tail(struct sk_buff_head *list,struct sk_buff *buf);
144 extern struct sk_buff * skb_dequeue(struct sk_buff_head *list);
145 extern void skb_insert(struct sk_buff *old,struct sk_buff *newsk);
146 extern void skb_append(struct sk_buff *old,struct sk_buff *newsk);
147 extern void skb_unlink(struct sk_buff *buf);
148 extern __u32 skb_queue_len(struct sk_buff_head *list);
149 extern struct sk_buff * skb_peek_copy(struct sk_buff_head *list);
150 extern struct sk_buff * alloc_skb(unsigned int size, int priority);
151 extern struct sk_buff * dev_alloc_skb(unsigned int size);
152 extern void kfree_skbmem(struct sk_buff *skb);
153 extern struct sk_buff * skb_clone(struct sk_buff *skb, int priority);
154 extern struct sk_buff * skb_copy(struct sk_buff *skb, int priority);
155 extern void skb_device_lock(struct sk_buff *skb);
156 extern void skb_device_unlock(struct sk_buff *skb);
157 extern void dev_kfree_skb(struct sk_buff *skb, int mode);
158 extern int skb_device_locked(struct sk_buff *skb);
159 extern unsigned char * skb_put(struct sk_buff *skb, int len);
160 extern unsigned char * skb_push(struct sk_buff *skb, int len);
161 extern unsigned char * skb_pull(struct sk_buff *skb, int len);
162 extern int skb_headroom(struct sk_buff *skb);
163 extern int skb_tailroom(struct sk_buff *skb);
164 extern void skb_reserve(struct sk_buff *skb, int len);
165 extern void skb_trim(struct sk_buff *skb, int len);
166
167 extern __inline__ int skb_queue_empty(struct sk_buff_head *list)
168 {
169 return (list->next == (struct sk_buff *) list);
170 }
171
172
173
174
175
176
177
178 extern __inline__ struct sk_buff *skb_peek(struct sk_buff_head *list_)
179 {
180 struct sk_buff *list = ((struct sk_buff *)list_)->next;
181 if (list == (struct sk_buff *)list_)
182 list = NULL;
183 return list;
184 }
185
186
187
188
189
190 extern __inline__ __u32 skb_queue_len(struct sk_buff_head *list_)
191 {
192 return(list_->qlen);
193 }
194
195 #if CONFIG_SKB_CHECK
196 extern int skb_check(struct sk_buff *skb,int,int, char *);
197 #define IS_SKB(skb) skb_check((skb), 0, __LINE__,__FILE__)
198 #define IS_SKB_HEAD(skb) skb_check((skb), 1, __LINE__,__FILE__)
199 #else
200 #define IS_SKB(skb)
201 #define IS_SKB_HEAD(skb)
202
203 extern __inline__ void skb_queue_head_init(struct sk_buff_head *list)
204 {
205 list->prev = (struct sk_buff *)list;
206 list->next = (struct sk_buff *)list;
207 list->qlen = 0;
208 }
209
210
211
212
213
214
215
216
217 extern __inline__ void __skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)
218 {
219 struct sk_buff *prev, *next;
220
221 newsk->list = list;
222 list->qlen++;
223 prev = (struct sk_buff *)list;
224 next = prev->next;
225 newsk->next = next;
226 newsk->prev = prev;
227 next->prev = newsk;
228 prev->next = newsk;
229 }
230
231 extern __inline__ void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)
232 {
233 unsigned long flags;
234
235 save_flags(flags);
236 cli();
237 __skb_queue_head(list, newsk);
238 restore_flags(flags);
239 }
240
241
242
243
244
245 extern __inline__ void __skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)
246 {
247 struct sk_buff *prev, *next;
248
249 newsk->list = list;
250 list->qlen++;
251 next = (struct sk_buff *)list;
252 prev = next->prev;
253 newsk->next = next;
254 newsk->prev = prev;
255 next->prev = newsk;
256 prev->next = newsk;
257 }
258
259 extern __inline__ void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)
260 {
261 unsigned long flags;
262
263 save_flags(flags);
264 cli();
265 __skb_queue_tail(list, newsk);
266 restore_flags(flags);
267 }
268
269
270
271
272
273 extern __inline__ struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
274 {
275 struct sk_buff *next, *prev, *result;
276
277 prev = (struct sk_buff *) list;
278 next = prev->next;
279 result = NULL;
280 if (next != prev) {
281 result = next;
282 next = next->next;
283 list->qlen--;
284 next->prev = prev;
285 prev->next = next;
286 result->next = NULL;
287 result->prev = NULL;
288 result->list = NULL;
289 }
290 return result;
291 }
292
293 extern __inline__ struct sk_buff *skb_dequeue(struct sk_buff_head *list)
294 {
295 long flags;
296 struct sk_buff *result;
297
298 save_flags(flags);
299 cli();
300 result = __skb_dequeue(list);
301 restore_flags(flags);
302 return result;
303 }
304
305
306
307
308
309 extern __inline__ void __skb_insert(struct sk_buff *newsk,
310 struct sk_buff * prev, struct sk_buff *next,
311 struct sk_buff_head * list)
312 {
313 newsk->next = next;
314 newsk->prev = prev;
315 next->prev = newsk;
316 prev->next = newsk;
317 newsk->list = list;
318 list->qlen++;
319 }
320
321
322
323
324 extern __inline__ void skb_insert(struct sk_buff *old, struct sk_buff *newsk)
325 {
326 unsigned long flags;
327
328 save_flags(flags);
329 cli();
330 __skb_insert(newsk, old->prev, old, old->list);
331 restore_flags(flags);
332 }
333
334
335
336
337
338 extern __inline__ void skb_append(struct sk_buff *old, struct sk_buff *newsk)
339 {
340 unsigned long flags;
341
342 save_flags(flags);
343 cli();
344 __skb_insert(newsk, old, old->next, old->list);
345 restore_flags(flags);
346 }
347
348
349
350
351
352 extern __inline__ void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
353 {
354 struct sk_buff * next, * prev;
355
356 list->qlen--;
357 next = skb->next;
358 prev = skb->prev;
359 skb->next = NULL;
360 skb->prev = NULL;
361 skb->list = NULL;
362 next->prev = prev;
363 prev->next = next;
364 }
365
366
367
368
369
370
371
372
373 extern __inline__ void skb_unlink(struct sk_buff *skb)
374 {
375 unsigned long flags;
376
377 save_flags(flags);
378 cli();
379 if(skb->list)
380 __skb_unlink(skb, skb->list);
381 restore_flags(flags);
382 }
383
384
385
386
387
388 extern __inline__ unsigned char *skb_put(struct sk_buff *skb, int len)
389 {
390 unsigned char *tmp=skb->tail;
391 skb->tail+=len;
392 skb->len+=len;
393 if(skb->tail>skb->end)
394 panic("skput:over: %p:%d", __builtin_return_address(0),len);
395 return tmp;
396 }
397
398 extern __inline__ unsigned char *skb_push(struct sk_buff *skb, int len)
399 {
400 skb->data-=len;
401 skb->len+=len;
402 if(skb->data<skb->head)
403 panic("skpush:under: %p:%d", __builtin_return_address(0),len);
404 return skb->data;
405 }
406
407 extern __inline__ unsigned char * skb_pull(struct sk_buff *skb, int len)
408 {
409 if(len > skb->len)
410 return NULL;
411 skb->data+=len;
412 skb->len-=len;
413 return skb->data;
414 }
415
416 extern __inline__ int skb_headroom(struct sk_buff *skb)
417 {
418 return skb->data-skb->head;
419 }
420
421 extern __inline__ int skb_tailroom(struct sk_buff *skb)
422 {
423 return skb->end-skb->tail;
424 }
425
426 extern __inline__ void skb_reserve(struct sk_buff *skb, int len)
427 {
428 skb->data+=len;
429 skb->tail+=len;
430 }
431
432 extern __inline__ void skb_trim(struct sk_buff *skb, int len)
433 {
434 if(skb->len>len)
435 {
436 skb->len=len;
437 skb->tail=skb->data+len;
438 }
439 }
440
441 #endif
442
443 extern struct sk_buff * skb_recv_datagram(struct sock *sk,unsigned flags,int noblock, int *err);
444 extern int datagram_select(struct sock *sk, int sel_type, select_table *wait);
445 extern void skb_copy_datagram(struct sk_buff *from, int offset, char *to,int size);
446 extern void skb_copy_datagram_iovec(struct sk_buff *from, int offset, struct iovec *to,int size);
447 extern void skb_free_datagram(struct sock * sk, struct sk_buff *skb);
448
449 #endif
450 #endif