This source file includes following definitions.
- min
- raw_err
- raw_rcv
- raw_sendto
- raw_write
- raw_close
- raw_init
- raw_recvfrom
- raw_read
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 #include <linux/types.h>
54 #include <linux/sched.h>
55 #include <linux/fcntl.h>
56 #include <linux/socket.h>
57 #include <netinet/in.h>
58 #include "timer.h"
59 #include "ip.h"
60 #include "tcp.h"
61 #include "sock.h"
62 #include <linux/errno.h>
63 #include <linux/timer.h>
64 #include <asm/system.h>
65 #include <asm/segment.h>
66 #include <linux/mm.h>
67 #include <linux/kernel.h>
68 #include "icmp.h"
69
70
71 #ifdef PRINTK
72 #undef PRINTK
73 #endif
74
75 #undef RAW_DEBUG
76 #ifdef RAW_DEBUG
77 #define PRINTK printk
78 #else
79 #define PRINTK dummy_routine
80 #endif
81
82 extern struct proto raw_prot;
83
84 static unsigned long
85 min(unsigned long a, unsigned long b)
86 {
87 if (a < b) return (a);
88 return (b);
89 }
90
91
92 void
93 raw_err (int err, unsigned char *header, unsigned long daddr,
94 unsigned long saddr, struct ip_protocol *protocol)
95 {
96 volatile struct sock *sk;
97
98 PRINTK ("raw_err (err=%d, header=%X, daddr=%X, saddr=%X, ip_protocl=%X)\n");
99
100 if (protocol == NULL) return;
101
102 sk = protocol->data;
103
104 if (sk == NULL) return;
105
106
107 if (err & 0xff00 == (ICMP_SOURCE_QUENCH << 8))
108 {
109 if (sk->cong_window > 1)
110 sk->cong_window = sk->cong_window/2;
111 return;
112 }
113
114 sk->err = icmp_err_convert[err & 0xff].errno;
115
116
117
118
119
120
121 return;
122
123 }
124
125
126
127 int
128 raw_rcv (struct sk_buff *skb, struct device *dev, struct options *opt,
129 unsigned long daddr, unsigned short len, unsigned long saddr,
130 int redo, struct ip_protocol *protocol)
131 {
132
133 volatile struct sock *sk;
134
135 PRINTK ("raw_rcv (skb=%X, dev=%X, opt=%X, daddr=%X,\n"
136 " len=%d, saddr=%X, redo=%d, protocol=%X)\n",
137 skb, dev, opt, daddr, len, saddr, redo, protocol);
138
139 if (skb == NULL) return (0);
140 if (protocol == NULL)
141 {
142 kfree_skb (skb, FREE_READ);
143 return (0);
144 }
145 sk = protocol->data;
146 if (sk == NULL)
147 {
148 kfree_skb (skb, FREE_READ);
149 return (0);
150 }
151
152
153 skb->sk = sk;
154 skb->len = len;
155 skb->dev = dev;
156 skb->saddr = daddr;
157 skb->daddr = saddr;
158
159 if (!redo )
160 {
161
162 cli();
163 if (sk->inuse)
164 {
165 PRINTK ("raw_rcv adding to backlog. \n");
166 if (sk->back_log == NULL)
167 {
168 sk->back_log = skb;
169 skb->next = skb;
170 skb->prev = skb;
171 }
172 else
173 {
174 skb->next = sk->back_log;
175 skb->prev = sk->back_log->prev;
176 skb->prev->next = skb;
177 skb->next->prev = skb;
178 }
179 sti();
180 return (0);
181 }
182 sk->inuse = 1;
183 sti();
184 }
185
186
187 if (sk->rmem_alloc + skb->mem_len >= SK_RMEM_MAX)
188 {
189 skb->sk = NULL;
190 kfree_skb (skb, FREE_READ);
191 return (0);
192 }
193
194 sk->rmem_alloc += skb->mem_len;
195
196
197 if (sk->rqueue == NULL)
198 {
199 sk->rqueue = skb;
200 skb->next = skb;
201 skb->prev = skb;
202 }
203 else
204 {
205 skb->next = sk->rqueue;
206 skb->prev = sk->rqueue->prev;
207 skb->prev->next = skb;
208 skb->next->prev = skb;
209 }
210 wake_up (sk->sleep);
211 release_sock (sk);
212 return (0);
213 }
214
215
216 static int
217 raw_sendto (volatile struct sock *sk, unsigned char *from, int len,
218 int noblock,
219 unsigned flags, struct sockaddr_in *usin, int addr_len)
220 {
221 struct sk_buff *skb;
222 struct device *dev=NULL;
223 struct sockaddr_in sin;
224 int tmp;
225
226 PRINTK ("raw_sendto (sk=%X, from=%X, len=%d, noblock=%d, flags=%X,\n"
227 " usin=%X, addr_len = %d)\n", sk, from, len, noblock,
228 flags, usin, addr_len);
229
230
231 if (flags) return (-EINVAL);
232 if (len < 0) return (-EINVAL);
233
234
235 if (usin)
236 {
237 if (addr_len < sizeof (sin))
238 return (-EINVAL);
239
240 memcpy_fromfs (&sin, usin, sizeof(sin));
241 if (sin.sin_family &&
242 sin.sin_family != AF_INET)
243 return (-EINVAL);
244 }
245 else
246 {
247 if (sk->state != TCP_ESTABLISHED)
248 return (-EINVAL);
249 sin.sin_family = AF_INET;
250 sin.sin_port = sk->protocol;
251 sin.sin_addr.s_addr = sk->daddr;
252 }
253 if (sin.sin_port == 0) sin.sin_port = sk->protocol;
254
255 sk->inuse = 1;
256 skb = NULL;
257 while (skb == NULL)
258 {
259 skb = sk->prot->wmalloc (sk, len+sizeof (*skb) + sk->prot->max_header,
260 0, GFP_KERNEL);
261
262
263 if (skb == NULL)
264 {
265 int tmp;
266 PRINTK ("raw_sendto: write buffer full?\n");
267 print_sk (sk);
268 if (noblock) return (-EAGAIN);
269 tmp = sk->wmem_alloc;
270 release_sock (sk);
271 cli();
272 if (tmp <= sk->wmem_alloc)
273 {
274 interruptible_sleep_on (sk->sleep);
275 if (current->signal & ~current->blocked)
276 {
277 sti();
278 return (-ERESTARTSYS);
279 }
280 }
281 sk->inuse = 1;
282 sti();
283 }
284 }
285 skb->lock = 0;
286 skb->mem_addr = skb;
287 skb->mem_len = len + sizeof (*skb) +sk->prot->max_header;
288 skb->sk = sk;
289
290 skb->free = 1;
291 skb->arp = 0;
292
293 tmp = sk->prot->build_header (skb, sk->saddr,
294 sin.sin_addr.s_addr, &dev,
295 sk->protocol, sk->opt, skb->mem_len);
296 if (tmp < 0)
297 {
298 PRINTK ("raw_sendto: error building ip header.\n");
299 sk->prot->wfree (sk, skb->mem_addr, skb->mem_len);
300 release_sock (sk);
301 return (tmp);
302 }
303
304
305 memcpy_fromfs ((unsigned char *)(skb+1)+tmp, from, len);
306 skb->len = tmp + len;
307 sk->prot->queue_xmit (sk, dev, skb, 1);
308 release_sock (sk);
309 return (len);
310 }
311
312 static int
313 raw_write (volatile struct sock *sk, unsigned char *buff, int len, int noblock,
314 unsigned flags)
315 {
316 return (raw_sendto (sk, buff, len, noblock, flags, NULL, 0));
317 }
318
319 static void
320 raw_close (volatile struct sock *sk, int timeout)
321 {
322 sk->inuse = 1;
323 sk->state = TCP_CLOSE;
324 PRINTK ("raw_close: deleting ip_protocol %d\n",
325 ((struct ip_protocol *)sk->pair)->protocol);
326 if (delete_ip_protocol ((struct ip_protocol *)sk->pair) < 0)
327 PRINTK ("raw_close: delete_ip_protocol failed. \n");
328 kfree_s ((void *)sk->pair, sizeof (struct ip_protocol));
329 sk->pair = NULL;
330 release_sock (sk);
331 }
332
333 static int
334 raw_init (volatile struct sock *sk)
335 {
336 struct ip_protocol *p;
337 p = kmalloc (sizeof (*p), GFP_KERNEL);
338 if (p == NULL) return (-ENOMEM);
339
340 p->handler = raw_rcv;
341 p->protocol = sk->protocol;
342 p->data = (void *)sk;
343 p->err_handler = raw_err;
344 add_ip_protocol (p);
345
346
347 sk->pair = (volatile struct sock *)p;
348
349 PRINTK ("raw init added protocol %d\n", sk->protocol);
350
351 return (0);
352 }
353
354
355 int
356 raw_recvfrom (volatile struct sock *sk, unsigned char *to, int len,
357 int noblock,
358 unsigned flags, struct sockaddr_in *sin, int *addr_len)
359 {
360
361
362 int copied=0;
363 struct sk_buff *skb;
364
365 PRINTK ("raw_recvfrom (sk=%X, to=%X, len=%d, noblock=%d, flags=%X,\n"
366 " sin=%X, addr_len=%X)\n", sk, to, len, noblock,
367 flags, sin, addr_len);
368
369 if (len == 0) return (0);
370 if (len < 0) return (-EINVAL);
371
372 if (sk->shutdown & RCV_SHUTDOWN) return (0);
373 if (addr_len)
374 {
375 verify_area (addr_len, sizeof(*addr_len));
376 put_fs_long (sizeof (*sin), addr_len);
377 }
378 sk->inuse = 1;
379 while (sk->rqueue == NULL)
380 {
381 if (noblock)
382 {
383 release_sock (sk);
384 if (copied) return (copied);
385 return (-EAGAIN);
386 }
387 release_sock (sk);
388 cli();
389 if (sk->rqueue == NULL)
390 {
391 interruptible_sleep_on (sk->sleep);
392 if (current->signal & ~current->blocked)
393 {
394 sti();
395 return (-ERESTARTSYS);
396 }
397 }
398 sk->inuse = 1;
399 sti();
400 }
401 skb = sk->rqueue;
402
403 if (!(flags & MSG_PEEK))
404 {
405 if (skb->next == skb )
406 {
407 sk->rqueue = NULL;
408 }
409 else
410 {
411 sk->rqueue = sk->rqueue ->next;
412 skb->prev->next = skb->next;
413 skb->next->prev = skb->prev;
414 }
415 }
416 copied = min (len, skb->len);
417 verify_area (to, copied);
418 memcpy_tofs (to, skb->h.raw, copied);
419
420 if (sin)
421 {
422 struct sockaddr_in addr;
423 addr.sin_family = AF_INET;
424 addr.sin_addr.s_addr = skb->daddr;
425 verify_area (sin, sizeof (*sin));
426 memcpy_tofs(sin, &addr, sizeof (*sin));
427 }
428
429 if (!(flags & MSG_PEEK))
430 {
431 kfree_skb (skb, FREE_READ);
432 }
433 release_sock (sk);
434 return (copied);
435
436 }
437
438 int
439 raw_read (volatile struct sock *sk, unsigned char *buff, int len, int noblock,
440 unsigned flags)
441 {
442 return (raw_recvfrom (sk, buff, len, noblock, flags, NULL, NULL));
443 }
444
445
446 int udp_connect (volatile struct sock *sk, struct sockaddr_in *usin,
447 int addr_len);
448
449 int udp_select (volatile struct sock *sk, int sel_type, select_table *wait);
450
451
452 struct proto raw_prot =
453 {
454 sock_wmalloc,
455 sock_rmalloc,
456 sock_wfree,
457 sock_rfree,
458 sock_rspace,
459 sock_wspace,
460 raw_close,
461 raw_read,
462 raw_write,
463 raw_sendto,
464 raw_recvfrom,
465 ip_build_header,
466 udp_connect,
467 NULL,
468 ip_queue_xmit,
469 ip_retransmit,
470 NULL,
471 NULL,
472 raw_rcv,
473 udp_select,
474 NULL,
475 raw_init,
476 NULL,
477 128,
478 0,
479 {NULL,}
480 };