This source file includes following definitions.
- sock_setsockopt
- sock_getsockopt
- sock_wmalloc
- sock_rmalloc
- sock_rspace
- sock_wspace
- sock_wfree
- sock_rfree
- sock_alloc_send_skb
- release_sock
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78 #include <linux/config.h>
79 #include <linux/errno.h>
80 #include <linux/types.h>
81 #include <linux/socket.h>
82 #include <linux/in.h>
83 #include <linux/kernel.h>
84 #include <linux/major.h>
85 #include <linux/sched.h>
86 #include <linux/timer.h>
87 #include <linux/string.h>
88 #include <linux/sockios.h>
89 #include <linux/net.h>
90 #include <linux/fcntl.h>
91 #include <linux/mm.h>
92 #include <linux/interrupt.h>
93
94 #include <asm/segment.h>
95 #include <asm/system.h>
96
97 #include <linux/inet.h>
98 #include <linux/netdevice.h>
99 #include <net/ip.h>
100 #include <net/protocol.h>
101 #include <net/arp.h>
102 #include <net/rarp.h>
103 #include <net/route.h>
104 #include <net/tcp.h>
105 #include <net/udp.h>
106 #include <linux/skbuff.h>
107 #include <net/sock.h>
108 #include <net/raw.h>
109 #include <net/icmp.h>
110
111 #define min(a,b) ((a)<(b)?(a):(b))
112
113
114
115
116
117
118 int sock_setsockopt(struct sock *sk, int level, int optname,
119 char *optval, int optlen)
120 {
121 int val;
122 int valbool;
123 int err;
124 struct linger ling;
125
126 if (optval == NULL)
127 return(-EINVAL);
128
129 err=verify_area(VERIFY_READ, optval, sizeof(int));
130 if(err)
131 return err;
132
133 val = get_user((int *)optval);
134 valbool = val?1:0;
135
136 switch(optname)
137 {
138 case SO_DEBUG:
139 if(val && !suser())
140 return(-EPERM);
141 sk->debug=valbool;
142 return 0;
143 case SO_REUSEADDR:
144 sk->reuse = valbool;
145 return(0);
146 case SO_TYPE:
147 case SO_ERROR:
148 return(-ENOPROTOOPT);
149 case SO_DONTROUTE:
150 sk->localroute=valbool;
151 return 0;
152 case SO_BROADCAST:
153 sk->broadcast=valbool;
154 return 0;
155 case SO_SNDBUF:
156 if(val>32767)
157 val=32767;
158 if(val<256)
159 val=256;
160 sk->sndbuf=val;
161 return 0;
162
163 case SO_RCVBUF:
164 if(val>32767)
165 val=32767;
166 if(val<256)
167 val=256;
168 sk->rcvbuf=val;
169 return(0);
170
171 case SO_KEEPALIVE:
172 sk->keepopen = valbool;
173 return(0);
174
175 case SO_OOBINLINE:
176 sk->urginline = valbool;
177 return(0);
178
179 case SO_NO_CHECK:
180 sk->no_check = valbool;
181 return(0);
182
183 case SO_PRIORITY:
184 if (val >= 0 && val < DEV_NUMBUFFS)
185 {
186 sk->priority = val;
187 }
188 else
189 {
190 return(-EINVAL);
191 }
192 return(0);
193
194
195 case SO_LINGER:
196 err=verify_area(VERIFY_READ,optval,sizeof(ling));
197 if(err)
198 return err;
199 memcpy_fromfs(&ling,optval,sizeof(ling));
200 if(ling.l_onoff==0)
201 sk->linger=0;
202 else
203 {
204 sk->lingertime=ling.l_linger;
205 sk->linger=1;
206 }
207 return 0;
208
209
210 default:
211 return(-ENOPROTOOPT);
212 }
213 }
214
215
216 int sock_getsockopt(struct sock *sk, int level, int optname,
217 char *optval, int *optlen)
218 {
219 int val;
220 int err;
221 struct linger ling;
222
223 switch(optname)
224 {
225 case SO_DEBUG:
226 val = sk->debug;
227 break;
228
229 case SO_DONTROUTE:
230 val = sk->localroute;
231 break;
232
233 case SO_BROADCAST:
234 val= sk->broadcast;
235 break;
236
237 case SO_SNDBUF:
238 val=sk->sndbuf;
239 break;
240
241 case SO_RCVBUF:
242 val =sk->rcvbuf;
243 break;
244
245 case SO_REUSEADDR:
246 val = sk->reuse;
247 break;
248
249 case SO_KEEPALIVE:
250 val = sk->keepopen;
251 break;
252
253 case SO_TYPE:
254 val = sk->type;
255 break;
256
257 case SO_ERROR:
258 val = sk->err;
259 sk->err = 0;
260 break;
261
262 case SO_OOBINLINE:
263 val = sk->urginline;
264 break;
265
266 case SO_NO_CHECK:
267 val = sk->no_check;
268 break;
269
270 case SO_PRIORITY:
271 val = sk->priority;
272 break;
273
274 case SO_LINGER:
275 err=verify_area(VERIFY_WRITE,optval,sizeof(ling));
276 if(err)
277 return err;
278 err=verify_area(VERIFY_WRITE,optlen,sizeof(int));
279 if(err)
280 return err;
281 put_fs_long(sizeof(ling),(unsigned long *)optlen);
282 ling.l_onoff=sk->linger;
283 ling.l_linger=sk->lingertime;
284 memcpy_tofs(optval,&ling,sizeof(ling));
285 return 0;
286
287
288
289 default:
290 return(-ENOPROTOOPT);
291 }
292 err=verify_area(VERIFY_WRITE, optlen, sizeof(int));
293 if(err)
294 return err;
295 put_fs_long(sizeof(int),(unsigned long *) optlen);
296
297 err=verify_area(VERIFY_WRITE, optval, sizeof(int));
298 if(err)
299 return err;
300 put_fs_long(val,(unsigned long *)optval);
301
302 return(0);
303 }
304
305
306 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
307 {
308 if (sk)
309 {
310 if (sk->wmem_alloc + size < sk->sndbuf || force)
311 {
312 struct sk_buff * c = alloc_skb(size, priority);
313 if (c)
314 {
315 unsigned long flags;
316 save_flags(flags);
317 cli();
318 sk->wmem_alloc+= c->truesize;
319 restore_flags(flags);
320 }
321 return c;
322 }
323 return(NULL);
324 }
325 return(alloc_skb(size, priority));
326 }
327
328
329 struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
330 {
331 if (sk)
332 {
333 if (sk->rmem_alloc + size < sk->rcvbuf || force)
334 {
335 struct sk_buff *c = alloc_skb(size, priority);
336 if (c)
337 {
338 unsigned long flags;
339 save_flags(flags);
340 cli();
341 sk->rmem_alloc += c->truesize;
342 restore_flags(flags);
343 }
344 return(c);
345 }
346 return(NULL);
347 }
348 return(alloc_skb(size, priority));
349 }
350
351
352 unsigned long sock_rspace(struct sock *sk)
353 {
354 int amt;
355
356 if (sk != NULL)
357 {
358 if (sk->rmem_alloc >= sk->rcvbuf-2*MIN_WINDOW)
359 return(0);
360 amt = min((sk->rcvbuf-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW);
361 if (amt < 0)
362 return(0);
363 return(amt);
364 }
365 return(0);
366 }
367
368
369 unsigned long sock_wspace(struct sock *sk)
370 {
371 if (sk != NULL)
372 {
373 if (sk->shutdown & SEND_SHUTDOWN)
374 return(0);
375 if (sk->wmem_alloc >= sk->sndbuf)
376 return(0);
377 return(sk->sndbuf-sk->wmem_alloc );
378 }
379 return(0);
380 }
381
382
383 void sock_wfree(struct sock *sk, struct sk_buff *skb)
384 {
385 int s=skb->truesize;
386 #if CONFIG_SKB_CHECK
387 IS_SKB(skb);
388 #endif
389 kfree_skbmem(skb);
390 if (sk)
391 {
392 unsigned long flags;
393 save_flags(flags);
394 cli();
395 sk->wmem_alloc -= s;
396 restore_flags(flags);
397
398 sk->write_space(sk);
399 return;
400 }
401 }
402
403
404 void sock_rfree(struct sock *sk, struct sk_buff *skb)
405 {
406 int s=skb->truesize;
407 #if CONFIG_SKB_CHECK
408 IS_SKB(skb);
409 #endif
410 kfree_skbmem(skb);
411 if (sk)
412 {
413 unsigned long flags;
414 save_flags(flags);
415 cli();
416 sk->rmem_alloc -= s;
417 restore_flags(flags);
418 }
419 }
420
421
422
423
424
425 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, unsigned long fallback, int noblock, int *errcode)
426 {
427 struct sk_buff *skb;
428 int err;
429
430 sk->inuse=1;
431
432 do
433 {
434 if(sk->err!=0)
435 {
436 cli();
437 err= -sk->err;
438 sk->err=0;
439 sti();
440 *errcode=err;
441 return NULL;
442 }
443
444 if(sk->shutdown&SEND_SHUTDOWN)
445 {
446 *errcode=-EPIPE;
447 return NULL;
448 }
449
450 if(!fallback)
451 skb = sock_wmalloc(sk, size, 0, GFP_KERNEL);
452 else
453 {
454
455
456 skb = sock_wmalloc(sk, size, 0 , GFP_BUFFER);
457 if(!skb)
458 skb=sock_wmalloc(sk, fallback, 0, GFP_KERNEL);
459 }
460
461
462
463
464
465 if(skb==NULL)
466 {
467 unsigned long tmp;
468
469 sk->socket->flags |= SO_NOSPACE;
470 if(noblock)
471 {
472 *errcode=-EAGAIN;
473 return NULL;
474 }
475 if(sk->shutdown&SEND_SHUTDOWN)
476 {
477 *errcode=-EPIPE;
478 return NULL;
479 }
480 tmp = sk->wmem_alloc;
481 cli();
482 if(sk->shutdown&SEND_SHUTDOWN)
483 {
484 sti();
485 *errcode=-EPIPE;
486 return NULL;
487 }
488
489 if( tmp <= sk->wmem_alloc)
490 {
491 sk->socket->flags &= ~SO_NOSPACE;
492 interruptible_sleep_on(sk->sleep);
493 if (current->signal & ~current->blocked)
494 {
495 sti();
496 *errcode = -ERESTARTSYS;
497 return NULL;
498 }
499 }
500 sti();
501 }
502 }
503 while(skb==NULL);
504
505 return skb;
506 }
507
508
509 void release_sock(struct sock *sk)
510 {
511 unsigned long flags;
512 #ifdef CONFIG_INET
513 struct sk_buff *skb;
514 #endif
515
516 if (!sk->prot)
517 return;
518
519
520
521
522
523
524
525 save_flags(flags);
526 cli();
527 if (sk->blog)
528 {
529 restore_flags(flags);
530 return;
531 }
532 sk->blog=1;
533 sk->inuse = 1;
534 restore_flags(flags);
535 #ifdef CONFIG_INET
536
537 while((skb = skb_dequeue(&sk->back_log)) != NULL)
538 {
539 sk->blog = 1;
540 if (sk->prot->rcv)
541 sk->prot->rcv(skb, skb->dev, sk->opt,
542 skb->saddr, skb->len, skb->daddr, 1,
543
544 (struct inet_protocol *)sk->pair);
545 }
546 #endif
547 sk->blog = 0;
548 sk->inuse = 0;
549 #ifdef CONFIG_INET
550 if (sk->dead && sk->state == TCP_CLOSE)
551 {
552
553 reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
554 }
555 #endif
556 }
557
558