static void dhcprelay_loop(int *fds, int num_sockets, int max_socket, char **clients, struct sockaddr_in *server_addr, uint32_t gw_ip) { struct dhcpMessage dhcp_msg; fd_set rfds; size_t packlen; socklen_t addr_size; struct sockaddr_in client_addr; struct timeval tv; int i; while (!dhcprelay_stopflag) { FD_ZERO(&rfds); for (i = 0; i < num_sockets; i++) FD_SET(fds[i], &rfds); tv.tv_sec = SELECT_TIMEOUT; tv.tv_usec = 0; if (select(max_socket + 1, &rfds, NULL, NULL, &tv) > 0) { /* server */ if (FD_ISSET(fds[0], &rfds)) { packlen = udhcp_get_packet(&dhcp_msg, fds[0]); if (packlen > 0) { pass_back(&dhcp_msg, packlen, fds); } } for (i = 1; i < num_sockets; i++) { /* clients */ if (!FD_ISSET(fds[i], &rfds)) continue; addr_size = sizeof(struct sockaddr_in); packlen = recvfrom(fds[i], &dhcp_msg, sizeof(dhcp_msg), 0, (struct sockaddr *)(&client_addr), &addr_size); if (packlen <= 0) continue; if (read_interface(clients[i-1], NULL, &dhcp_msg.giaddr, NULL) < 0) dhcp_msg.giaddr = gw_ip; pass_on(&dhcp_msg, packlen, i, fds, &client_addr, server_addr); } } xid_expire(); } }
int dhcprelay_main(int argc UNUSED_PARAM, char **argv) { struct sockaddr_in server_addr; char **iface_list; int *fds; int num_sockets, max_socket; uint32_t our_nip; INIT_G(); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = htonl(INADDR_BROADCAST); server_addr.sin_port = htons(SERVER_PORT); /* dhcprelay CLIENT_IFACE1[,CLIENT_IFACE2...] SERVER_IFACE [SERVER_IP] */ if (!argv[1] || !argv[2]) bb_show_usage(); if (argv[3]) { if (!inet_aton(argv[3], &server_addr.sin_addr)) bb_perror_msg_and_die("bad server IP"); } iface_list = make_iface_list(argv + 1, &num_sockets); fds = xmalloc(num_sockets * sizeof(fds[0])); /* Create sockets and bind one to every iface */ max_socket = init_sockets(iface_list, num_sockets, fds); /* Get our IP on server_iface */ if (udhcp_read_interface(argv[2], NULL, &our_nip, NULL)) return 1; /* Main loop */ while (1) { // reinit stuff from time to time? go back to make_iface_list // every N minutes? fd_set rfds; struct timeval tv; int i; FD_ZERO(&rfds); for (i = 0; i < num_sockets; i++) FD_SET(fds[i], &rfds); tv.tv_sec = SELECT_TIMEOUT; tv.tv_usec = 0; if (select(max_socket + 1, &rfds, NULL, NULL, &tv) > 0) { int packlen; struct dhcp_packet dhcp_msg; /* server */ if (FD_ISSET(fds[0], &rfds)) { packlen = udhcp_recv_kernel_packet(&dhcp_msg, fds[0]); if (packlen > 0) { pass_to_client(&dhcp_msg, packlen, fds); } } /* clients */ for (i = 1; i < num_sockets; i++) { struct sockaddr_in client_addr; socklen_t addr_size; if (!FD_ISSET(fds[i], &rfds)) continue; addr_size = sizeof(client_addr); packlen = recvfrom(fds[i], &dhcp_msg, sizeof(dhcp_msg), 0, (struct sockaddr *)(&client_addr), &addr_size); if (packlen <= 0) continue; /* Get our IP on corresponding client_iface */ // RFC 1542 // 4.1 General BOOTP Processing for Relay Agents // 4.1.1 BOOTREQUEST Messages // If the relay agent does decide to relay the request, it MUST examine // the 'giaddr' ("gateway" IP address) field. If this field is zero, // the relay agent MUST fill this field with the IP address of the // interface on which the request was received. If the interface has // more than one IP address logically associated with it, the relay // agent SHOULD choose one IP address associated with that interface and // use it consistently for all BOOTP messages it relays. If the // 'giaddr' field contains some non-zero value, the 'giaddr' field MUST // NOT be modified. The relay agent MUST NOT, under any circumstances, // fill the 'giaddr' field with a broadcast address as is suggested in // [1] (Section 8, sixth paragraph). // but why? what if server can't route such IP? Client ifaces may be, say, NATed! // 4.1.2 BOOTREPLY Messages // BOOTP relay agents relay BOOTREPLY messages only to BOOTP clients. // It is the responsibility of BOOTP servers to send BOOTREPLY messages // directly to the relay agent identified in the 'giaddr' field. // (yeah right, unless it is impossible... see comment above) // Therefore, a relay agent may assume that all BOOTREPLY messages it // receives are intended for BOOTP clients on its directly-connected // networks. // // When a relay agent receives a BOOTREPLY message, it should examine // the BOOTP 'giaddr', 'yiaddr', 'chaddr', 'htype', and 'hlen' fields. // These fields should provide adequate information for the relay agent // to deliver the BOOTREPLY message to the client. // // The 'giaddr' field can be used to identify the logical interface from // which the reply must be sent (i.e., the host or router interface // connected to the same network as the BOOTP client). If the content // of the 'giaddr' field does not match one of the relay agent's // directly-connected logical interfaces, the BOOTREPLY message MUST be // silently discarded. if (udhcp_read_interface(iface_list[i], NULL, &dhcp_msg.gateway_nip, NULL)) { /* Fall back to our IP on server iface */ // this makes more sense! dhcp_msg.gateway_nip = our_nip; } // maybe dhcp_msg.hops++? drop packets with too many hops (RFC 1542 says 4 or 16)? pass_to_server(&dhcp_msg, packlen, i, fds, &client_addr, &server_addr); } } xid_expire(); } /* while (1) */ /* return 0; - not reached */ }