Annotation of embedaddon/freevrrpd/vrrp_network.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (c) 2001,2002 Sebastien Petit <spe@bsdfr.org>
! 3: *
! 4: * Redistribution and use in source forms, with and without modification,
! 5: * are permitted provided that the following conditions are met:
! 6: * 1. Redistributions of source code must retain the above copyright notice,
! 7: * this list of conditions and the following disclaimer.
! 8: * 2. Redistributions in binary form must reproduce the above copyright notice,
! 9: * this list of conditions and the following disclaimer in the documentation
! 10: * and/or other materials provided with the distribution. Obviously, it
! 11: * would be nice if you gave credit where credit is due but requiring it
! 12: * would be too onerous.
! 13: * 3. All advertising materials mentioning features or use of this software
! 14: * must display the following acknowledgement:
! 15: * This product includes software developed by Sebastien Petit.
! 16: * 4. Neither the name of its contributors may be used to endorse or promote
! 17: * products derived from this software without specific prior written
! 18: * permission.
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 30: * SUCH DAMAGE.
! 31: *
! 32: * $Id: vrrp_network.c,v 1.27 2004/04/04 19:45:46 rival Exp $
! 33: */
! 34:
! 35: #include <errno.h>
! 36: #include <sys/param.h>
! 37: #include "vrrp_network.h"
! 38: #include "vrrp_ah.h"
! 39:
! 40: u_short ip_id;
! 41:
! 42: /* Initialisation pour l'identification IP */
! 43: void
! 44: vrrp_network_initialize(void)
! 45: {
! 46: srand(time(NULL));
! 47: ip_id = random() % 65535;
! 48:
! 49: return;
! 50: }
! 51:
! 52: /* Open VRRP socket for reading */
! 53: char
! 54: vrrp_network_open_socket(struct vrrp_vr * vr)
! 55: {
! 56: struct timeval timeout;
! 57: int hincl = 1;
! 58:
! 59: vr->sd = socket(AF_INET, SOCK_RAW, IPPROTO_VRRP);
! 60: if (vr->sd == -1) {
! 61: syslog(LOG_ERR, "cannot open raw socket for VRRP protocol [ AF_INET, SOCK_RAW, IPPROTO_VRRP ]: %s", strerror(errno));
! 62: return -1;
! 63: }
! 64: if (setsockopt(vr->sd, IPPROTO_IP, IP_HDRINCL, &hincl, sizeof(hincl))) {
! 65: syslog(LOG_ERR, "cannot set IP_HDRINCL option on the IPPROTO_IP raw socket: %s", strerror(errno));
! 66: return -1;
! 67: }
! 68: timeout.tv_sec = 0;
! 69: timeout.tv_usec = 100000;
! 70: if (setsockopt(vr->sd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) == -1) {
! 71: syslog(LOG_ERR, "cannot set SO_RCVTIMEO option on the IPPROTO_VRRP raw socket: %s", strerror(errno));
! 72: return -1;
! 73: }
! 74:
! 75: return 0;
! 76: }
! 77:
! 78: ssize_t
! 79: vrrp_network_send_packet(char *buffer, int sizebuf, int sd, int log)
! 80: {
! 81: struct sockaddr_in addr;
! 82: ssize_t octets;
! 83:
! 84: addr.sin_family = AF_INET;
! 85: addr.sin_port = 0;
! 86: addr.sin_len = sizeof(struct sockaddr_in);
! 87: addr.sin_addr.s_addr = inet_addr(VRRP_MULTICAST_IP);
! 88: octets = sendto(sd, buffer, sizebuf, 0, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
! 89: if (octets < 0) {
! 90: if (log)
! 91: syslog(LOG_ERR, "can't write to socket: %s", strerror(errno));
! 92: return -1;
! 93: }
! 94:
! 95: return octets;
! 96: }
! 97:
! 98: u_int
! 99: vrrp_network_vrrphdr_len(struct vrrp_vr * vr)
! 100: {
! 101: u_int len = sizeof(struct vrrp_hdr);
! 102:
! 103: len += (vr->cnt_ip << 2) + VRRP_AUTH_DATA_LEN;
! 104:
! 105: return len;
! 106: }
! 107:
! 108: void
! 109: vrrp_network_init_iphdr(char *buffer, struct vrrp_vr * vr)
! 110: {
! 111: struct ip *iph = (struct ip *)buffer;
! 112:
! 113: iph->ip_hl = 5;
! 114: iph->ip_v = 4;
! 115: iph->ip_tos = 0;
! 116: #if (defined(__FreeBSD__) && (__FreeBSD_version < 1100030)) || defined(__NetBSD__)
! 117: iph->ip_len = sizeof(struct ip) + vrrp_network_vrrphdr_len(vr) + vrrp_ah_ahhdr_len(vr);
! 118: #else
! 119: iph->ip_len = htons(sizeof(struct ip) + vrrp_network_vrrphdr_len(vr) + vrrp_ah_ahhdr_len(vr));
! 120: #endif
! 121: /* iph->ip_id = ++ip_id; */
! 122: iph->ip_off = 0;
! 123: iph->ip_ttl = VRRP_MULTICAST_TTL;
! 124: #ifdef ENABLE_VRRP_AH
! 125: if (vr->AHencryption == 1)
! 126: iph->ip_p = IPPROTO_AH;
! 127: else
! 128: iph->ip_p = IPPROTO_VRRP;
! 129: #else
! 130: iph->ip_p = IPPROTO_VRRP;
! 131: #endif
! 132: iph->ip_src.s_addr = vr->vr_if->ip_addrs[0].s_addr;
! 133: iph->ip_dst.s_addr = inet_addr(VRRP_MULTICAST_IP);
! 134: iph->ip_sum = vrrp_misc_compute_checksum((u_short *) iph, iph->ip_hl << 2);
! 135:
! 136: return;
! 137: }
! 138:
! 139: void
! 140: vrrp_network_init_vrrphdr(char *buffer, struct vrrp_vr * vr)
! 141: {
! 142: struct vrrp_hdr *vp;
! 143: struct in_addr *addr;
! 144: char *password;
! 145: int cpt;
! 146:
! 147: vp = (struct vrrp_hdr *)buffer;
! 148: vp->vrrp_v = VRRP_PROTOCOL_VERSION;
! 149: vp->vrrp_t = VRRP_PROTOCOL_ADVERTISEMENT;
! 150: vp->vr_id = vr->vr_id;
! 151: vp->priority = vr->priority;
! 152: vp->cnt_ip = vr->cnt_ip;
! 153: vp->auth_type = vr->auth_type;
! 154: vp->adv_int = vr->adv_int;
! 155: addr = (struct in_addr *) & buffer[sizeof(struct vrrp_hdr)];
! 156: for (cpt = 0; cpt < vr->cnt_ip; cpt++) {
! 157: addr[cpt].s_addr = vr->vr_ip[cpt].addr.s_addr;
! 158: }
! 159: if (vr->auth_type == 1) {
! 160: password = (char *)&addr[vr->cnt_ip];
! 161: strncpy(password, vr->password, 8);
! 162: }
! 163: vp->csum = vrrp_misc_compute_checksum((u_short *) vp, vrrp_network_vrrphdr_len(vr));
! 164:
! 165: return;
! 166: }
! 167:
! 168: char
! 169: vrrp_network_send_advertisement(struct vrrp_vr * vr)
! 170: {
! 171: u_char *buffer;
! 172: #ifdef ENABLE_VRRP_AH
! 173: u_int len = sizeof(struct ip) + vrrp_ah_ahhdr_len(vr) + vrrp_network_vrrphdr_len(vr);
! 174: #else
! 175: u_int len = sizeof(struct ip) + vrrp_network_vrrphdr_len(vr);
! 176: #endif
! 177: ssize_t bytes = 0;
! 178:
! 179: buffer = (u_char *) malloc(len);
! 180: bzero(buffer, len);
! 181:
! 182: vrrp_network_init_iphdr(buffer, vr);
! 183: #ifdef ENABLE_VRRP_AH
! 184: /* add AH adding code */
! 185: if (vr->AHencryption == 1) {
! 186: vrrp_ah_init_ahhdr(buffer,vr);
! 187: vrrp_network_init_vrrphdr(&buffer[sizeof(struct ip)+vrrp_ah_ahhdr_len(vr)], vr);
! 188: vrrp_ah_hmacmd5(buffer,vr);
! 189: } else
! 190: vrrp_network_init_vrrphdr(&buffer[sizeof(struct ip)+vrrp_ah_ahhdr_len(vr)], vr);
! 191: #else
! 192: vrrp_network_init_vrrphdr(&buffer[sizeof(struct ip)], vr);
! 193: #endif
! 194:
! 195: if (vr->fault)
! 196: bytes = vrrp_network_send_packet(buffer, len, vr->sd, 0);
! 197: else
! 198: bytes = vrrp_network_send_packet(buffer, len, vr->sd, 1);
! 199:
! 200: if (bytes < 0) {
! 201: syslog(LOG_ERR, "There is a big problem here !");
! 202: vr->fault = 1;
! 203: free(buffer);
! 204: return -1;
! 205: }
! 206: vr->fault = 0;
! 207: free(buffer);
! 208:
! 209: return 0;
! 210: }
! 211:
! 212: int
! 213: vrrp_network_open_bpf(char *if_name)
! 214: {
! 215: struct ifreq ifr;
! 216: int n = 0;
! 217: char device[16];
! 218: int sd = 0;
! 219: int yes = 1;
! 220:
! 221: while ((sd <= 0) && (n < 100)) {
! 222: snprintf(device, sizeof(device), "/dev/bpf%d", n++);
! 223: sd = open(device, O_WRONLY);
! 224: }
! 225: if (sd < 0) {
! 226: syslog(LOG_ERR, "cannot found a valid /dev/bpf* entry, do you have bpf in kernel ?");
! 227: syslog(LOG_ERR, "perhaps you've not created /dev entry on your chroot directory with bpf* entries");
! 228: return -1;
! 229: }
! 230: bzero(&ifr, sizeof(ifr));
! 231: strncpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
! 232: if (ioctl(sd, BIOCSETIF, (caddr_t)&ifr) < 0) {
! 233: syslog(LOG_ERR, "interface %s doesn't seem to exist, ioctl: %s\n", strerror(errno), ifr.ifr_name);
! 234: syslog(LOG_ERR, "you must correct your configuration file with a good option for 'interface ='");
! 235: return -1;
! 236: }
! 237: if (ioctl(sd, BIOCSHDRCMPLT, &yes) < 0) {
! 238: syslog(LOG_ERR, "cannot do BIOCSHDRCMPLT: %s", strerror(errno));
! 239: syslog(LOG_ERR, "something is terribly wrong, I can't continue");
! 240: return -1;
! 241: }
! 242:
! 243: return sd;
! 244: }
! 245:
! 246: int
! 247: vrrp_network_send_gratuitous_arp(char *if_name, struct ether_addr *ethaddr, struct in_addr addr)
! 248: {
! 249: char buffer[ETHER_HDR_LEN + sizeof(struct arp_header)];
! 250: struct ether_header *ethhdr = (struct ether_header *) buffer;
! 251: struct arp_header *arph = (struct arp_header *) & buffer[ETHER_HDR_LEN];
! 252: int sd;
! 253:
! 254: memset(ethhdr->ether_dhost, 0xFF, ETHER_ADDR_LEN);
! 255: bcopy(ethaddr, ethhdr->ether_shost, ETHER_ADDR_LEN);
! 256: ethhdr->ether_type = htons(ETHERTYPE_ARP);
! 257: bzero(arph, sizeof(*arph));
! 258: arph->ar_hrd = htons(ARPHRD_ETHER);
! 259: arph->ar_pro = htons(ETHERTYPE_IP);
! 260: arph->ar_hln = ETHER_ADDR_LEN;
! 261: arph->ar_pln = 4;
! 262: arph->ar_op = htons(ARPOP_REQUEST);
! 263: memcpy(arph->ar_sha, ethhdr->ether_shost, ETHER_ADDR_LEN);
! 264: sd = vrrp_network_open_bpf(if_name);
! 265: if (sd == -1)
! 266: return -1;
! 267: memcpy(arph->ar_spa, &addr, sizeof(struct in_addr));
! 268: memcpy(arph->ar_tpa, &addr, sizeof(struct in_addr));
! 269: if (write(sd, buffer, ETHER_HDR_LEN + sizeof(struct arp_header)) == -1) {
! 270: syslog(LOG_ERR, "cannot write on socket descriptor sd: %s", strerror(errno));
! 271: close(sd);
! 272: return -1;
! 273: }
! 274: close(sd);
! 275:
! 276: return 0;
! 277: }
! 278:
! 279: int
! 280: vrrp_network_send_gratuitous_arp_ips(struct vrrp_vr * vr, struct ether_addr * ethaddr)
! 281: {
! 282: int cpt = 0;
! 283: struct in_addr addrs[MAX_IP_ALIAS];
! 284: int size = MAX_IP_ALIAS;
! 285: char coderet = 0;
! 286:
! 287: bzero(addrs, sizeof(addrs));
! 288: vrrp_misc_get_if_infos(vr->vr_if->if_name, NULL, addrs, &size);
! 289: while (addrs[cpt].s_addr) {
! 290: coderet = vrrp_network_send_gratuitous_arp(vr->vr_if->if_name, ethaddr, addrs[cpt]);
! 291: syslog(LOG_ERR, "send gratuitous arp %s -> %x:%x:%x:%x:%x:%x", inet_ntoa(addrs[cpt]), ethaddr->octet[0], ethaddr->octet[1], ethaddr->octet[2], ethaddr->octet[3], ethaddr->octet[4], ethaddr->octet[5]);
! 292: cpt++;
! 293: }
! 294:
! 295: return coderet;
! 296: }
! 297:
! 298: #define rtm rtmsg.rthdr
! 299: char
! 300: vrrp_network_delete_local_route(struct in_addr addr)
! 301: {
! 302: struct routemsg rtmsg;
! 303: int sd;
! 304:
! 305: sd = socket(PF_ROUTE, SOCK_RAW, 0);
! 306: if (sd == -1) {
! 307: close(sd);
! 308: return -1;
! 309: }
! 310: bzero(&rtmsg, sizeof(rtmsg));
! 311: rtm.rtm_type = RTM_DELETE;
! 312: rtm.rtm_version = RTM_VERSION;
! 313: #ifdef __FreeBSD__
! 314: rtm.rtm_flags = RTF_UP | RTF_HOST | RTF_LOCAL;
! 315: #endif
! 316: #if __FreeBSD_version < 800059
! 317: rtm.rtm_flags |= RTF_WASCLONED;
! 318: #endif
! 319: #ifdef __NetBSD__
! 320: rtm.rtm_flags = RTF_UP | RTF_HOST | RTF_CLONED;
! 321: #endif
! 322: rtm.rtm_addrs = RTA_DST;
! 323: rtm.rtm_msglen = sizeof(rtmsg);
! 324: rtmsg.addr.sin_len = sizeof(rtmsg.addr);
! 325: rtmsg.addr.sin_family = AF_INET;
! 326: rtmsg.addr.sin_addr = addr;
! 327: if (write(sd, &rtmsg, sizeof(rtmsg)) == -1) {
! 328: close(sd);
! 329: return -1;
! 330: }
! 331: close(sd);
! 332:
! 333: return 0;
! 334: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to vrrp_network.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / freevrrpd