Return to ipip.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mrouted

Annotation of embedaddon/mrouted/ipip.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * The mrouted program is covered by the license in the accompanying file
        !             3:  * named "LICENSE".  Use of the mrouted program represents acceptance of
        !             4:  * the terms and conditions listed in that file.
        !             5:  *
        !             6:  * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
        !             7:  * Leland Stanford Junior University.
        !             8:  */
        !             9: 
        !            10: #include "defs.h"
        !            11: 
        !            12: /*
        !            13:  * Exported variables.
        !            14:  */
        !            15: #ifdef notyet
        !            16: int            raw_socket;                 /* socket for raw network I/O  */
        !            17: #endif
        !            18: /*
        !            19:  *XXX For now, we just use the IGMP socket to send packets.
        !            20:  * This is legal in BSD, because the protocol # is not checked
        !            21:  * on raw sockets.  The k_* interfaces need to gain a socket
        !            22:  * argument so that we can call them on the raw_socket also.
        !            23:  */
        !            24: #define        raw_socket      igmp_socket
        !            25: 
        !            26: /*
        !            27:  * Private variables.
        !            28:  */
        !            29: static int rawid = 0;
        !            30: 
        !            31: /*
        !            32:  * Open and initialize the raw socket.
        !            33:  */
        !            34: void init_ipip(void)
        !            35: {
        !            36: #ifdef notyet
        !            37:     if ((raw_socket = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
        !            38:        logit(LOG_ERR, errno, "Raw IP socket");
        !            39: #endif
        !            40: }
        !            41: 
        !            42: /*
        !            43:  * Allocate and fill in static IP header for encapsulating on a tunnel.
        !            44:  */
        !            45: void init_ipip_on_vif(struct uvif *v)
        !            46: {
        !            47:     struct ip *ip;
        !            48: 
        !            49:     ip = v->uv_encap_hdr = (struct ip *)malloc(sizeof(struct ip));
        !            50:     if (ip == NULL)
        !            51:        logit(LOG_ERR, 0, "out of memory");
        !            52:     memset(ip, 0, sizeof(struct ip));
        !            53:     /*
        !            54:      * Fields zeroed that aren't filled in later:
        !            55:      * - IP ID (let the kernel fill it in)
        !            56:      * - Offset (we don't send fragments)
        !            57:      * - Checksum (let the kernel fill it in)
        !            58:      */
        !            59:     ip->ip_v   = IPVERSION;
        !            60:     ip->ip_hl  = sizeof(struct ip) >> 2;
        !            61:     ip->ip_tos = 0xc0;         /* Internet Control */
        !            62:     ip->ip_ttl = MAXTTL;       /* applies to unicasts only */
        !            63:     ip->ip_p   = IPPROTO_IPIP;
        !            64:     ip->ip_src.s_addr = v->uv_lcl_addr;
        !            65:     ip->ip_dst.s_addr = v->uv_rmt_addr;
        !            66: }
        !            67: 
        !            68: /*
        !            69:  * Call build_igmp() to build an IGMP message in the output packet buffer.
        !            70:  * Then fill in the fields of the IP packet that build_igmp() left for the
        !            71:  * kernel to fill in, and encapsulate the original packet with the
        !            72:  * pre-created ip header for this vif.
        !            73:  */
        !            74: void send_ipip(u_int32 src, u_int32 dst, int type, int code, u_int32 group, int datalen, struct uvif *v)
        !            75: {
        !            76:     struct msghdr msg;
        !            77:     struct iovec iov[2];
        !            78:     struct sockaddr_in sdst;
        !            79:     struct ip *ip;
        !            80: 
        !            81:     build_igmp(src, dst, type, code, group, datalen);
        !            82:     ip = (struct ip *)send_buf;
        !            83:     ip->ip_id = htons(rawid++);
        !            84:     ip->ip_sum = 0;
        !            85:     ip->ip_sum = inet_cksum((u_int16_t *)ip, ip->ip_hl << 2);
        !            86: 
        !            87:     ip = v->uv_encap_hdr;
        !            88:     ip->ip_len = 2 * MIN_IP_HEADER_LEN + IGMP_MINLEN + datalen;
        !            89:     ip->ip_len = htons(ip->ip_len);
        !            90: 
        !            91:     memset(&sdst, 0, sizeof(sdst));
        !            92:     sdst.sin_family = AF_INET;
        !            93: #ifdef HAVE_SA_LEN
        !            94:     sdst.sin_len = sizeof(sdst);
        !            95: #endif
        !            96:     sdst.sin_addr = ip->ip_dst;
        !            97: 
        !            98:     iov[0].iov_base = (caddr_t)v->uv_encap_hdr;
        !            99:     iov[0].iov_len = sizeof(struct ip);
        !           100:     iov[1].iov_base = (caddr_t)send_buf;
        !           101:     iov[1].iov_len = MIN_IP_HEADER_LEN + IGMP_MINLEN + datalen;
        !           102: 
        !           103:     memset(&msg, 0, sizeof(msg));
        !           104:     msg.msg_name = (caddr_t)&sdst;
        !           105:     msg.msg_namelen = sizeof(sdst);
        !           106:     msg.msg_iov = iov;
        !           107:     msg.msg_iovlen = 2;
        !           108:     if (sendmsg(raw_socket, &msg, 0) < 0) {
        !           109:        if (errno == ENETDOWN)
        !           110:            check_vif_state();
        !           111:        else
        !           112:            logit(LOG_WARNING, errno,
        !           113:                "sendmsg to %s on %s",
        !           114:                inet_fmt(sdst.sin_addr.s_addr, s1, sizeof(s1)), inet_fmt(src, s2, sizeof(s2)));
        !           115:     }
        !           116: 
        !           117:     IF_DEBUG(DEBUG_PKT|igmp_debug_kind(type, code))
        !           118:     logit(LOG_DEBUG, 0, "SENT %s from %-15s to %s encaped to %s",
        !           119:        igmp_packet_kind(type, code), src == INADDR_ANY ? "INADDR_ANY" :
        !           120:                                 inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)),
        !           121:                                 inet_fmt(sdst.sin_addr.s_addr, s3, sizeof(s3)));
        !           122: }
        !           123: 
        !           124: /**
        !           125:  * Local Variables:
        !           126:  *  version-control: t
        !           127:  *  indent-tabs-mode: t
        !           128:  *  c-file-style: "ellemtel"
        !           129:  *  c-basic-offset: 4
        !           130:  * End:
        !           131:  */