OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [ipv6/] [datagram.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1275 phoenix
/*
2
 *      common UDP/RAW code
3
 *      Linux INET6 implementation
4
 *
5
 *      Authors:
6
 *      Pedro Roque             <roque@di.fc.ul.pt>
7
 *
8
 *      $Id: datagram.c,v 1.1.1.1 2004-04-15 01:14:46 phoenix Exp $
9
 *
10
 *      This program is free software; you can redistribute it and/or
11
 *      modify it under the terms of the GNU General Public License
12
 *      as published by the Free Software Foundation; either version
13
 *      2 of the License, or (at your option) any later version.
14
 */
15
 
16
#include <linux/errno.h>
17
#include <linux/types.h>
18
#include <linux/kernel.h>
19
#include <linux/sched.h>
20
#include <linux/interrupt.h>
21
#include <linux/socket.h>
22
#include <linux/sockios.h>
23
#include <linux/in6.h>
24
#include <linux/ipv6.h>
25
#include <linux/route.h>
26
 
27
#include <net/ipv6.h>
28
#include <net/ndisc.h>
29
#include <net/addrconf.h>
30
#include <net/transp_v6.h>
31
 
32
#include <linux/errqueue.h>
33
#include <asm/uaccess.h>
34
 
35
void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
36
                     u16 port, u32 info, u8 *payload)
37
{
38
        struct icmp6hdr *icmph = (struct icmp6hdr *)skb->h.raw;
39
        struct sock_exterr_skb *serr;
40
 
41
        if (!sk->net_pinfo.af_inet6.recverr)
42
                return;
43
 
44
        skb = skb_clone(skb, GFP_ATOMIC);
45
        if (!skb)
46
                return;
47
 
48
        serr = SKB_EXT_ERR(skb);
49
        serr->ee.ee_errno = err;
50
        serr->ee.ee_origin = SO_EE_ORIGIN_ICMP6;
51
        serr->ee.ee_type = icmph->icmp6_type;
52
        serr->ee.ee_code = icmph->icmp6_code;
53
        serr->ee.ee_pad = 0;
54
        serr->ee.ee_info = info;
55
        serr->ee.ee_data = 0;
56
        serr->addr_offset = (u8*)&(((struct ipv6hdr*)(icmph+1))->daddr) - skb->nh.raw;
57
        serr->port = port;
58
 
59
        skb->h.raw = payload;
60
        __skb_pull(skb, payload - skb->data);
61
 
62
        if (sock_queue_err_skb(sk, skb))
63
                kfree_skb(skb);
64
}
65
 
66
void ipv6_local_error(struct sock *sk, int err, struct flowi *fl, u32 info)
67
{
68
        struct sock_exterr_skb *serr;
69
        struct ipv6hdr *iph;
70
        struct sk_buff *skb;
71
 
72
        if (!sk->net_pinfo.af_inet6.recverr)
73
                return;
74
 
75
        skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
76
        if (!skb)
77
                return;
78
 
79
        iph = (struct ipv6hdr*)skb_put(skb, sizeof(struct ipv6hdr));
80
        skb->nh.ipv6h = iph;
81
        memcpy(&iph->daddr, fl->fl6_dst, 16);
82
 
83
        serr = SKB_EXT_ERR(skb);
84
        serr->ee.ee_errno = err;
85
        serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
86
        serr->ee.ee_type = 0;
87
        serr->ee.ee_code = 0;
88
        serr->ee.ee_pad = 0;
89
        serr->ee.ee_info = info;
90
        serr->ee.ee_data = 0;
91
        serr->addr_offset = (u8*)&iph->daddr - skb->nh.raw;
92
        serr->port = fl->uli_u.ports.dport;
93
 
94
        skb->h.raw = skb->tail;
95
        __skb_pull(skb, skb->tail - skb->data);
96
 
97
        if (sock_queue_err_skb(sk, skb))
98
                kfree_skb(skb);
99
}
100
 
101
/*
102
 *      Handle MSG_ERRQUEUE
103
 */
104
int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len)
105
{
106
        struct sock_exterr_skb *serr;
107
        struct sk_buff *skb, *skb2;
108
        struct sockaddr_in6 *sin;
109
        struct {
110
                struct sock_extended_err ee;
111
                struct sockaddr_in6      offender;
112
        } errhdr;
113
        int err;
114
        int copied;
115
 
116
        err = -EAGAIN;
117
        skb = skb_dequeue(&sk->error_queue);
118
        if (skb == NULL)
119
                goto out;
120
 
121
        copied = skb->len;
122
        if (copied > len) {
123
                msg->msg_flags |= MSG_TRUNC;
124
                copied = len;
125
        }
126
        err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
127
        if (err)
128
                goto out_free_skb;
129
 
130
        sock_recv_timestamp(msg, sk, skb);
131
 
132
        serr = SKB_EXT_ERR(skb);
133
 
134
        sin = (struct sockaddr_in6 *)msg->msg_name;
135
        if (sin) {
136
                sin->sin6_family = AF_INET6;
137
                sin->sin6_flowinfo = 0;
138
                sin->sin6_port = serr->port;
139
                sin->sin6_scope_id = 0;
140
                if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6) {
141
                        memcpy(&sin->sin6_addr, skb->nh.raw + serr->addr_offset, 16);
142
                        if (sk->net_pinfo.af_inet6.sndflow)
143
                                sin->sin6_flowinfo = *(u32*)(skb->nh.raw + serr->addr_offset - 24) & IPV6_FLOWINFO_MASK;
144
                        if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL) {
145
                                struct inet6_skb_parm *opt = (struct inet6_skb_parm *) skb->cb;
146
                                sin->sin6_scope_id = opt->iif;
147
                        }
148
                } else {
149
                        ipv6_addr_set(&sin->sin6_addr, 0, 0,
150
                                      htonl(0xffff),
151
                                      *(u32*)(skb->nh.raw + serr->addr_offset));
152
                }
153
        }
154
 
155
        memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
156
        sin = &errhdr.offender;
157
        sin->sin6_family = AF_UNSPEC;
158
        if (serr->ee.ee_origin != SO_EE_ORIGIN_LOCAL) {
159
                sin->sin6_family = AF_INET6;
160
                sin->sin6_flowinfo = 0;
161
                sin->sin6_scope_id = 0;
162
                if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6) {
163
                        memcpy(&sin->sin6_addr, &skb->nh.ipv6h->saddr, 16);
164
                        if (sk->net_pinfo.af_inet6.rxopt.all)
165
                                datagram_recv_ctl(sk, msg, skb);
166
                        if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL) {
167
                                struct inet6_skb_parm *opt = (struct inet6_skb_parm *) skb->cb;
168
                                sin->sin6_scope_id = opt->iif;
169
                        }
170
                } else {
171
                        ipv6_addr_set(&sin->sin6_addr, 0, 0,
172
                                      htonl(0xffff),
173
                                      skb->nh.iph->saddr);
174
                        if (sk->protinfo.af_inet.cmsg_flags)
175
                                ip_cmsg_recv(msg, skb);
176
                }
177
        }
178
 
179
        put_cmsg(msg, SOL_IPV6, IPV6_RECVERR, sizeof(errhdr), &errhdr);
180
 
181
        /* Now we could try to dump offended packet options */
182
 
183
        msg->msg_flags |= MSG_ERRQUEUE;
184
        err = copied;
185
 
186
        /* Reset and regenerate socket error */
187
        spin_lock_irq(&sk->error_queue.lock);
188
        sk->err = 0;
189
        if ((skb2 = skb_peek(&sk->error_queue)) != NULL) {
190
                sk->err = SKB_EXT_ERR(skb2)->ee.ee_errno;
191
                spin_unlock_irq(&sk->error_queue.lock);
192
                sk->error_report(sk);
193
        } else {
194
                spin_unlock_irq(&sk->error_queue.lock);
195
        }
196
 
197
out_free_skb:
198
        kfree_skb(skb);
199
out:
200
        return err;
201
}
202
 
203
 
204
 
205
int datagram_recv_ctl(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
206
{
207
        struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
208
        struct inet6_skb_parm *opt = (struct inet6_skb_parm *) skb->cb;
209
 
210
        if (np->rxopt.bits.rxinfo) {
211
                struct in6_pktinfo src_info;
212
 
213
                src_info.ipi6_ifindex = opt->iif;
214
                ipv6_addr_copy(&src_info.ipi6_addr, &skb->nh.ipv6h->daddr);
215
                put_cmsg(msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
216
        }
217
 
218
        if (np->rxopt.bits.rxhlim) {
219
                int hlim = skb->nh.ipv6h->hop_limit;
220
                put_cmsg(msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
221
        }
222
 
223
        if (np->rxopt.bits.rxflow && (*(u32*)skb->nh.raw & IPV6_FLOWINFO_MASK)) {
224
                u32 flowinfo = *(u32*)skb->nh.raw & IPV6_FLOWINFO_MASK;
225
                put_cmsg(msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
226
        }
227
        if (np->rxopt.bits.hopopts && opt->hop) {
228
                u8 *ptr = skb->nh.raw + opt->hop;
229
                put_cmsg(msg, SOL_IPV6, IPV6_HOPOPTS, (ptr[1]+1)<<3, ptr);
230
        }
231
        if (np->rxopt.bits.dstopts && opt->dst0) {
232
                u8 *ptr = skb->nh.raw + opt->dst0;
233
                put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, (ptr[1]+1)<<3, ptr);
234
        }
235
        if (np->rxopt.bits.srcrt && opt->srcrt) {
236
                struct ipv6_rt_hdr *rthdr = (struct ipv6_rt_hdr *)(skb->nh.raw + opt->srcrt);
237
                put_cmsg(msg, SOL_IPV6, IPV6_RTHDR, (rthdr->hdrlen+1) << 3, rthdr);
238
        }
239
        if (np->rxopt.bits.authhdr && opt->auth) {
240
                u8 *ptr = skb->nh.raw + opt->auth;
241
                put_cmsg(msg, SOL_IPV6, IPV6_AUTHHDR, (ptr[1]+1)<<2, ptr);
242
        }
243
        if (np->rxopt.bits.dstopts && opt->dst1) {
244
                u8 *ptr = skb->nh.raw + opt->dst1;
245
                put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, (ptr[1]+1)<<3, ptr);
246
        }
247
        return 0;
248
}
249
 
250
int datagram_send_ctl(struct msghdr *msg, struct flowi *fl,
251
                      struct ipv6_txoptions *opt,
252
                      int *hlimit)
253
{
254
        struct in6_pktinfo *src_info;
255
        struct cmsghdr *cmsg;
256
        struct ipv6_rt_hdr *rthdr;
257
        struct ipv6_opt_hdr *hdr;
258
        int len;
259
        int err = 0;
260
 
261
        for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
262
 
263
                if (cmsg->cmsg_len < sizeof(struct cmsghdr) ||
264
                    (unsigned long)(((char*)cmsg - (char*)msg->msg_control)
265
                                    + cmsg->cmsg_len) > msg->msg_controllen) {
266
                        err = -EINVAL;
267
                        goto exit_f;
268
                }
269
 
270
                if (cmsg->cmsg_level != SOL_IPV6)
271
                        continue;
272
 
273
                switch (cmsg->cmsg_type) {
274
                case IPV6_PKTINFO:
275
                        if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct in6_pktinfo))) {
276
                                err = -EINVAL;
277
                                goto exit_f;
278
                        }
279
 
280
                        src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
281
 
282
                        if (src_info->ipi6_ifindex) {
283
                                if (fl->oif && src_info->ipi6_ifindex != fl->oif)
284
                                        return -EINVAL;
285
                                fl->oif = src_info->ipi6_ifindex;
286
                        }
287
 
288
                        if (!ipv6_addr_any(&src_info->ipi6_addr)) {
289
                                if (!ipv6_chk_addr(&src_info->ipi6_addr, NULL)) {
290
                                        err = -EINVAL;
291
                                        goto exit_f;
292
                                }
293
 
294
                                fl->fl6_src = &src_info->ipi6_addr;
295
                        }
296
 
297
                        break;
298
 
299
                case IPV6_FLOWINFO:
300
                        if (cmsg->cmsg_len < CMSG_LEN(4)) {
301
                                err = -EINVAL;
302
                                goto exit_f;
303
                        }
304
 
305
                        if (fl->fl6_flowlabel&IPV6_FLOWINFO_MASK) {
306
                                if ((fl->fl6_flowlabel^*(u32 *)CMSG_DATA(cmsg))&~IPV6_FLOWINFO_MASK) {
307
                                        err = -EINVAL;
308
                                        goto exit_f;
309
                                }
310
                        }
311
                        fl->fl6_flowlabel = IPV6_FLOWINFO_MASK & *(u32 *)CMSG_DATA(cmsg);
312
                        break;
313
 
314
                case IPV6_HOPOPTS:
315
                        if (opt->hopopt || cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
316
                                err = -EINVAL;
317
                                goto exit_f;
318
                        }
319
 
320
                        hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
321
                        len = ((hdr->hdrlen + 1) << 3);
322
                        if (cmsg->cmsg_len < CMSG_LEN(len)) {
323
                                err = -EINVAL;
324
                                goto exit_f;
325
                        }
326
                        if (!capable(CAP_NET_RAW)) {
327
                                err = -EPERM;
328
                                goto exit_f;
329
                        }
330
                        opt->opt_nflen += len;
331
                        opt->hopopt = hdr;
332
                        break;
333
 
334
                case IPV6_DSTOPTS:
335
                        if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
336
                                err = -EINVAL;
337
                                goto exit_f;
338
                        }
339
 
340
                        hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
341
                        len = ((hdr->hdrlen + 1) << 3);
342
                        if (cmsg->cmsg_len < CMSG_LEN(len)) {
343
                                err = -EINVAL;
344
                                goto exit_f;
345
                        }
346
                        if (!capable(CAP_NET_RAW)) {
347
                                err = -EPERM;
348
                                goto exit_f;
349
                        }
350
                        if (opt->dst1opt) {
351
                                err = -EINVAL;
352
                                goto exit_f;
353
                        }
354
                        opt->opt_flen += len;
355
                        opt->dst1opt = hdr;
356
                        break;
357
 
358
                case IPV6_AUTHHDR:
359
                        if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
360
                                err = -EINVAL;
361
                                goto exit_f;
362
                        }
363
 
364
                        hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
365
                        len = ((hdr->hdrlen + 2) << 2);
366
                        if (cmsg->cmsg_len < CMSG_LEN(len)) {
367
                                err = -EINVAL;
368
                                goto exit_f;
369
                        }
370
                        if (len & ~7) {
371
                                err = -EINVAL;
372
                                goto exit_f;
373
                        }
374
                        opt->opt_flen += len;
375
                        opt->auth = hdr;
376
                        break;
377
 
378
                case IPV6_RTHDR:
379
                        if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_rt_hdr))) {
380
                                err = -EINVAL;
381
                                goto exit_f;
382
                        }
383
 
384
                        rthdr = (struct ipv6_rt_hdr *)CMSG_DATA(cmsg);
385
 
386
                        /*
387
                         *      TYPE 0
388
                         */
389
                        if (rthdr->type) {
390
                                err = -EINVAL;
391
                                goto exit_f;
392
                        }
393
 
394
                        len = ((rthdr->hdrlen + 1) << 3);
395
 
396
                        if (cmsg->cmsg_len < CMSG_LEN(len)) {
397
                                err = -EINVAL;
398
                                goto exit_f;
399
                        }
400
 
401
                        /* segments left must also match */
402
                        if ((rthdr->hdrlen >> 1) != rthdr->segments_left) {
403
                                err = -EINVAL;
404
                                goto exit_f;
405
                        }
406
 
407
                        opt->opt_nflen += len;
408
                        opt->srcrt = rthdr;
409
 
410
                        if (opt->dst1opt) {
411
                                int dsthdrlen = ((opt->dst1opt->hdrlen+1)<<3);
412
 
413
                                opt->opt_nflen += dsthdrlen;
414
                                opt->dst0opt = opt->dst1opt;
415
                                opt->dst1opt = NULL;
416
                                opt->opt_flen -= dsthdrlen;
417
                        }
418
 
419
                        break;
420
 
421
                case IPV6_HOPLIMIT:
422
                        if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
423
                                err = -EINVAL;
424
                                goto exit_f;
425
                        }
426
 
427
                        *hlimit = *(int *)CMSG_DATA(cmsg);
428
                        break;
429
 
430
                default:
431
                        if (net_ratelimit())
432
                                printk(KERN_DEBUG "invalid cmsg type: %d\n", cmsg->cmsg_type);
433
                        err = -EINVAL;
434
                        break;
435
                };
436
        }
437
 
438
exit_f:
439
        return err;
440
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.