This source file includes following definitions.
- min
- packet_rcv
- packet_sendto
- packet_write
- packet_close
- packet_init
- packet_recvfrom
- packet_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 #include <linux/types.h>
44 #include <linux/sched.h>
45 #include <linux/fcntl.h>
46 #include <linux/socket.h>
47 #include <netinet/in.h>
48 #include "timer.h"
49 #include "ip.h"
50 #include "tcp.h"
51 #include "sock.h"
52 #include <linux/errno.h>
53 #include <linux/timer.h>
54 #include <asm/system.h>
55 #include <asm/segment.h>
56 #include "../kern_sock.h"
57
58 extern struct proto raw_prot;
59
60 static unsigned long
61 min(unsigned long a, unsigned long b)
62 {
63 if (a < b) return (a);
64 return (b);
65 }
66
67
68
69 int
70 packet_rcv (struct sk_buff *skb, struct device *dev, struct packet_type *pt)
71 {
72 volatile struct sock *sk;
73
74 sk = pt->data;
75 skb->dev = dev;
76 skb->len += dev->hard_header_len;
77
78
79 cli();
80 if (sk->inuse)
81 {
82 sti();
83
84
85
86 skb->sk = NULL;
87 kfree_skb (skb, FREE_READ);
88 return (0);
89
90 }
91 sk->inuse = 1;
92 sti ();
93
94 skb->sk = sk;
95
96
97 if (sk->rmem_alloc + skb->mem_len >= SK_RMEM_MAX)
98 {
99 skb->sk = NULL;
100 kfree_skb (skb, FREE_READ);
101 return (0);
102 }
103
104 sk->rmem_alloc += skb->mem_len;
105
106
107 if (sk->rqueue == NULL)
108 {
109 sk->rqueue = skb;
110 skb->next = skb;
111 skb->prev = skb;
112 }
113 else
114 {
115 skb->next = sk->rqueue;
116 skb->prev = sk->rqueue->prev;
117 skb->prev->next = skb;
118 skb->next->prev = skb;
119 }
120 wake_up (sk->sleep);
121 release_sock (sk);
122 return (0);
123 }
124
125
126 static int
127 packet_sendto (volatile struct sock *sk, unsigned char *from, int len,
128 int noblock,
129 unsigned flags, struct sockaddr_in *usin, int addr_len)
130 {
131 struct sk_buff *skb;
132 struct device *dev;
133 struct sockaddr saddr;
134
135
136 if (flags) return (-EINVAL);
137 if (len < 0) return (-EINVAL);
138
139
140 if (usin)
141 {
142 if (addr_len < sizeof (saddr))
143 return (-EINVAL);
144
145 memcpy_fromfs (&saddr, usin, sizeof(saddr));
146 }
147 else
148 return (-EINVAL);
149
150 skb = sk->prot->wmalloc (sk, len+sizeof (*skb) + sk->prot->max_header, 0,
151 GFP_KERNEL);
152
153 if (skb == NULL)
154 {
155 PRINTK ("packet_sendto: write buffer full?\n");
156 print_sk (sk);
157 return (-EAGAIN);
158 }
159 skb->lock = 0;
160 skb->mem_addr = skb;
161 skb->mem_len = len + sizeof (*skb) +sk->prot->max_header;
162 skb->sk = sk;
163 skb->free = 1;
164 saddr.sa_data[13] = 0;
165 dev = get_dev (saddr.sa_data);
166 if (dev == NULL)
167 {
168 sk->prot->wfree (sk, skb->mem_addr, skb->mem_len);
169 return (-ENXIO);
170 }
171
172 memcpy_fromfs (skb+1, from, len);
173 skb->len = len;
174 skb->next = NULL;
175 if (dev->up)
176 dev->queue_xmit (skb, dev, sk->priority);
177 else
178 kfree_skb (skb, FREE_WRITE);
179 return (len);
180 }
181
182 static int
183 packet_write (volatile struct sock *sk, unsigned char *buff,
184 int len, int noblock, unsigned flags)
185 {
186 return (packet_sendto (sk, buff, len, noblock, flags, NULL, 0));
187 }
188
189 static void
190 packet_close (volatile struct sock *sk, int timeout)
191 {
192 sk->inuse = 1;
193 sk->state = TCP_CLOSE;
194 dev_remove_pack ((struct packet_type *)sk->pair);
195 kfree_s ((void *)sk->pair, sizeof (struct packet_type));
196 release_sock (sk);
197 }
198
199 static int
200 packet_init (volatile struct sock *sk)
201 {
202 struct packet_type *p;
203 p = kmalloc (sizeof (*p), GFP_KERNEL);
204 if (p == NULL) return (-ENOMEM);
205
206 p->func = packet_rcv;
207 p->type = sk->num;
208 p->data = (void *)sk;
209 dev_add_pack (p);
210
211
212 sk->pair = (volatile struct sock *)p;
213
214 return (0);
215 }
216
217
218 int
219 packet_recvfrom (volatile struct sock *sk, unsigned char *to, int len,
220 int noblock,
221 unsigned flags, struct sockaddr_in *sin, int *addr_len)
222 {
223
224
225 int copied=0;
226 struct sk_buff *skb;
227 struct sockaddr *saddr;
228 saddr = (struct sockaddr *)sin;
229
230 if (len == 0) return (0);
231 if (len < 0) return (-EINVAL);
232
233 if (sk->shutdown & RCV_SHUTDOWN) return (0);
234
235 if (addr_len)
236 {
237 verify_area (addr_len, sizeof(*addr_len));
238 put_fs_long (sizeof (*saddr), addr_len);
239 }
240
241 sk->inuse = 1;
242 while (sk->rqueue == NULL)
243 {
244 if (noblock)
245 {
246 release_sock (sk);
247 return (-EAGAIN);
248 }
249 release_sock (sk);
250 cli();
251 if (sk->rqueue == NULL)
252 {
253 interruptible_sleep_on (sk->sleep);
254 if (current->signal & ~current->blocked)
255 {
256 return (-ERESTARTSYS);
257 }
258 }
259 sti();
260 }
261 skb = sk->rqueue;
262
263 if (!(flags & MSG_PEEK))
264 {
265 if (skb->next == skb )
266 {
267 sk->rqueue = NULL;
268 }
269 else
270 {
271 sk->rqueue = sk->rqueue ->next;
272 skb->prev->next = skb->next;
273 skb->next->prev = skb->prev;
274 }
275 }
276 copied = min (len, skb->len);
277 verify_area (to, copied);
278 memcpy_tofs (to, skb+1, copied);
279
280 if (saddr)
281 {
282 struct sockaddr addr;
283 addr.sa_family = skb->dev->type;
284 memcpy (addr.sa_data,skb->dev->name, 14);
285 verify_area (saddr, sizeof (*saddr));
286 memcpy_tofs(saddr, &addr, sizeof (*saddr));
287 }
288
289 if (!(flags & MSG_PEEK))
290 {
291 kfree_skb (skb, FREE_READ);
292 }
293
294 release_sock (sk);
295 return (copied);
296
297 }
298
299 int
300 packet_read (volatile struct sock *sk, unsigned char *buff,
301 int len, int noblock, unsigned flags)
302 {
303 return (packet_recvfrom (sk, buff, len, noblock, flags, NULL, NULL));
304 }
305
306
307 int udp_connect (volatile struct sock *sk, struct sockaddr_in *usin,
308 int addr_len);
309
310 int udp_select (volatile struct sock *sk, int sel_type, select_table *wait);
311
312
313 struct proto packet_prot =
314 {
315 sock_wmalloc,
316 sock_rmalloc,
317 sock_wfree,
318 sock_rfree,
319 sock_rspace,
320 sock_wspace,
321 packet_close,
322 packet_read,
323 packet_write,
324 packet_sendto,
325 packet_recvfrom,
326 ip_build_header,
327 udp_connect,
328 NULL,
329 ip_queue_xmit,
330 ip_retransmit,
331 NULL,
332 NULL,
333 NULL,
334 udp_select,
335 NULL,
336 packet_init,
337 NULL,
338 128,
339 0,
340 {NULL,}
341 };