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 * volatile 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 ip_summed;
98 #define PACKET_HOST 0
99 #define PACKET_BROADCAST 1
100 #define PACKET_MULTICAST 2
101 #define PACKET_OTHERHOST 3
102 unsigned short users;
103 unsigned short protocol;
104 unsigned short truesize;
105
106 atomic_t count;
107 struct sk_buff *data_skb;
108 unsigned char *head;
109 unsigned char *data;
110 unsigned char *tail;
111 unsigned char *end;
112 void (*destructor)(struct sk_buff *this);
113 };
114
115 #ifdef CONFIG_SKB_LARGE
116 #define SK_WMEM_MAX 65535
117 #define SK_RMEM_MAX 65535
118 #else
119 #define SK_WMEM_MAX 32767
120 #define SK_RMEM_MAX 32767
121 #endif
122
123 #if CONFIG_SKB_CHECK
124 #define SK_FREED_SKB 0x0DE2C0DE
125 #define SK_GOOD_SKB 0xDEC0DED1
126 #define SK_HEAD_SKB 0x12231298
127 #endif
128
129 #ifdef __KERNEL__
130
131
132
133
134 #include <asm/system.h>
135
136 #if 0
137 extern void print_skb(struct sk_buff *);
138 #endif
139 extern void kfree_skb(struct sk_buff *skb, int rw);
140 extern void skb_queue_head_init(struct sk_buff_head *list);
141 extern void skb_queue_head(struct sk_buff_head *list,struct sk_buff *buf);
142 extern void skb_queue_tail(struct sk_buff_head *list,struct sk_buff *buf);
143 extern struct sk_buff * skb_dequeue(struct sk_buff_head *list);
144 extern void skb_insert(struct sk_buff *old,struct sk_buff *newsk);
145 extern void skb_append(struct sk_buff *old,struct sk_buff *newsk);
146 extern void skb_unlink(struct sk_buff *buf);
147 extern __u32 skb_queue_len(struct sk_buff_head *list);
148 extern struct sk_buff * skb_peek_copy(struct sk_buff_head *list);
149 extern struct sk_buff * alloc_skb(unsigned int size, int priority);
150 extern struct sk_buff * dev_alloc_skb(unsigned int size);
151 extern void kfree_skbmem(struct sk_buff *skb);
152 extern struct sk_buff * skb_clone(struct sk_buff *skb, int priority);
153 extern struct sk_buff * skb_copy(struct sk_buff *skb, int priority);
154 extern void skb_device_lock(struct sk_buff *skb);
155 extern void skb_device_unlock(struct sk_buff *skb);
156 extern void dev_kfree_skb(struct sk_buff *skb, int mode);
157 extern int skb_device_locked(struct sk_buff *skb);
158 extern unsigned char * skb_put(struct sk_buff *skb, int len);
159 extern unsigned char * skb_push(struct sk_buff *skb, int len);
160 extern unsigned char * skb_pull(struct sk_buff *skb, int len);
161 extern int skb_headroom(struct sk_buff *skb);
162 extern int skb_tailroom(struct sk_buff *skb);
163 extern void skb_reserve(struct sk_buff *skb, int len);
164 extern void skb_trim(struct sk_buff *skb, int len);
165
166 extern __inline__ int skb_queue_empty(struct sk_buff_head *list)
167 {
168 return (list->next == (struct sk_buff *) list);
169 }
170
171
172
173
174
175
176
177 extern __inline__ struct sk_buff *skb_peek(struct sk_buff_head *list_)
178 {
179 struct sk_buff *list = ((struct sk_buff *)list_)->next;
180 if (list == (struct sk_buff *)list_)
181 list = NULL;
182 return list;
183 }
184
185
186
187
188
189 extern __inline__ __u32 skb_queue_len(struct sk_buff_head *list_)
190 {
191 return(list_->qlen);
192 }
193
194 #if CONFIG_SKB_CHECK
195 extern int skb_check(struct sk_buff *skb,int,int, char *);
196 #define IS_SKB(skb) skb_check((skb), 0, __LINE__,__FILE__)
197 #define IS_SKB_HEAD(skb) skb_check((skb), 1, __LINE__,__FILE__)
198 #else
199 #define IS_SKB(skb)
200 #define IS_SKB_HEAD(skb)
201
202 extern __inline__ void skb_queue_head_init(struct sk_buff_head *list)
203 {
204 list->prev = (struct sk_buff *)list;
205 list->next = (struct sk_buff *)list;
206 list->qlen = 0;
207 }
208
209
210
211
212
213
214
215
216 extern __inline__ void __skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)
217 {
218 struct sk_buff *prev, *next;
219
220 newsk->list = list;
221 list->qlen++;
222 prev = (struct sk_buff *)list;
223 next = prev->next;
224 newsk->next = next;
225 newsk->prev = prev;
226 next->prev = newsk;
227 prev->next = newsk;
228 }
229
230 extern __inline__ void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)
231 {
232 unsigned long flags;
233
234 save_flags(flags);
235 cli();
236 __skb_queue_head(list, newsk);
237 restore_flags(flags);
238 }
239
240
241
242
243
244 extern __inline__ void __skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)
245 {
246 struct sk_buff *prev, *next;
247
248 newsk->list = list;
249 list->qlen++;
250 next = (struct sk_buff *)list;
251 prev = next->prev;
252 newsk->next = next;
253 newsk->prev = prev;
254 next->prev = newsk;
255 prev->next = newsk;
256 }
257
258 extern __inline__ void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)
259 {
260 unsigned long flags;
261
262 save_flags(flags);
263 cli();
264 __skb_queue_tail(list, newsk);
265 restore_flags(flags);
266 }
267
268
269
270
271
272 extern __inline__ struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
273 {
274 struct sk_buff *next, *prev, *result;
275
276 prev = (struct sk_buff *) list;
277 next = prev->next;
278 result = NULL;
279 if (next != prev) {
280 result = next;
281 next = next->next;
282 list->qlen--;
283 next->prev = prev;
284 prev->next = next;
285 result->next = NULL;
286 result->prev = NULL;
287 result->list = NULL;
288 }
289 return result;
290 }
291
292 extern __inline__ struct sk_buff *skb_dequeue(struct sk_buff_head *list)
293 {
294 long flags;
295 struct sk_buff *result;
296
297 save_flags(flags);
298 cli();
299 result = __skb_dequeue(list);
300 restore_flags(flags);
301 return result;
302 }
303
304
305
306
307
308 extern __inline__ void __skb_insert(struct sk_buff *newsk,
309 struct sk_buff * prev, struct sk_buff *next,
310 struct sk_buff_head * list)
311 {
312 newsk->next = next;
313 newsk->prev = prev;
314 next->prev = newsk;
315 prev->next = newsk;
316 newsk->list = list;
317 list->qlen++;
318 }
319
320
321
322
323 extern __inline__ void skb_insert(struct sk_buff *old, struct sk_buff *newsk)
324 {
325 unsigned long flags;
326
327 save_flags(flags);
328 cli();
329 __skb_insert(newsk, old->prev, old, old->list);
330 restore_flags(flags);
331 }
332
333
334
335
336
337 extern __inline__ void skb_append(struct sk_buff *old, struct sk_buff *newsk)
338 {
339 unsigned long flags;
340
341 save_flags(flags);
342 cli();
343 __skb_insert(newsk, old, old->next, old->list);
344 restore_flags(flags);
345 }
346
347
348
349
350
351 extern __inline__ void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
352 {
353 struct sk_buff * next, * prev;
354
355 list->qlen--;
356 next = skb->next;
357 prev = skb->prev;
358 skb->next = NULL;
359 skb->prev = NULL;
360 skb->list = NULL;
361 next->prev = prev;
362 prev->next = next;
363 }
364
365
366
367
368
369
370
371
372 extern __inline__ void skb_unlink(struct sk_buff *skb)
373 {
374 unsigned long flags;
375
376 save_flags(flags);
377 cli();
378 if(skb->list)
379 __skb_unlink(skb, skb->list);
380 restore_flags(flags);
381 }
382
383
384
385
386
387 extern __inline__ unsigned char *skb_put(struct sk_buff *skb, int len)
388 {
389 unsigned char *tmp=skb->tail;
390 skb->tail+=len;
391 skb->len+=len;
392 if(skb->tail>skb->end)
393 panic("skput:over: %p:%d", __builtin_return_address(0),len);
394 return tmp;
395 }
396
397 extern __inline__ unsigned char *skb_push(struct sk_buff *skb, int len)
398 {
399 skb->data-=len;
400 skb->len+=len;
401 if(skb->data<skb->head)
402 panic("skpush:under: %p:%d", __builtin_return_address(0),len);
403 return skb->data;
404 }
405
406 extern __inline__ unsigned char * skb_pull(struct sk_buff *skb, int len)
407 {
408 if(len > skb->len)
409 return NULL;
410 skb->data+=len;
411 skb->len-=len;
412 return skb->data;
413 }
414
415 extern __inline__ int skb_headroom(struct sk_buff *skb)
416 {
417 return skb->data-skb->head;
418 }
419
420 extern __inline__ int skb_tailroom(struct sk_buff *skb)
421 {
422 return skb->end-skb->tail;
423 }
424
425 extern __inline__ void skb_reserve(struct sk_buff *skb, int len)
426 {
427 skb->data+=len;
428 skb->tail+=len;
429 }
430
431 extern __inline__ void skb_trim(struct sk_buff *skb, int len)
432 {
433 if(skb->len>len)
434 {
435 skb->len=len;
436 skb->tail=skb->data+len;
437 }
438 }
439
440 #endif
441
442 extern struct sk_buff * skb_recv_datagram(struct sock *sk,unsigned flags,int noblock, int *err);
443 extern int datagram_select(struct sock *sk, int sel_type, select_table *wait);
444 extern void skb_copy_datagram(struct sk_buff *from, int offset, char *to,int size);
445 extern void skb_copy_datagram_iovec(struct sk_buff *from, int offset, struct iovec *to,int size);
446 extern void skb_free_datagram(struct sock * sk, struct sk_buff *skb);
447
448 #endif
449 #endif