source: rtems/cpukit/libnetworking/netinet/raw_ip.c @ 657e6c93

Last change on this file since 657e6c93 was 657e6c93, checked in by Christian Mauderer <Christian.Mauderer@…>, on Jun 24, 2016 at 5:57:17 AM

libnetworking: Import current <netinet/in.h>

Import the <netinet/in.h> from current FreeBSD. This allows to build
some current software (e.g. libressl).

Add legacy support like

  • prototype for in_cksum(),
  • IPPORT_USERRESERVED,
  • deprecated IPCTL_RT* defines,
  • ip_fw_chk_t and ip_fw_ctl_t,
  • ip_nat_... (IP NAT hooks), and
  • IP_NAT option for get/setsockopt()

to new <rtems/rtems_netinet_in.h>.

  • Property mode set to 100644
File size: 11.3 KB
Line 
1/*
2 * Copyright (c) 1982, 1986, 1988, 1993
3 *      The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 *      @(#)raw_ip.c    8.7 (Berkeley) 5/15/95
30 * $FreeBSD: src/sys/netinet/raw_ip.c,v 1.147 2005/01/07 01:45:45 imp Exp $
31 */
32
33
34#ifdef HAVE_CONFIG_H
35#include "config.h"
36#endif
37 
38#include "opt_inet6.h"
39#include "opt_ipsec.h"
40#include "opt_mac.h"
41
42#include <sys/param.h>
43#include <sys/queue.h>
44#include <sys/malloc.h>
45#include <sys/mbuf.h>
46#include <sys/socket.h>
47#include <sys/protosw.h>
48#include <sys/socketvar.h>
49#include <errno.h>
50#include <sys/systm.h>
51
52#include <net/if.h>
53#include <net/route.h>
54
55#define _IP_VHL
56#include <netinet/in.h>
57#include <rtems/rtems_netinet_in.h>
58#include <netinet/in_systm.h>
59#include <netinet/in_pcb.h>
60#include <netinet/in_var.h>
61#include <netinet/ip.h>
62#include <netinet/ip_var.h>
63#include <netinet/ip_mroute.h>
64
65#include <netinet/ip_fw.h>
66
67#if !defined(COMPAT_IPFW) || COMPAT_IPFW == 1
68#undef COMPAT_IPFW
69#define COMPAT_IPFW 1
70#else
71#undef COMPAT_IPFW
72#endif
73
74static struct inpcbhead ripcb;
75static struct inpcbinfo ripcbinfo;
76
77/*
78 * Nominal space allocated to a raw ip socket.
79 */
80#define RIPSNDQ         8192
81#define RIPRCVQ         8192
82
83/*
84 * Raw interface to IP protocol.
85 */
86
87/*
88 * Initialize raw connection block q.
89 */
90void
91rip_init(void)
92{
93        LIST_INIT(&ripcb);
94        ripcbinfo.listhead = &ripcb;
95        /*
96         * XXX We don't use the hash list for raw IP, but it's easier
97         * to allocate a one entry hash list than it is to check all
98         * over the place for hashbase == NULL.
99         */
100        ripcbinfo.hashbase = hashinit(1, M_PCB, &ripcbinfo.hashmask);
101}
102
103static struct   sockaddr_in ripsrc = { sizeof(ripsrc), AF_INET, 0, {0}, {0} };
104/*
105 * Setup generic address and protocol structures
106 * for raw_input routine, then pass them along with
107 * mbuf chain.
108 */
109void
110rip_input(struct mbuf *m, int iphlen)
111{
112        struct ip *ip = mtod(m, struct ip *);
113        register struct inpcb *inp;
114        struct inpcb *last = 0;
115        struct mbuf *opts = 0;
116
117        ripsrc.sin_addr = ip->ip_src;
118        for (inp = ripcb.lh_first; inp != NULL; inp = inp->inp_list.le_next) {
119                if (inp->inp_ip_p && inp->inp_ip_p != ip->ip_p)
120                        continue;
121                if (inp->inp_laddr.s_addr &&
122                  inp->inp_laddr.s_addr != ip->ip_dst.s_addr)
123                        continue;
124                if (inp->inp_faddr.s_addr &&
125                  inp->inp_faddr.s_addr != ip->ip_src.s_addr)
126                        continue;
127                if (last) {
128                        struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);
129                        if (n) {
130                                if (last->inp_flags & INP_CONTROLOPTS ||
131                                    last->inp_socket->so_options & SO_TIMESTAMP)
132                                    ip_savecontrol(last, &opts, ip, n);
133                                if (sbappendaddr(&last->inp_socket->so_rcv,
134                                    (struct sockaddr *)&ripsrc, n,
135                                    opts) == 0) {
136                                        /* should notify about lost packet */
137                                        m_freem(n);
138                                        if (opts)
139                                            m_freem(opts);
140                                } else
141                                        sorwakeup(last->inp_socket);
142                                opts = 0;
143                        }
144                }
145                last = inp;
146        }
147        if (last) {
148                if (last->inp_flags & INP_CONTROLOPTS ||
149                    last->inp_socket->so_options & SO_TIMESTAMP)
150                        ip_savecontrol(last, &opts, ip, m);
151                if (sbappendaddr(&last->inp_socket->so_rcv,
152                    (struct sockaddr *)&ripsrc, m, opts) == 0) {
153                        m_freem(m);
154                        if (opts)
155                            m_freem(opts);
156                } else
157                        sorwakeup(last->inp_socket);
158        } else {
159                m_freem(m);
160              ipstat.ips_noproto++;
161              ipstat.ips_delivered--;
162      }
163}
164
165/*
166 * Generate IP header and pass packet to ip_output.
167 * Tack on options user may have setup with control call.
168 */
169int
170rip_output(struct mbuf *m, struct socket *so, u_long dst)
171{
172        struct ip *ip;
173        struct inpcb *inp = sotoinpcb(so);
174        int flags = ((so->so_options & SO_DONTROUTE) ? IP_ROUTETOIF : 0) |
175            IP_ALLOWBROADCAST;
176
177        /*
178         * If the user handed us a complete IP packet, use it.
179         * Otherwise, allocate an mbuf for a header and fill it in.
180         */
181        if ((inp->inp_flags & INP_HDRINCL) == 0) {
182                if (m->m_pkthdr.len + sizeof(struct ip) > IP_MAXPACKET) {
183                        m_freem(m);
184                        return(EMSGSIZE);
185                }
186                M_PREPEND(m, sizeof(struct ip), M_WAIT);
187                ip = mtod(m, struct ip *);
188                ip->ip_tos = 0;
189                ip->ip_off = 0;
190                ip->ip_p = inp->inp_ip_p;
191                ip->ip_len = m->m_pkthdr.len;
192                ip->ip_src = inp->inp_laddr;
193                ip->ip_dst.s_addr = dst;
194                ip->ip_ttl = MAXTTL;
195        } else {
196                if (m->m_pkthdr.len > IP_MAXPACKET) {
197                        m_freem(m);
198                        return(EMSGSIZE);
199                }
200                ip = mtod(m, struct ip *);
201                /* don't allow both user specified and setsockopt options,
202                   and don't allow packet length sizes that will crash */
203#ifdef _IP_VHL
204                if (((IP_VHL_HL(ip->ip_vhl) != (sizeof (*ip) >> 2)) 
205                     && inp->inp_options)
206                    || (ip->ip_len > m->m_pkthdr.len)
207                    || (ip->ip_len < (IP_VHL_HL(ip->ip_vhl) << 2))) {
208#else
209                if (((ip->ip_hl != (sizeof (*ip) >> 2))
210                     && inp->inp_options)
211                    || (ip->ip_len > m->m_pkthdr.len)
212                    || (ip->ip_len < (ip->ip_hl << 2))) {
213#endif
214                        m_freem(m);
215                        return EINVAL;
216                }
217                if (ip->ip_id == 0)
218                        ip->ip_id = htons(ip_id++);
219                /* XXX prevent ip_output from overwriting header fields */
220                flags |= IP_RAWOUTPUT;
221                ipstat.ips_rawout++;
222        }
223        return (ip_output(m, inp->inp_options, &inp->inp_route, flags,
224                          inp->inp_moptions));
225}
226
227/*
228 * Raw IP socket option processing.
229 */
230int
231rip_ctloutput(int op, struct socket *so, int level, int optname,
232        struct mbuf **m)
233{
234        struct inpcb *inp = sotoinpcb(so);
235        int error;
236
237        if (level != IPPROTO_IP) {
238                if (op == PRCO_SETOPT && *m)
239                        (void)m_free(*m);
240                return (EINVAL);
241        }
242
243        switch (optname) {
244
245        case IP_HDRINCL:
246                error = 0;
247                if (op == PRCO_SETOPT) {
248                        if (m == 0 || *m == 0 || (*m)->m_len < sizeof (int))
249                                error = EINVAL;
250                        else if (*mtod(*m, int *))
251                                inp->inp_flags |= INP_HDRINCL;
252                        else
253                                inp->inp_flags &= ~INP_HDRINCL;
254                        if (*m)
255                                (void)m_free(*m);
256                } else {
257                        *m = m_get(M_WAIT, MT_SOOPTS);
258                        (*m)->m_len = sizeof (int);
259                        *mtod(*m, int *) = inp->inp_flags & INP_HDRINCL;
260                }
261                return (error);
262
263#ifdef COMPAT_IPFW
264        case IP_FW_GET:
265                if (ip_fw_ctl_ptr == NULL || op == PRCO_SETOPT) {
266                        if (*m) (void)m_free(*m);
267                        return(EINVAL);
268                }
269                return (*ip_fw_ctl_ptr)(optname, m); 
270
271        case IP_FW_ADD:
272        case IP_FW_DEL:
273        case IP_FW_FLUSH:
274        case IP_FW_ZERO:
275                if (ip_fw_ctl_ptr == NULL || op != PRCO_SETOPT) {
276                        if (*m) (void)m_free(*m);
277                        return(EINVAL);
278                }
279                return (*ip_fw_ctl_ptr)(optname, m); 
280
281        case IP_NAT:
282                if (ip_nat_ctl_ptr == NULL) {
283                        if (*m) (void)m_free(*m);
284                        return(EINVAL);
285                }
286                return (*ip_nat_ctl_ptr)(op, m); 
287
288#endif
289        case IP_RSVP_ON:
290                return ip_rsvp_init(so);
291                break;
292
293        case IP_RSVP_OFF:
294                return ip_rsvp_done();
295                break;
296
297        case IP_RSVP_VIF_ON:
298                return ip_rsvp_vif_init(so, *m);
299
300        case IP_RSVP_VIF_OFF:
301                return ip_rsvp_vif_done(so, *m);
302
303        case MRT_INIT:
304        case MRT_DONE:
305        case MRT_ADD_VIF:
306        case MRT_DEL_VIF:
307        case MRT_ADD_MFC:
308        case MRT_DEL_MFC:
309        case MRT_VERSION:
310        case MRT_ASSERT:
311                if (op == PRCO_SETOPT) {
312                        error = ip_mrouter_set(optname, so, *m);
313                        if (*m)
314                                (void)m_free(*m);
315                } else if (op == PRCO_GETOPT) {
316                        error = ip_mrouter_get(optname, so, m);
317                } else
318                        error = EINVAL;
319                return (error);
320        }
321        return (ip_ctloutput(op, so, level, optname, m));
322}
323
324static u_long   rip_sendspace = RIPSNDQ; /* XXX sysctl ? */
325static u_long   rip_recvspace = RIPRCVQ; /* XXX sysctl ? */
326
327/*ARGSUSED*/
328int
329rip_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
330        struct mbuf *control)
331{
332        register int error = 0;
333        register struct inpcb *inp = sotoinpcb(so);
334        int s;
335
336        if (req == PRU_CONTROL)
337                return (in_control(so, (uintptr_t)m, (caddr_t)nam,
338                        (struct ifnet *)control));
339
340        switch (req) {
341
342        case PRU_ATTACH:
343                if (inp)
344                        panic("rip_attach");
345                if ((so->so_state & SS_PRIV) == 0) {
346                        error = EACCES;
347                        break;
348                }
349                s = splnet();
350                error = in_pcballoc(so, &ripcbinfo);
351                splx(s);
352                if (error)
353                        break;
354                error = soreserve(so, rip_sendspace, rip_recvspace);
355                if (error)
356                        break;
357                inp = (struct inpcb *)so->so_pcb;
358                inp->inp_ip_p = (uintptr_t)nam;
359                break;
360
361        case PRU_DISCONNECT:
362                if ((so->so_state & SS_ISCONNECTED) == 0) {
363                        error = ENOTCONN;
364                        break;
365                }
366                /* FALLTHROUGH */
367        case PRU_ABORT:
368                soisdisconnected(so);
369                /* FALLTHROUGH */
370        case PRU_DETACH:
371                if (inp == 0)
372                        panic("rip_detach");
373                if (so == ip_mrouter)
374                        ip_mrouter_done();
375                ip_rsvp_force_done(so);
376                if (so == ip_rsvpd)
377                        ip_rsvp_done();
378                in_pcbdetach(inp);
379                break;
380
381        case PRU_BIND:
382            {
383                struct sockaddr_in *addr = mtod(nam, struct sockaddr_in *);
384
385                if (nam->m_len != sizeof(*addr)) {
386                        error = EINVAL;
387                        break;
388                }
389                if ((ifnet == 0) ||
390                    ((addr->sin_family != AF_INET) &&
391                     (addr->sin_family != AF_IMPLINK)) ||
392                    (addr->sin_addr.s_addr &&
393                     ifa_ifwithaddr((struct sockaddr *)addr) == 0)) {
394                        error = EADDRNOTAVAIL;
395                        break;
396                }
397                inp->inp_laddr = addr->sin_addr;
398                break;
399            }
400        case PRU_CONNECT:
401            {
402                struct sockaddr_in *addr = mtod(nam, struct sockaddr_in *);
403
404                if (nam->m_len != sizeof(*addr)) {
405                        error = EINVAL;
406                        break;
407                }
408                if (ifnet == 0) {
409                        error = EADDRNOTAVAIL;
410                        break;
411                }
412                if ((addr->sin_family != AF_INET) &&
413                     (addr->sin_family != AF_IMPLINK)) {
414                        error = EAFNOSUPPORT;
415                        break;
416                }
417                inp->inp_faddr = addr->sin_addr;
418                soisconnected(so);
419                break;
420            }
421
422        case PRU_CONNECT2:
423                error = EOPNOTSUPP;
424                break;
425
426        /*
427         * Mark the connection as being incapable of further input.
428         */
429        case PRU_SHUTDOWN:
430                socantsendmore(so);
431                break;
432
433        /*
434         * Ship a packet out.  The appropriate raw output
435         * routine handles any massaging necessary.
436         */
437        case PRU_SEND:
438            {
439                register u_long dst;
440
441                if (so->so_state & SS_ISCONNECTED) {
442                        if (nam) {
443                                error = EISCONN;
444                                break;
445                        }
446                        dst = inp->inp_faddr.s_addr;
447                } else {
448                        if (nam == NULL) {
449                                error = ENOTCONN;
450                                break;
451                        }
452                        dst = mtod(nam, struct sockaddr_in *)->sin_addr.s_addr;
453                }
454                error = rip_output(m, so, dst);
455                m = NULL;
456                break;
457            }
458
459        case PRU_SENSE:
460                /*
461                 * stat: don't bother with a blocksize.
462                 */
463                return (0);
464
465        /*
466         * Not supported.
467         */
468        case PRU_RCVOOB:
469        case PRU_RCVD:
470        case PRU_LISTEN:
471        case PRU_ACCEPT:
472        case PRU_SENDOOB:
473                error = EOPNOTSUPP;
474                break;
475
476        case PRU_SOCKADDR:
477                in_setsockaddr(inp, nam);
478                break;
479
480        case PRU_PEERADDR:
481                in_setpeeraddr(inp, nam);
482                break;
483
484        default:
485                panic("rip_usrreq");
486        }
487        if (m != NULL)
488                m_freem(m);
489        return (error);
490}
Note: See TracBrowser for help on using the repository browser.