union {
struct in_addr v4; //!< IPv4 address.
struct in6_addr v6; //!< IPv6 address.
- } ipaddr;
+ } addr;
uint8_t prefix; //!< Prefix length - Between 0-32 for IPv4 and 0-128 for IPv6.
uint32_t zone_id; //!< A host may have multiple link-local interfaces
//!< the scope ID allows the application to specify which of
switch (addr->af) {
case AF_INET:
- addr->ipaddr.v4 = fr_inaddr_mask(&addr->ipaddr.v4, prefix);
+ addr->addr.v4 = fr_inaddr_mask(&addr->addr.v4, prefix);
break;
case AF_INET6:
- addr->ipaddr.v6 = fr_in6addr_mask(&addr->ipaddr.v6, prefix);
+ addr->addr.v6 = fr_in6addr_mask(&addr->addr.v6, prefix);
break;
default:
if (af == AF_UNSPEC) af = AF_INET;
- if (!inet_pton(af, hostname, &(out->ipaddr))) return -1;
+ if (!inet_pton(af, hostname, &(out->addr))) return -1;
out->af = af;
return 0;
* No DNS lookups
*/
if (!fr_dns_lookups) {
- return inet_ntop(src->af, &(src->ipaddr), out, outlen);
+ return inet_ntop(src->af, &(src->addr), out, outlen);
}
if (!fr_ipaddr_to_sockaddr(src, 0, &ss, &salen)) {
* Allow '*' as the wildcard address usually 0.0.0.0
*/
if ((value[0] == '*') && (value[1] == '\0')) {
- out->ipaddr.v4.s_addr = htonl(INADDR_ANY);
+ out->addr.v4.s_addr = htonl(INADDR_ANY);
/*
* Convert things which are obviously integers to IP addresses
* IP address.
*/
} else if (is_integer(value) || ((value[0] == '0') && (value[1] == 'x'))) {
- out->ipaddr.v4.s_addr = htonl(strtoul(value, NULL, 0));
+ out->addr.v4.s_addr = htonl(strtoul(value, NULL, 0));
} else if (!resolve) {
- if (inet_pton(AF_INET, value, &out->ipaddr.v4.s_addr) <= 0) {
+ if (inet_pton(AF_INET, value, &out->addr.v4.s_addr) <= 0) {
fr_strerror_printf("Failed to parse IPv4 addreess string \"%s\"", value);
return -1;
}
*
* @todo we should allow hostnames to be parsed as prefixes.
*/
- if (ip_prefix_addr_from_str(&out->ipaddr.v4, buffer) <= 0) {
+ if (ip_prefix_addr_from_str(&out->addr.v4, buffer) <= 0) {
fr_strerror_printf("Failed to parse IPv4 prefix string \"%s\"", value);
return -1;
}
}
if (mask_bits && (mask < 32)) {
- out->ipaddr.v4 = fr_inaddr_mask(&out->ipaddr.v4, mask);
+ out->addr.v4 = fr_inaddr_mask(&out->addr.v4, mask);
}
out->prefix = (uint8_t) mask;
* Allow '*' as the wildcard address
*/
if ((value[0] == '*') && (value[1] == '\0')) {
- memset(out->ipaddr.v6.s6_addr, 0, sizeof(out->ipaddr.v6.s6_addr));
+ memset(out->addr.v6.s6_addr, 0, sizeof(out->addr.v6.s6_addr));
} else if (!resolve) {
- if (inet_pton(AF_INET6, value, out->ipaddr.v6.s6_addr) <= 0) {
+ if (inet_pton(AF_INET6, value, out->addr.v6.s6_addr) <= 0) {
fr_strerror_printf("Failed to parse IPv6 address string \"%s\"", value);
return -1;
}
buffer[p - value] = '\0';
if (!resolve) {
- if (inet_pton(AF_INET6, buffer, out->ipaddr.v6.s6_addr) <= 0) {
+ if (inet_pton(AF_INET6, buffer, out->addr.v6.s6_addr) <= 0) {
fr_strerror_printf("Failed to parse IPv6 address string \"%s\"", value);
return -1;
}
if (mask && (prefix < 128)) {
struct in6_addr addr;
- addr = fr_in6addr_mask(&out->ipaddr.v6, prefix);
- memcpy(out->ipaddr.v6.s6_addr, addr.s6_addr, sizeof(out->ipaddr.v6.s6_addr));
+ addr = fr_in6addr_mask(&out->addr.v6, prefix);
+ memcpy(out->addr.v6.s6_addr, addr.s6_addr, sizeof(out->addr.v6.s6_addr));
}
out->prefix = (uint8_t) prefix;
char *p;
size_t len;
- if (inet_ntop(addr->af, &addr->ipaddr, out, outlen) == NULL) return NULL;
+ if (inet_ntop(addr->af, &addr->addr, out, outlen) == NULL) return NULL;
if ((addr->af == AF_INET) || (addr->zone_id == 0)) return out;
switch (a->af) {
case AF_INET:
- return memcmp(&a->ipaddr.v4,
- &b->ipaddr.v4,
- sizeof(a->ipaddr.v4));
+ return memcmp(&a->addr.v4,
+ &b->addr.v4,
+ sizeof(a->addr.v4));
#ifdef HAVE_STRUCT_SOCKADDR_IN6
case AF_INET6:
if (a->zone_id < b->zone_id) return -1;
if (a->zone_id > b->zone_id) return +1;
- return memcmp(&a->ipaddr.v6,
- &b->ipaddr.v6,
- sizeof(a->ipaddr.v6));
+ return memcmp(&a->addr.v6,
+ &b->addr.v6,
+ sizeof(a->addr.v6));
#endif
default:
memset(&s4, 0, sizeof(s4));
s4.sin_family = AF_INET;
- s4.sin_addr = ipaddr->ipaddr.v4;
+ s4.sin_addr = ipaddr->addr.v4;
s4.sin_port = htons(port);
memset(sa, 0, sizeof(*sa));
memcpy(sa, &s4, sizeof(s4));
memset(&s6, 0, sizeof(s6));
s6.sin6_family = AF_INET6;
- s6.sin6_addr = ipaddr->ipaddr.v6;
+ s6.sin6_addr = ipaddr->addr.v6;
s6.sin6_port = htons(port);
s6.sin6_scope_id = ipaddr->zone_id;
memset(sa, 0, sizeof(*sa));
memcpy(&s4, sa, sizeof(s4));
ipaddr->af = AF_INET;
ipaddr->prefix = 32;
- ipaddr->ipaddr.v4 = s4.sin_addr;
+ ipaddr->addr.v4 = s4.sin_addr;
if (port) *port = ntohs(s4.sin_port);
#ifdef HAVE_STRUCT_SOCKADDR_IN6
memcpy(&s6, sa, sizeof(s6));
ipaddr->af = AF_INET6;
ipaddr->prefix = 128;
- ipaddr->ipaddr.v6 = s6.sin6_addr;
+ ipaddr->addr.v6 = s6.sin6_addr;
if (port) *port = ntohs(s6.sin6_port);
ipaddr->zone_id = s6.sin6_scope_id;
#endif
*/
if (ipaddr->af == AF_INET6) {
# ifdef IPV6_V6ONLY
- if (IN6_IS_ADDR_UNSPECIFIED(&ipaddr->ipaddr.v6)) {
+ if (IN6_IS_ADDR_UNSPECIFIED(&ipaddr->addr.v6)) {
int on = 1;
if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY,
*/
#ifdef IPV6_V6ONLY
- if (IN6_IS_ADDR_UNSPECIFIED(&ipaddr->ipaddr.v6)) {
+ if (IN6_IS_ADDR_UNSPECIFIED(&ipaddr->addr.v6)) {
int on = 1;
if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY,
{
if (ipaddr->af == AF_INET) {
- if (ipaddr->ipaddr.v4.s_addr == INADDR_ANY) {
+ if (ipaddr->addr.v4.s_addr == INADDR_ANY) {
return 1;
}
#ifdef HAVE_STRUCT_SOCKADDR_IN6
} else if (ipaddr->af == AF_INET6) {
- if (IN6_IS_ADDR_UNSPECIFIED(&(ipaddr->ipaddr.v6))) {
+ if (IN6_IS_ADDR_UNSPECIFIED(&(ipaddr->addr.v6))) {
return 1;
}
#endif
if (packet->src_ipaddr.af != AF_UNSPEC) {
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
ip_buf, sizeof(ip_buf));
snprintf(buffer, sizeof(buffer), "host %s port %d",
ip_buf, packet->src_port);
return -1;
}
- dst->datum.ipaddr.s_addr = addr.ipaddr.v4.s_addr;
+ dst->datum.ipaddr.s_addr = addr.addr.v4.s_addr;
}
goto finish;
if (fr_inet_pton4(&addr, in, inlen, fr_hostname_lookups, false, true) < 0) return -1;
dst->datum.ipv4prefix[1] = addr.prefix;
- memcpy(&dst->datum.ipv4prefix[2], &addr.ipaddr.v4.s_addr, sizeof(dst->datum.ipv4prefix) - 2);
+ memcpy(&dst->datum.ipv4prefix[2], &addr.addr.v4.s_addr, sizeof(dst->datum.ipv4prefix) - 2);
}
goto finish;
return -1;
}
- memcpy(&dst->datum.ipv6addr, addr.ipaddr.v6.s6_addr, sizeof(dst->datum.ipv6addr));
+ memcpy(&dst->datum.ipv6addr, addr.addr.v6.s6_addr, sizeof(dst->datum.ipv6addr));
}
goto finish;
if (fr_inet_pton6(&addr, in, inlen, fr_hostname_lookups, false, true) < 0) return -1;
dst->datum.ipv6prefix[1] = addr.prefix;
- memcpy(&dst->datum.ipv6prefix[2], addr.ipaddr.v6.s6_addr, sizeof(dst->datum.ipv6prefix) - 2);
+ memcpy(&dst->datum.ipv6prefix[2], addr.addr.v6.s6_addr, sizeof(dst->datum.ipv6prefix) - 2);
}
goto finish;
}
*dst_type = PW_TYPE_IPV4_ADDR;
- dst->datum.ipaddr.s_addr = ipaddr.ipaddr.v4.s_addr;
+ dst->datum.ipaddr.s_addr = ipaddr.addr.v4.s_addr;
ret = dict_attr_sizes[PW_TYPE_COMBO_IP_ADDR][0]; /* size of IPv4 address */
}
}
case PW_TYPE_IPV4_ADDR:
if (da->attr == PW_FREERADIUS_CLIENT_IP_ADDRESS) {
c->ipaddr.af = AF_INET;
- c->ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ c->ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
c->ipaddr.prefix = 32;
cp = cf_pair_alloc(c->cs, "ipv4addr", strvalue, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
} else if (da->attr == PW_FREERADIUS_CLIENT_SRC_IP_ADDRESS) {
#ifdef WITH_UDPFROMTO
RDEBUG2("src_ipaddr = %s", strvalue);
c->src_ipaddr.af = AF_INET;
- c->src_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ c->src_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
c->src_ipaddr.prefix = 32;
cp = cf_pair_alloc(c->cs, "src_ipaddr", strvalue, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
#else
case PW_TYPE_IPV6_ADDR:
if (da->attr == PW_FREERADIUS_CLIENT_IPV6_ADDRESS) {
c->ipaddr.af = AF_INET6;
- c->ipaddr.ipaddr.v6 = vp->vp_ipv6addr;
+ c->ipaddr.addr.v6 = vp->vp_ipv6addr;
c->ipaddr.prefix = 128;
cp = cf_pair_alloc(c->cs, "ipv6addr", strvalue, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
} else if (da->attr == PW_FREERADIUS_CLIENT_SRC_IPV6_ADDRESS) {
#ifdef WITH_UDPFROMTO
c->src_ipaddr.af = AF_INET6;
- c->src_ipaddr.ipaddr.v6 = vp->vp_ipv6addr;
+ c->src_ipaddr.addr.v6 = vp->vp_ipv6addr;
c->src_ipaddr.prefix = 128;
cp = cf_pair_alloc(c->cs, "src_addr", strvalue, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
#else
case PW_TYPE_IPV4_PREFIX:
if (da->attr == PW_FREERADIUS_CLIENT_IP_PREFIX) {
c->ipaddr.af = AF_INET;
- memcpy(&c->ipaddr.ipaddr.v4, &vp->vp_ipv4prefix[2],
- sizeof(c->ipaddr.ipaddr.v4.s_addr));
+ memcpy(&c->ipaddr.addr.v4, &vp->vp_ipv4prefix[2],
+ sizeof(c->ipaddr.addr.v4.s_addr));
fr_ipaddr_mask(&c->ipaddr, (vp->vp_ipv4prefix[1] & 0x3f));
cp = cf_pair_alloc(c->cs, "ipv4addr", strvalue, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
}
case PW_TYPE_IPV6_PREFIX:
if (da->attr == PW_FREERADIUS_CLIENT_IPV6_PREFIX) {
c->ipaddr.af = AF_INET6;
- memcpy(&c->ipaddr.ipaddr.v6, &vp->vp_ipv6prefix[2],
- sizeof(c->ipaddr.ipaddr.v6));
+ memcpy(&c->ipaddr.addr.v6, &vp->vp_ipv6prefix[2],
+ sizeof(c->ipaddr.addr.v6));
fr_ipaddr_mask(&c->ipaddr, vp->vp_ipv6prefix[1]);
cp = cf_pair_alloc(c->cs, "ipv6addr", strvalue, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
}
if (rad_debug_lvl) {
RDEBUG("Injected %s packet to host %s port 0 code=%d, id=%d", what,
inet_ntop(request->reply->src_ipaddr.af,
- &request->reply->src_ipaddr.ipaddr,
+ &request->reply->src_ipaddr.addr,
buffer, sizeof(buffer)),
request->reply->code, request->reply->id);
}
DEBUG("Injecting %s packet from host %s port 0 code=%d, id=%d",
fr_packet_codes[packet->code],
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
buffer, sizeof(buffer)),
packet->code, packet->id);
#ifdef WITH_TCP
" proto %s"
#endif
- , name, inet_ntop(ipaddr->af, &ipaddr->ipaddr,
+ , name, inet_ntop(ipaddr->af, &ipaddr->addr,
buffer, sizeof(buffer)), src_port
#ifdef WITH_TCP
, (sock->proto == IPPROTO_UDP) ? "udp" : "tcp"
ADDSTRING(") -> (");
if ((sock->my_ipaddr.af == AF_INET) &&
- (sock->my_ipaddr.ipaddr.v4.s_addr == htonl(INADDR_ANY))) {
+ (sock->my_ipaddr.addr.v4.s_addr == htonl(INADDR_ANY))) {
strlcpy(buffer, "*", bufsize);
} else {
fr_inet_ntoh(&sock->my_ipaddr, buffer, bufsize);
ADDSTRING(") -> home_server (");
if ((sock->other_ipaddr.af == AF_INET) &&
- (sock->other_ipaddr.ipaddr.v4.s_addr == htonl(INADDR_ANY))) {
+ (sock->other_ipaddr.addr.v4.s_addr == htonl(INADDR_ANY))) {
strlcpy(buffer, "*", bufsize);
} else {
fr_inet_ntoh(&sock->other_ipaddr, buffer, bufsize);
ADDSTRING(" address ");
if ((sock->my_ipaddr.af == AF_INET) &&
- (sock->my_ipaddr.ipaddr.v4.s_addr == htonl(INADDR_ANY))) {
+ (sock->my_ipaddr.addr.v4.s_addr == htonl(INADDR_ANY))) {
strlcpy(buffer, "*", bufsize);
} else {
fr_inet_ntoh(&sock->my_ipaddr, buffer, bufsize);
* Try IPv4 first
*/
memset(&ipaddr, 0, sizeof(ipaddr));
- ipaddr.ipaddr.v4.s_addr = htonl(INADDR_NONE);
+ ipaddr.addr.v4.s_addr = htonl(INADDR_NONE);
rcode = cf_pair_parse(NULL, cs, "ipaddr", FR_ITEM_POINTER(PW_TYPE_COMBO_IP_ADDR, &ipaddr), NULL, T_INVALID);
if (rcode < 0) return -1;
memset(&ipaddr, 0, sizeof(ipaddr));
ipaddr.af = AF_INET6;
ipaddr.prefix = 128;
- ipaddr.ipaddr.v6 = in6addr_any; /* in6addr_any binds to all addresses */
+ ipaddr.addr.v6 = in6addr_any; /* in6addr_any binds to all addresses */
}
rcode = cf_pair_parse(NULL, cs, "port", FR_ITEM_POINTER(PW_TYPE_SHORT, &sock->my_port), "0", T_BARE_WORD);
RDEBUG2("Reply from home server %s port %d - ID: %d arrived too late. "
"Try increasing 'retry_delay' or 'max_request_time'",
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port, request->proxy->packet->id);
}
pthread_mutex_unlock(&proxy_mutex);
RDEBUG3("proxy: allocating destination %s port %d - Id %d",
- inet_ntop(request->proxy->packet->dst_ipaddr.af, &request->proxy->packet->dst_ipaddr.ipaddr, buffer, sizeof(buffer)),
+ inet_ntop(request->proxy->packet->dst_ipaddr.af, &request->proxy->packet->dst_ipaddr.addr, buffer, sizeof(buffer)),
request->proxy->packet->dst_port,
request->proxy->packet->id);
PROXY("No outstanding request was found for %s packet from host %s port %d - ID %u",
fr_packet_codes[reply->code],
inet_ntop(reply->src_ipaddr.af,
- &reply->src_ipaddr.ipaddr,
+ &reply->src_ipaddr.addr,
buffer, sizeof(buffer)),
reply->src_port, reply->id);
return 0;
*/
if (!proxy->reply && (fr_radius_packet_verify(reply, proxy->packet, proxy->home_server->secret) != 0)) {
RWDEBUG("Discarding invalid reply from host %s port %d - ID: %d: %s",
- inet_ntop(reply->src_ipaddr.af, &reply->src_ipaddr.ipaddr, buffer, sizeof(buffer)),
+ inet_ntop(reply->src_ipaddr.af, &reply->src_ipaddr.addr, buffer, sizeof(buffer)),
reply->src_port, reply->id, fr_strerror());
return 0;
}
*/
if (proxy->reply && (memcmp(proxy->reply->vector, reply->vector, sizeof(proxy->reply->vector)) != 0)) {
RWDEBUG("Discarding conflicting reply from host %s port %d - ID: %d",
- inet_ntop(reply->src_ipaddr.af, &reply->src_ipaddr.ipaddr, buffer, sizeof(buffer)),
+ inet_ntop(reply->src_ipaddr.af, &reply->src_ipaddr.addr, buffer, sizeof(buffer)),
reply->src_port, reply->id);
return 0;
}
proxy->reply->count++;
RWDEBUG("Discarding duplicate reply from host %s port %d - ID: %d",
- inet_ntop(reply->src_ipaddr.af, &reply->src_ipaddr.ipaddr, buffer, sizeof(buffer)),
+ inet_ntop(reply->src_ipaddr.af, &reply->src_ipaddr.addr, buffer, sizeof(buffer)),
reply->src_port, reply->id);
return 0;
}
if (vp->da->attr == PW_PACKET_DST_IP_ADDRESS) {
dst_ipaddr.af = AF_INET;
- dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
dst_ipaddr.prefix = 32;
} else {
dst_ipaddr.af = AF_INET6;
- memcpy(&dst_ipaddr.ipaddr.v6, &vp->vp_ipv6addr, sizeof(vp->vp_ipv6addr));
+ memcpy(&dst_ipaddr.addr.v6, &vp->vp_ipv6addr, sizeof(vp->vp_ipv6addr));
dst_ipaddr.prefix = 128;
}
char buffer[INET6_ADDRSTRLEN];
WARN("No such home server %s port %u",
- inet_ntop(dst_ipaddr.af, &dst_ipaddr.ipaddr, buffer, sizeof(buffer)),
+ inet_ntop(dst_ipaddr.af, &dst_ipaddr.addr, buffer, sizeof(buffer)),
(unsigned int) dst_port);
return 0;
}
if (request->proxy->home_server->tls) {
RDEBUG2("Proxying request to home server %s port %d (TLS) timeout %d.%06d",
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port,
(int) response_window->tv_sec, (int) response_window->tv_usec);
#endif
RDEBUG2("Proxying request to home server %s port %d timeout %d.%06d",
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port,
(int) response_window->tv_sec, (int) response_window->tv_usec);
request->number,
request->proxy->packet->id,
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port);
remove_from_proxy_hash(request);
if (old_state == HOME_STATE_UNKNOWN) {
RPROXY("Home server %s port %d went from idle -> alive",
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port);
} else {
RPROXY("Marking home server %s port %d alive",
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port);
}
home->num_received_pings = 0;
PROXY("Marking home server %s port %d as zombie (it has not responded in %d.%06d seconds).",
- inet_ntop(home->ipaddr.af, &home->ipaddr.ipaddr,
+ inet_ntop(home->ipaddr.af, &home->ipaddr.addr,
buffer, sizeof(buffer)),
home->port, (int) response_window->tv_sec, (int) response_window->tv_usec);
char buffer[INET6_ADDRSTRLEN];
PROXY("Marking home server %s port %d as dead",
- inet_ntop(home->ipaddr.af, &home->ipaddr.ipaddr,
+ inet_ntop(home->ipaddr.af, &home->ipaddr.addr,
buffer, sizeof(buffer)),
home->port);
fr_event_timer_delete(el, &home->ev);
PROXY("Marking home server %s port %d alive again... we have no idea if it really is alive or not.",
- inet_ntop(home->ipaddr.af, &home->ipaddr.ipaddr, buffer, sizeof(buffer)),
+ inet_ntop(home->ipaddr.af, &home->ipaddr.addr, buffer, sizeof(buffer)),
home->port);
}
"server %s port %d",
request->username->vp_strvalue,
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port);
} else {
RERROR("Failing proxied request, due to lack of any response from home server %s port %d",
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port);
}
if (fr_timeval_cmp(now, &when) < 0) {
DEBUG2("Suppressing duplicate proxied request (too fast) to home server %s port %d proto TCP - ID: %d",
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port,
request->proxy->packet->id);
RDEBUG2("Sending duplicate proxied request to home server %s port %d - ID: %d",
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port,
request->proxy->packet->id);
if (home->proto == IPPROTO_TCP) {
DEBUG2("Suppressing duplicate proxied request (tcp) to home server %s port %d proto TCP - ID: %d",
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port,
request->proxy->packet->id);
vp = fr_pair_find_by_num(coa->proxy->packet->vps, 0, PW_PACKET_DST_IP_ADDRESS, TAG_ANY);
if (vp) {
ipaddr.af = AF_INET;
- ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
ipaddr.prefix = 32;
} else if ((vp = fr_pair_find_by_num(coa->proxy->packet->vps, 0, PW_PACKET_DST_IPV6_ADDRESS, TAG_ANY)) != NULL) {
ipaddr.af = AF_INET6;
- ipaddr.ipaddr.v6 = vp->vp_ipv6addr;
+ ipaddr.addr.v6 = vp->vp_ipv6addr;
ipaddr.prefix = 128;
} else if ((vp = fr_pair_find_by_num(coa->proxy->packet->vps, 0, PW_HOME_SERVER_POOL, TAG_ANY)) != NULL) {
coa->home_pool = home_pool_byname(vp->vp_strvalue,
coa->home_server = home_server_find(&ipaddr, port, IPPROTO_UDP);
if (!coa->home_server) {
RWDEBUG2("Unknown destination %s:%d for CoA request",
- inet_ntop(ipaddr.af, &ipaddr.ipaddr,
+ inet_ntop(ipaddr.af, &ipaddr.addr,
buffer, sizeof(buffer)), port);
goto fail;
}
RERROR("Failing request - originate-coa ID %u, due to lack of any response from coa server %s port %d",
request->proxy->packet->id,
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port);
return false;
RDEBUG2("Sending duplicate CoA request to home server %s port %d - ID: %d",
inet_ntop(request->proxy->packet->dst_ipaddr.af,
- &request->proxy->packet->dst_ipaddr.ipaddr,
+ &request->proxy->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port,
request->proxy->packet->id);
case FR_ACTION_PROXY_REPLY: /* too late! */
RDEBUG2("Reply from CoA server %s port %d - ID: %d arrived too late.",
inet_ntop(request->proxy->packet->src_ipaddr.af,
- &request->proxy->packet->src_ipaddr.ipaddr,
+ &request->proxy->packet->src_ipaddr.addr,
buffer, sizeof(buffer)),
request->proxy->packet->dst_port, request->proxy->packet->id);
break;
case PW_PACKET_DST_IP_ADDRESS:
request->packet->dst_ipaddr.af = AF_INET;
- request->packet->dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->packet->dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
request->packet->dst_ipaddr.prefix = 32;
break;
case PW_PACKET_DST_IPV6_ADDRESS:
request->packet->dst_ipaddr.af = AF_INET6;
- request->packet->dst_ipaddr.ipaddr.v6 = vp->vp_ipv6addr;
+ request->packet->dst_ipaddr.addr.v6 = vp->vp_ipv6addr;
request->packet->dst_ipaddr.prefix = 128;
break;
case PW_PACKET_SRC_IP_ADDRESS:
request->packet->src_ipaddr.af = AF_INET;
- request->packet->src_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->packet->src_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
request->packet->src_ipaddr.prefix = 32;
break;
case PW_PACKET_SRC_IPV6_ADDRESS:
request->packet->src_ipaddr.af = AF_INET6;
- request->packet->src_ipaddr.ipaddr.v6 = vp->vp_ipv6addr;
+ request->packet->src_ipaddr.addr.v6 = vp->vp_ipv6addr;
request->packet->src_ipaddr.prefix = 128;
break;
ssize_t len, s = sizeof(buffer);
- inet_ntop(packet->src_ipaddr.af, &packet->src_ipaddr.ipaddr, src, sizeof(src));
- inet_ntop(packet->dst_ipaddr.af, &packet->dst_ipaddr.ipaddr, dst, sizeof(dst));
+ inet_ntop(packet->src_ipaddr.af, &packet->src_ipaddr.addr, src, sizeof(src));
+ inet_ntop(packet->dst_ipaddr.af, &packet->dst_ipaddr.addr, dst, sizeof(dst));
status_str = fr_int2str(rs_events, status, NULL);
RS_ASSERT(status_str);
ssize_t len, s = sizeof(buffer);
- inet_ntop(packet->src_ipaddr.af, &packet->src_ipaddr.ipaddr, src, sizeof(src));
- inet_ntop(packet->dst_ipaddr.af, &packet->dst_ipaddr.ipaddr, dst, sizeof(dst));
+ inet_ntop(packet->src_ipaddr.af, &packet->src_ipaddr.addr, src, sizeof(src));
+ inet_ntop(packet->dst_ipaddr.af, &packet->dst_ipaddr.addr, dst, sizeof(dst));
/* Only print out status str if something's not right */
if (status != RS_NORMAL) {
*/
if (ip) {
current->src_ipaddr.af = AF_INET;
- current->src_ipaddr.ipaddr.v4.s_addr = ip->ip_src.s_addr;
+ current->src_ipaddr.addr.v4.s_addr = ip->ip_src.s_addr;
current->dst_ipaddr.af = AF_INET;
- current->dst_ipaddr.ipaddr.v4.s_addr = ip->ip_dst.s_addr;
+ current->dst_ipaddr.addr.v4.s_addr = ip->ip_dst.s_addr;
} else {
current->src_ipaddr.af = AF_INET6;
- memcpy(current->src_ipaddr.ipaddr.v6.s6_addr, ip6->ip_src.s6_addr,
- sizeof(current->src_ipaddr.ipaddr.v6.s6_addr));
+ memcpy(current->src_ipaddr.addr.v6.s6_addr, ip6->ip_src.s6_addr,
+ sizeof(current->src_ipaddr.addr.v6.s6_addr));
current->dst_ipaddr.af = AF_INET6;
- memcpy(current->dst_ipaddr.ipaddr.v6.s6_addr, ip6->ip_dst.s6_addr,
- sizeof(current->dst_ipaddr.ipaddr.v6.s6_addr));
+ memcpy(current->dst_ipaddr.addr.v6.s6_addr, ip6->ip_dst.s6_addr,
+ sizeof(current->dst_ipaddr.addr.v6.s6_addr));
}
current->src_port = ntohs(udp->src);
if (!home->server && (rbtree_finddata(home_servers_byaddr, home) != NULL)) {
char buffer[INET6_ADDRSTRLEN];
- inet_ntop(home->ipaddr.af, &home->ipaddr.ipaddr, buffer, sizeof(buffer));
+ inet_ntop(home->ipaddr.af, &home->ipaddr.addr, buffer, sizeof(buffer));
cf_log_err_cs(home->cs, "Duplicate home server address%s%s%s: %s:%s%s/%i",
home->name ? " (already in use by " : "",
case HOME_POOL_CLIENT_BALANCE:
switch (request->packet->src_ipaddr.af) {
case AF_INET:
- hash = fr_hash(&request->packet->src_ipaddr.ipaddr.v4,
- sizeof(request->packet->src_ipaddr.ipaddr.v4));
+ hash = fr_hash(&request->packet->src_ipaddr.addr.v4,
+ sizeof(request->packet->src_ipaddr.addr.v4));
break;
case AF_INET6:
- hash = fr_hash(&request->packet->src_ipaddr.ipaddr.v6,
- sizeof(request->packet->src_ipaddr.ipaddr.v6));
+ hash = fr_hash(&request->packet->src_ipaddr.addr.v6,
+ sizeof(request->packet->src_ipaddr.addr.v6));
break;
default:
case HOME_POOL_CLIENT_PORT_BALANCE:
switch (request->packet->src_ipaddr.af) {
case AF_INET:
- hash = fr_hash(&request->packet->src_ipaddr.ipaddr.v4,
- sizeof(request->packet->src_ipaddr.ipaddr.v4));
+ hash = fr_hash(&request->packet->src_ipaddr.addr.v4,
+ sizeof(request->packet->src_ipaddr.addr.v4));
break;
case AF_INET6:
- hash = fr_hash(&request->packet->src_ipaddr.ipaddr.v6,
- sizeof(request->packet->src_ipaddr.ipaddr.v6));
+ hash = fr_hash(&request->packet->src_ipaddr.addr.v6,
+ sizeof(request->packet->src_ipaddr.addr.v6));
break;
default:
fr_ipaddr_t ipaddr;
ipaddr.af = AF_INET;
- ipaddr.ipaddr.v4.s_addr = nasaddr;
+ ipaddr.addr.v4.s_addr = nasaddr;
/*
* Find NAS type.
* Unknown NAS, so trusting radutmp.
*/
DEBUG2("checkrad: Unknown NAS %s, not checking",
- inet_ntop(ipaddr.af, &ipaddr.ipaddr, buffer, sizeof(buffer)));
+ inet_ntop(ipaddr.af, &ipaddr.addr, buffer, sizeof(buffer)));
return 1;
}
*/
closefrom(3);
- inet_ntop(ipaddr.af, &ipaddr.ipaddr, buffer, sizeof(buffer));
+ inet_ntop(ipaddr.af, &ipaddr.addr, buffer, sizeof(buffer));
snprintf(port, 11, "%u", nas_port);
#ifdef __EMX__
*/
if (client->ipaddr.af != AF_INET) return 0;
- out->datum.ipaddr = client->ipaddr.ipaddr.v4;
+ out->datum.ipaddr = client->ipaddr.addr.v4;
out->length = dict_attr_sizes[PW_TYPE_IPV4_ADDR][0];
return 0;
if (server_port) {
ipaddr.af = AF_INET;
- ipaddr.ipaddr.v4.s_addr = server_ip->vp_ipv4addr;
+ ipaddr.addr.v4.s_addr = server_ip->vp_ipv4addr;
cl = listener_find_client_list(&ipaddr, server_port->vp_integer, IPPROTO_UDP);
/*
if (vp) {
memset(&ipaddr, 0, sizeof(ipaddr));
ipaddr.af = AF_INET;
- ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
client = client_find(cl, &ipaddr, IPPROTO_UDP);
#ifdef WITH_TCP
if (!client) {
&request->reply->vps,
PW_FREERADIUS_STATS_CLIENT_IP_ADDRESS, VENDORPEC_FREERADIUS);
if (vp) {
- vp->vp_ipv4addr = client->ipaddr.ipaddr.v4.s_addr;
+ vp->vp_ipv4addr = client->ipaddr.addr.v4.s_addr;
}
if (client->ipaddr.prefix != 32) {
if (!server_port) return;
ipaddr.af = AF_INET;
- ipaddr.ipaddr.v4.s_addr = server_ip->vp_ipv4addr;
+ ipaddr.addr.v4.s_addr = server_ip->vp_ipv4addr;
this = listener_find_byipaddr(&ipaddr,
server_port->vp_integer,
IPPROTO_UDP);
memset(&ipaddr, 0, sizeof(ipaddr));
#endif
ipaddr.af = AF_INET;
- ipaddr.ipaddr.v4.s_addr = server_ip->vp_ipv4addr;
+ ipaddr.addr.v4.s_addr = server_ip->vp_ipv4addr;
home = home_server_find(&ipaddr, server_port->vp_integer,
IPPROTO_UDP);
RDEBUG("tls_recv: %s packet from host %s port %d, id=%d, length=%d",
fr_packet_codes[packet->code],
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
host_ipaddr, sizeof(host_ipaddr)),
packet->src_port,
packet->id, (int) packet->data_len);
} else {
RDEBUG("tls_recv: Packet from host %s port %d code=%d, id=%d, length=%d",
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
host_ipaddr, sizeof(host_ipaddr)),
packet->src_port,
packet->code,
request->packet->code = PW_CODE_ACCESS_REQUEST;
request->packet->src_ipaddr.af = AF_INET;
- request->packet->src_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_LOOPBACK);
+ request->packet->src_ipaddr.addr.v4.s_addr = htonl(INADDR_LOOPBACK);
request->packet->src_port = 18120;
request->packet->dst_ipaddr.af = AF_INET;
- request->packet->dst_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_LOOPBACK);
+ request->packet->dst_ipaddr.addr.v4.s_addr = htonl(INADDR_LOOPBACK);
request->packet->dst_port = 1812;
/*
case PW_PACKET_DST_IP_ADDRESS:
request->packet->dst_ipaddr.af = AF_INET;
- request->packet->dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->packet->dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
request->packet->dst_ipaddr.prefix = 32;
break;
case PW_PACKET_DST_IPV6_ADDRESS:
request->packet->dst_ipaddr.af = AF_INET6;
- request->packet->dst_ipaddr.ipaddr.v6 = vp->vp_ipv6addr;
+ request->packet->dst_ipaddr.addr.v6 = vp->vp_ipv6addr;
request->packet->dst_ipaddr.prefix = 128;
break;
case PW_PACKET_SRC_IP_ADDRESS:
request->packet->src_ipaddr.af = AF_INET;
- request->packet->src_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->packet->src_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
request->packet->src_ipaddr.prefix = 32;
break;
case PW_PACKET_SRC_IPV6_ADDRESS:
request->packet->src_ipaddr.af = AF_INET6;
- request->packet->src_ipaddr.ipaddr.v6 = vp->vp_ipv6addr;
+ request->packet->src_ipaddr.addr.v6 = vp->vp_ipv6addr;
request->packet->src_ipaddr.prefix = 128;
break;
request->packet->code = PW_CODE_ACCESS_REQUEST;
request->packet->src_ipaddr.af = AF_INET;
- request->packet->src_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_LOOPBACK);
+ request->packet->src_ipaddr.addr.v4.s_addr = htonl(INADDR_LOOPBACK);
request->packet->src_port = 18120;
request->packet->dst_ipaddr.af = AF_INET;
- request->packet->dst_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_LOOPBACK);
+ request->packet->dst_ipaddr.addr.v4.s_addr = htonl(INADDR_LOOPBACK);
request->packet->dst_port = 1812;
/*
case PW_PACKET_SRC_IP_ADDRESS:
if (packet->src_ipaddr.af == AF_INET) {
virtual = fr_pair_afrom_da(ctx, vpt->tmpl_da);
- virtual->vp_ipv4addr = packet->src_ipaddr.ipaddr.v4.s_addr;
+ virtual->vp_ipv4addr = packet->src_ipaddr.addr.v4.s_addr;
vp = virtual;
}
break;
case PW_PACKET_DST_IP_ADDRESS:
if (packet->dst_ipaddr.af == AF_INET) {
virtual = fr_pair_afrom_da(ctx, vpt->tmpl_da);
- virtual->vp_ipv4addr = packet->dst_ipaddr.ipaddr.v4.s_addr;
+ virtual->vp_ipv4addr = packet->dst_ipaddr.addr.v4.s_addr;
vp = virtual;
}
break;
if (packet->src_ipaddr.af == AF_INET6) {
virtual = fr_pair_afrom_da(ctx, vpt->tmpl_da);
memcpy(&virtual->vp_ipv6addr,
- &packet->src_ipaddr.ipaddr.v6,
- sizeof(packet->src_ipaddr.ipaddr.v6));
+ &packet->src_ipaddr.addr.v6,
+ sizeof(packet->src_ipaddr.addr.v6));
vp = virtual;
}
break;
if (packet->dst_ipaddr.af == AF_INET6) {
virtual = fr_pair_afrom_da(ctx, vpt->tmpl_da);
memcpy(&virtual->vp_ipv6addr,
- &packet->dst_ipaddr.ipaddr.v6,
- sizeof(packet->dst_ipaddr.ipaddr.v6));
+ &packet->dst_ipaddr.addr.v6,
+ sizeof(packet->dst_ipaddr.addr.v6));
vp = virtual;
}
break;
client = &sock->client;
memset(client, 0, sizeof(*client));
client->ipaddr.af = AF_INET;
- client->ipaddr.ipaddr.v4.s_addr = INADDR_NONE;
+ client->ipaddr.addr.v4.s_addr = INADDR_NONE;
client->ipaddr.prefix = 0;
client->longname = client->shortname = sock->lsock.interface;
client->secret = client->shortname;
* Try IPv4 first
*/
memset(ipaddr, 0, sizeof(*ipaddr));
- ipaddr->ipaddr.v4.s_addr = htonl(INADDR_NONE);
+ ipaddr->addr.v4.s_addr = htonl(INADDR_NONE);
rcode = cf_pair_parse(NULL, cs, "ipaddr", FR_ITEM_POINTER(PW_TYPE_IPV4_ADDR, ipaddr), NULL, T_INVALID);
if (rcode < 0) return -1;
FORWARD;
if ((sock->my_ipaddr.af == AF_INET) &&
- (sock->my_ipaddr.ipaddr.v4.s_addr == htonl(INADDR_ANY))) {
+ (sock->my_ipaddr.addr.v4.s_addr == htonl(INADDR_ANY))) {
strlcpy(buffer, "*", bufsize);
} else {
fr_inet_ntoh(&sock->my_ipaddr, buffer, bufsize);
memset(packet, 0, sizeof(*packet));
packet->sockfd = -1;
packet->src_ipaddr.af = AF_INET;
- packet->src_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_NONE);
+ packet->src_ipaddr.addr.v4.s_addr = htonl(INADDR_NONE);
/*
* If everything's OK, this is a waste of memory.
vp = fr_pair_find_by_num(packet->vps, 0, PW_PACKET_SRC_IP_ADDRESS, TAG_ANY);
if (vp) {
packet->src_ipaddr.af = AF_INET;
- packet->src_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ packet->src_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
packet->src_ipaddr.prefix = 32;
} else {
vp = fr_pair_find_by_num(packet->vps, 0, PW_PACKET_SRC_IPV6_ADDRESS, TAG_ANY);
if (vp) {
packet->src_ipaddr.af = AF_INET6;
- memcpy(&packet->src_ipaddr.ipaddr.v6,
+ memcpy(&packet->src_ipaddr.addr.v6,
&vp->vp_ipv6addr, sizeof(vp->vp_ipv6addr));
packet->src_ipaddr.prefix = 128;
}
vp = fr_pair_find_by_num(packet->vps, 0, PW_PACKET_DST_IP_ADDRESS, TAG_ANY);
if (vp) {
packet->dst_ipaddr.af = AF_INET;
- packet->dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ packet->dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
packet->dst_ipaddr.prefix = 32;
} else {
vp = fr_pair_find_by_num(packet->vps, 0, PW_PACKET_DST_IPV6_ADDRESS, TAG_ANY);
if (vp) {
packet->dst_ipaddr.af = AF_INET6;
- memcpy(&packet->dst_ipaddr.ipaddr.v6,
+ memcpy(&packet->dst_ipaddr.addr.v6,
&vp->vp_ipv6addr, sizeof(vp->vp_ipv6addr));
packet->dst_ipaddr.prefix = 128;
}
packet->dst_port = 1024 + ((data->counter >> 16) & 0xff);
packet->dst_ipaddr.af = AF_INET;
- packet->dst_ipaddr.ipaddr.v4.s_addr = htonl((INADDR_LOOPBACK & ~0xffffff) | ((data->counter >> 24) & 0xff));
+ packet->dst_ipaddr.addr.v4.s_addr = htonl((INADDR_LOOPBACK & ~0xffffff) | ((data->counter >> 24) & 0xff));
/*
* Create / update accounting attributes.
client = &data->detail_client;
memset(client, 0, sizeof(*client));
client->ipaddr.af = AF_INET;
- client->ipaddr.ipaddr.v4.s_addr = INADDR_NONE;
+ client->ipaddr.addr.v4.s_addr = INADDR_NONE;
client->ipaddr.prefix = 0;
client->longname = client->shortname = data->filename;
client->secret = client->shortname;
src_port = ntohs(udp->src);
src_ipaddr.af = AF_INET;
- src_ipaddr.ipaddr.v4 = ip->ip_src;
+ src_ipaddr.addr.v4 = ip->ip_src;
src_ipaddr.prefix = 32;
src_ipaddr.zone_id = 0;
dst_ipaddr.af = AF_INET;
- dst_ipaddr.ipaddr.v4 = ip->ip_dst;
+ dst_ipaddr.addr.v4 = ip->ip_dst;
dst_ipaddr.prefix = 32;
dst_ipaddr.zone_id = 0;
ip_hdr->ip_p = 17;
ip_hdr->ip_sum = 0; /* Filled later */
- ip_hdr->ip_src.s_addr = packet->src_ipaddr.ipaddr.v4.s_addr;
- ip_hdr->ip_dst.s_addr = packet->dst_ipaddr.ipaddr.v4.s_addr;
+ ip_hdr->ip_src.s_addr = packet->src_ipaddr.addr.v4.s_addr;
+ ip_hdr->ip_dst.s_addr = packet->dst_ipaddr.addr.v4.s_addr;
/* IP header checksum */
ip_hdr->ip_sum = fr_ip_header_checksum((uint8_t const *)ip_hdr, 5);
/* UDP checksum is done here */
udp_hdr->checksum = fr_udp_checksum((uint8_t const *)udp_hdr, ntohs(udp_hdr->len), udp_hdr->checksum,
- packet->src_ipaddr.ipaddr.v4,
- packet->dst_ipaddr.ipaddr.v4);
+ packet->src_ipaddr.addr.v4,
+ packet->dst_ipaddr.addr.v4);
ret = pcap_inject(pcap->handle, dhcp_packet, (end - dhcp_packet + packet->data_len));
if (ret < 0) {
case PW_PACKET_DST_IP_ADDRESS:
request->dst_ipaddr.af = AF_INET;
- request->dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
request->dst_ipaddr.prefix = 32;
break;
case PW_PACKET_DST_IPV6_ADDRESS:
request->dst_ipaddr.af = AF_INET6;
- request->dst_ipaddr.ipaddr.v6 = vp->vp_ipv6addr;
+ request->dst_ipaddr.addr.v6 = vp->vp_ipv6addr;
request->dst_ipaddr.prefix = 128;
break;
case PW_PACKET_SRC_IP_ADDRESS:
request->src_ipaddr.af = AF_INET;
- request->src_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->src_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
request->src_ipaddr.prefix = 32;
break;
case PW_PACKET_SRC_IPV6_ADDRESS:
request->src_ipaddr.af = AF_INET6;
- request->src_ipaddr.ipaddr.v6 = vp->vp_ipv6addr;
+ request->src_ipaddr.addr.v6 = vp->vp_ipv6addr;
request->src_ipaddr.prefix = 128;
break;
packet->id,
packet->src_ipaddr.af == AF_INET6 ? "[" : "",
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
src_ipaddr, sizeof(src_ipaddr)),
packet->src_ipaddr.af == AF_INET6 ? "]" : "",
packet->src_port,
packet->dst_ipaddr.af == AF_INET6 ? "[" : "",
inet_ntop(packet->dst_ipaddr.af,
- &packet->dst_ipaddr.ipaddr,
+ &packet->dst_ipaddr.addr,
dst_ipaddr, sizeof(dst_ipaddr)),
packet->dst_ipaddr.af == AF_INET6 ? "]" : "",
packet->dst_port,
exit(1);
}
- if (server_ipaddr.ipaddr.v4.s_addr == 0xFFFFFFFF) {
+ if (server_ipaddr.addr.v4.s_addr == 0xFFFFFFFF) {
ERROR("Using interface: %s (index: %d) in raw packet mode", iface, iface_ind);
raw_mode = true;
}
*/
/* set SRC ipaddr/port to the listener ipaddr/port */
request->packet->src_ipaddr.af = AF_INET;
- request->packet->src_ipaddr.ipaddr.v4.s_addr = sock->lsock.my_ipaddr.ipaddr.v4.s_addr;
+ request->packet->src_ipaddr.addr.v4.s_addr = sock->lsock.my_ipaddr.addr.v4.s_addr;
request->packet->src_port = sock->lsock.my_port;
vp = fr_pair_find_by_num(request->control, DHCP_MAGIC_VENDOR, 270, TAG_ANY); /* DHCP-Relay-To-IP-Address */
/* set DEST ipaddr/port to the next server ipaddr/port */
request->packet->dst_ipaddr.af = AF_INET;
- request->packet->dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->packet->dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
request->packet->dst_port = sock->lsock.my_port;
/*
giaddr = fr_pair_find_by_num(request->packet->vps, DHCP_MAGIC_VENDOR, 266, TAG_ANY); /* DHCP-Gateway-IP-Address */
/* --with-udpfromto is needed just for the following test */
- if (!giaddr || giaddr->vp_ipv4addr != request->packet->dst_ipaddr.ipaddr.v4.s_addr) {
+ if (!giaddr || giaddr->vp_ipv4addr != request->packet->dst_ipaddr.addr.v4.s_addr) {
RDEBUG2("Packet received from server was not for us (was for 0x%x). Discarding packet",
- ntohl(request->packet->dst_ipaddr.ipaddr.v4.s_addr));
+ ntohl(request->packet->dst_ipaddr.addr.v4.s_addr));
return 1;
}
/*
* We're a relay, and send the reply to giaddr.
*/
- request->reply->dst_ipaddr.ipaddr.v4.s_addr = giaddr->vp_ipv4addr;
+ request->reply->dst_ipaddr.addr.v4.s_addr = giaddr->vp_ipv4addr;
request->reply->dst_port = request->packet->dst_port; /* server port */
if ((request->packet->code == PW_DHCP_NAK) ||
* - Broadcast flag is set up and ciaddr == NULL
*/
RDEBUG2("Response will be broadcast");
- request->packet->dst_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_BROADCAST);
+ request->packet->dst_ipaddr.addr.v4.s_addr = htonl(INADDR_BROADCAST);
} else {
/*
* RFC 2131, page 23
*/
if ((vp = fr_pair_find_by_num(request->packet->vps, DHCP_MAGIC_VENDOR, 263, TAG_ANY)) /* DHCP-Client-IP-Address */ &&
(vp->vp_ipv4addr != htonl(INADDR_ANY))) {
- request->packet->dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->packet->dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
} else {
vp = fr_pair_find_by_num(request->packet->vps, DHCP_MAGIC_VENDOR, 264, TAG_ANY); /* DHCP-Your-IP-Address */
if (!vp) {
}
RDEBUG2("Response will be unicast to &DHCP-Your-IP-Address");
- request->packet->dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->packet->dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
/*
* When sending a DHCP_OFFER, make sure our ARP table
vp = fr_pair_find_by_num(request->reply->vps, 0, PW_PACKET_SRC_IP_ADDRESS, TAG_ANY);
if (vp) {
request->reply->if_index = 0; /* Must be 0, we don't know the outbound if_index */
- request->reply->src_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->reply->src_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
/*
* The request was unicast (via a relay)
*/
- } else if (request->packet->dst_ipaddr.ipaddr.v4.s_addr != htonl(INADDR_BROADCAST) &&
- request->packet->dst_ipaddr.ipaddr.v4.s_addr != htonl(INADDR_ANY)) {
- request->reply->src_ipaddr.ipaddr.v4.s_addr = request->packet->dst_ipaddr.ipaddr.v4.s_addr;
+ } else if (request->packet->dst_ipaddr.addr.v4.s_addr != htonl(INADDR_BROADCAST) &&
+ request->packet->dst_ipaddr.addr.v4.s_addr != htonl(INADDR_ANY)) {
+ request->reply->src_ipaddr.addr.v4.s_addr = request->packet->dst_ipaddr.addr.v4.s_addr;
request->reply->if_index = request->packet->if_index;
/*
* The listener was bound to an IP address, or we determined
* the address automatically, as it was the only address bound
* to the interface, and we bound to the interface.
*/
- } else if (sock->src_ipaddr.ipaddr.v4.s_addr != htonl(INADDR_ANY)) {
- request->reply->src_ipaddr.ipaddr.v4.s_addr = sock->src_ipaddr.ipaddr.v4.s_addr;
+ } else if (sock->src_ipaddr.addr.v4.s_addr != htonl(INADDR_ANY)) {
+ request->reply->src_ipaddr.addr.v4.s_addr = sock->src_ipaddr.addr.v4.s_addr;
#ifdef WITH_IFINDEX_IPADDR_RESOLUTION
/*
* We built with udpfromto and have the if_index of the receiving
* There's a Server-Identification attribute
*/
} else if ((vp = fr_pair_find_by_num(request->reply->vps, DHCP_MAGIC_VENDOR, 54, TAG_ANY))) {
- request->reply->src_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->reply->src_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
} else {
REDEBUG("Unable to determine correct src_ipaddr for response");
return RLM_MODULE_FAIL;
vp = fr_pair_find_by_num(request->reply->vps, DHCP_MAGIC_VENDOR, 272, TAG_ANY); /* DHCP-Relay-IP-Address */
if (vp && (vp->vp_ipv4addr != ntohl(INADDR_ANY))) {
RDEBUG2("Reply will be unicast to giaddr from original packet");
- request->reply->dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->reply->dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
request->reply->dst_port = request->packet->dst_port;
vp = fr_pair_find_by_num(request->reply->vps, 0, PW_PACKET_DST_PORT, TAG_ANY);
vp = fr_pair_find_by_num(request->reply->vps, DHCP_MAGIC_VENDOR, 266, TAG_ANY); /* DHCP-Gateway-IP-Address */
if (vp && (vp->vp_ipv4addr != htonl(INADDR_ANY))) {
RDEBUG2("Reply will be unicast to giaddr");
- request->reply->dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->reply->dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
request->reply->dst_port = request->packet->dst_port;
return RLM_MODULE_OK;
}
* - Broadcast flag is set up and ciaddr == NULL
*/
RDEBUG2("Reply will be broadcast");
- request->reply->dst_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_BROADCAST);
+ request->reply->dst_ipaddr.addr.v4.s_addr = htonl(INADDR_BROADCAST);
return RLM_MODULE_OK;
}
if ((vp = fr_pair_find_by_num(request->reply->vps, DHCP_MAGIC_VENDOR, 263, TAG_ANY)) && /* DHCP-Client-IP-Address */
(vp->vp_ipv4addr != htonl(INADDR_ANY))) {
RDEBUG2("Reply will be sent unicast to &DHCP-Client-IP-Address");
- request->reply->dst_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ request->reply->dst_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
return RLM_MODULE_OK;
}
}
}
#else
- if (request->packet->src_ipaddr.ipaddr.v4.s_addr != ntohl(INADDR_NONE)) {
+ if (request->packet->src_ipaddr.addr.v4.s_addr != ntohl(INADDR_NONE)) {
RDEBUG2("Reply will be unicast to the unicast source IP address");
- request->reply->dst_ipaddr.ipaddr.v4.s_addr = request->packet->src_ipaddr.ipaddr.v4.s_addr;
+ request->reply->dst_ipaddr.addr.v4.s_addr = request->packet->src_ipaddr.addr.v4.s_addr;
} else {
RDEBUG2("Reply will be broadcast as this system does not support ARP updates");
- request->reply->dst_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_BROADCAST);
+ request->reply->dst_ipaddr.addr.v4.s_addr = htonl(INADDR_BROADCAST);
}
#endif
cp = cf_pair_find(cs, "src_ipaddr");
if (cp) {
memset(&sock->src_ipaddr, 0, sizeof(sock->src_ipaddr));
- sock->src_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_NONE);
+ sock->src_ipaddr.addr.v4.s_addr = htonl(INADDR_NONE);
rcode = cf_pair_parse(sock, cs, "src_ipaddr",
FR_ITEM_POINTER(PW_TYPE_IPV4_ADDR, &sock->src_ipaddr), NULL, T_INVALID);
if (rcode < 0) return -1;
WARN("Will continue, but source address must be set within the DHCP virtual server");
goto src_addr_is_bound_addr;
}
- inet_ntop(sock->src_ipaddr.af, &sock->src_ipaddr.ipaddr.v4.s_addr, buffer, sizeof(buffer));
+ inet_ntop(sock->src_ipaddr.af, &sock->src_ipaddr.addr.v4.s_addr, buffer, sizeof(buffer));
rad_assert(sock->src_ipaddr.af == AF_INET);
} else {
src_addr_is_bound_addr:
* This lets %{config:} work as expected, if we want to set
* DHCP-DHCP-Server-Identifier.
*/
- inet_ntop(sock->src_ipaddr.af, &sock->src_ipaddr.ipaddr.v4.s_addr, buffer, sizeof(buffer));
+ inet_ntop(sock->src_ipaddr.af, &sock->src_ipaddr.addr.v4.s_addr, buffer, sizeof(buffer));
DEBUG2("\tsrc_ipaddr = \"%s\"", buffer);
cp = cf_pair_alloc(cs, "src_ipaddr", buffer, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
if (!cp) return -1;
client = &sock->dhcp_client;
memset(client, 0, sizeof(*client));
client->ipaddr.af = AF_INET;
- client->ipaddr.ipaddr.v4.s_addr = ntohl(INADDR_NONE);
+ client->ipaddr.addr.v4.s_addr = ntohl(INADDR_NONE);
client->ipaddr.prefix = 0;
client->longname = client->shortname = "dhcp";
client->secret = client->shortname;
packet->id,
packet->src_ipaddr.af == AF_INET6 ? "[" : "",
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
src_ipaddr, sizeof(src_ipaddr)),
packet->src_ipaddr.af == AF_INET6 ? "]" : "",
packet->src_port,
packet->dst_ipaddr.af == AF_INET6 ? "[" : "",
inet_ntop(packet->dst_ipaddr.af,
- &packet->dst_ipaddr.ipaddr,
+ &packet->dst_ipaddr.addr,
dst_ipaddr, sizeof(dst_ipaddr)),
packet->dst_ipaddr.af == AF_INET6 ? "]" : "",
packet->dst_port,
packet->id,
packet->src_ipaddr.af == AF_INET6 ? "[" : "",
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
src_ipaddr, sizeof(src_ipaddr)),
packet->src_ipaddr.af == AF_INET6 ? "]" : "",
packet->src_port,
packet->dst_ipaddr.af == AF_INET6 ? "[" : "",
inet_ntop(packet->dst_ipaddr.af,
- &packet->dst_ipaddr.ipaddr,
+ &packet->dst_ipaddr.addr,
dst_ipaddr, sizeof(dst_ipaddr)),
packet->dst_ipaddr.af == AF_INET6 ? "]" : "",
packet->dst_port,
if (packet->src_ipaddr.af != AF_UNSPEC) {
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
ip_buf, sizeof(ip_buf));
snprintf(buffer, sizeof(buffer), "host %s port %d",
ip_buf, packet->src_port);
switch (packet->src_ipaddr.af) {
case AF_INET:
src_vp.da = fr_dict_attr_by_num(NULL, 0, PW_PACKET_SRC_IP_ADDRESS);
- src_vp.vp_ipv4addr = packet->src_ipaddr.ipaddr.v4.s_addr;
+ src_vp.vp_ipv4addr = packet->src_ipaddr.addr.v4.s_addr;
dst_vp.da = fr_dict_attr_by_num(NULL, 0, PW_PACKET_DST_IP_ADDRESS);
- dst_vp.vp_ipv4addr = packet->dst_ipaddr.ipaddr.v4.s_addr;
+ dst_vp.vp_ipv4addr = packet->dst_ipaddr.addr.v4.s_addr;
break;
case AF_INET6:
src_vp.da = fr_dict_attr_by_num(NULL, 0, PW_PACKET_SRC_IPV6_ADDRESS);
- memcpy(&src_vp.vp_ipv6addr, &packet->src_ipaddr.ipaddr.v6,
- sizeof(packet->src_ipaddr.ipaddr.v6));
+ memcpy(&src_vp.vp_ipv6addr, &packet->src_ipaddr.addr.v6,
+ sizeof(packet->src_ipaddr.addr.v6));
dst_vp.da = fr_dict_attr_by_num(NULL, 0, PW_PACKET_DST_IPV6_ADDRESS);
- memcpy(&dst_vp.vp_ipv6addr, &packet->dst_ipaddr.ipaddr.v6,
- sizeof(packet->dst_ipaddr.ipaddr.v6));
+ memcpy(&dst_vp.vp_ipv6addr, &packet->dst_ipaddr.addr.v6,
+ sizeof(packet->dst_ipaddr.addr.v6));
break;
default:
if (request->proxy) {
char proxy_buffer[INET6_ADDRSTRLEN];
- inet_ntop(request->proxy->packet->dst_ipaddr.af, &request->proxy->packet->dst_ipaddr.ipaddr,
+ inet_ntop(request->proxy->packet->dst_ipaddr.af, &request->proxy->packet->dst_ipaddr.addr,
proxy_buffer, sizeof(proxy_buffer));
WRITE("\tFreeradius-Proxied-To = %s\n", proxy_buffer);
}
nas = fr_pair_find_by_num(request->packet->vps, 0, PW_NAS_IP_ADDRESS, TAG_ANY);
if (!nas) {
nas = radius_pair_create(request->packet, &request->packet->vps, PW_NAS_IP_ADDRESS, 0);
- nas->vp_ipv4addr = request->packet->src_ipaddr.ipaddr.v4.s_addr;
+ nas->vp_ipv4addr = request->packet->src_ipaddr.addr.v4.s_addr;
}
break;
nas = fr_pair_find_by_num(request->packet->vps, 0, PW_NAS_IPV6_ADDRESS, TAG_ANY);
if (!nas) {
nas = radius_pair_create(request->packet, &request->packet->vps, PW_NAS_IPV6_ADDRESS, 0);
- memcpy(&nas->vp_ipv6addr, &request->packet->src_ipaddr.ipaddr,
- sizeof(request->packet->src_ipaddr.ipaddr));
+ memcpy(&nas->vp_ipv6addr, &request->packet->src_ipaddr.addr,
+ sizeof(request->packet->src_ipaddr.addr));
}
break;
vp = pair_make_request("Failed-Home-Server-IP", NULL, T_OP_ADD);
if (vp) {
fr_pair_value_snprintf(vp, "%s", inet_ntop(ccr->packet->dst_ipaddr.af,
- &ccr->packet->dst_ipaddr.ipaddr,
+ &ccr->packet->dst_ipaddr.addr,
buffer, sizeof(buffer)));
}
}
DEBUG("Received unknown reply %s packet from home server %s port %d - ID %u - ignoring",
fr_packet_codes[reply->code],
inet_ntop(reply->src_ipaddr.af,
- &reply->src_ipaddr.ipaddr,
+ &reply->src_ipaddr.addr,
buffer, sizeof(buffer)),
reply->src_port, reply->id);
fr_radius_free(&reply);
RDEBUG("Received reply %s packet from home server %s port %d - ID %u",
fr_packet_codes[reply->code],
inet_ntop(reply->src_ipaddr.af,
- &reply->src_ipaddr.ipaddr,
+ &reply->src_ipaddr.addr,
buffer, sizeof(buffer)),
reply->src_port, reply->id);
fr_packet_codes[packet->code],
ccr->inst->home_server->name,
inet_ntop(packet->dst_ipaddr.af,
- &packet->dst_ipaddr.ipaddr,
+ &packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
packet->dst_port, packet->id);
fr_packet_codes[packet->code],
ccr->inst->home_server->name,
inet_ntop(packet->dst_ipaddr.af,
- &packet->dst_ipaddr.ipaddr,
+ &packet->dst_ipaddr.addr,
buffer, sizeof(buffer)),
packet->dst_port, packet->id);
* originator's IP address.
*/
if (ut.nas_address == htonl(INADDR_NONE)) {
- ut.nas_address = request->packet->src_ipaddr.ipaddr.v4.s_addr;
+ ut.nas_address = request->packet->src_ipaddr.addr.v4.s_addr;
nas = request->client->shortname;
- } else if (request->packet->src_ipaddr.ipaddr.v4.s_addr == ut.nas_address) { /* might be a client, might not be. */
+ } else if (request->packet->src_ipaddr.addr.v4.s_addr == ut.nas_address) { /* might be a client, might not be. */
nas = request->client->shortname;
/*
my_ipaddr.af = AF_INET;
my_ipaddr.prefix = 32;
- my_ipaddr.ipaddr.v4.s_addr = vp->vp_ipv4addr;
+ my_ipaddr.addr.v4.s_addr = vp->vp_ipv4addr;
/*
* Loop over the home accounting servers for this
/*
* Write out the IP address and Port in string form
*/
- p = inet_ntop(node->pending_addr.ipaddr.af, &node->pending_addr.ipaddr.ipaddr,
+ p = inet_ntop(node->pending_addr.ipaddr.af, &node->pending_addr.ipaddr.addr,
node->name, sizeof(node->name));
if (!rad_cond_assert(p)) return CLUSTER_OP_FAILED;
if (!create) {
pthread_mutex_unlock(&cluster->mutex);
- hostname = inet_ntop(node_addr->ipaddr.af, &node_addr->ipaddr.ipaddr, buffer, sizeof(buffer));
+ hostname = inet_ntop(node_addr->ipaddr.af, &node_addr->ipaddr.addr, buffer, sizeof(buffer));
rad_assert(hostname); /* addr.ipaddr is probably corrupt */;
fr_strerror_printf("No existing node found with address %s, port %i",
hostname, node_addr->port);
#define IPPOOL_SPRINT_IP(_buff, _ip, _prefix) \
do { \
if (_prefix == IPADDR_LEN((_ip)->af)) { \
- inet_ntop((_ip)->af, &((_ip)->ipaddr), _buff, sizeof(_buff)); \
+ inet_ntop((_ip)->af, &((_ip)->addr), _buff, sizeof(_buff)); \
} else { \
uint8_t _net = (_ip)->prefix; \
(_ip)->prefix = _prefix; \
lua_update_digest,
key_prefix, key_prefix_len,
(unsigned int)now.tv_sec, expires,
- htonl(ip->ipaddr.v4.s_addr),
+ htonl(ip->addr.v4.s_addr),
device_id, device_id_len,
gateway_id, gateway_id_len);
} else {
lua_release_digest,
key_prefix, key_prefix_len,
(unsigned int)now.tv_sec,
- htonl(ip->ipaddr.v4.s_addr),
+ htonl(ip->addr.v4.s_addr),
device_id, device_id_len);
} else {
char ip_buff[FR_IPADDR_PREFIX_STRLEN];
rad_assert((prefix > 0) && (prefix <= 128));
/* Don't be tempted to cast */
- memcpy(&ip_curr, ipaddr->ipaddr.v6.s6_addr, sizeof(ip_curr));
- memcpy(&ip_end, end->ipaddr.v6.s6_addr, sizeof(ip_curr));
+ memcpy(&ip_curr, ipaddr->addr.v6.s6_addr, sizeof(ip_curr));
+ memcpy(&ip_end, end->addr.v6.s6_addr, sizeof(ip_curr));
ip_curr = ntohlll(ip_curr);
ip_end = ntohlll(ip_end);
/* Increment the prefix */
ip_curr = uint128_add(ip_curr, uint128_lshift(uint128_new(0, 1), (128 - prefix)));
ip_curr = htonlll(ip_curr);
- memcpy(&ipaddr->ipaddr.v6.s6_addr, &ip_curr, sizeof(ipaddr->ipaddr.v6.s6_addr));
+ memcpy(&ipaddr->addr.v6.s6_addr, &ip_curr, sizeof(ipaddr->addr.v6.s6_addr));
return true;
}
rad_assert((prefix > 0) && (prefix <= 32));
- ip_curr = ntohl(ipaddr->ipaddr.v4.s_addr);
- ip_end = ntohl(end->ipaddr.v4.s_addr);
+ ip_curr = ntohl(ipaddr->addr.v4.s_addr);
+ ip_end = ntohl(end->addr.v4.s_addr);
/* We're done */
if (ip_curr == ip_end) return false;
/* Increment the prefix */
ip_curr += 1 << (32 - prefix);
- ipaddr->ipaddr.v4.s_addr = htonl(ip_curr);
+ ipaddr->addr.v4.s_addr = htonl(ip_curr);
return true;
}
}
if (start.af == AF_INET6) {
uint128_t start_int, end_int;
- memcpy(&start_int, start.ipaddr.v6.s6_addr, sizeof(start_int));
- memcpy(&end_int, end.ipaddr.v6.s6_addr, sizeof(end_int));
+ memcpy(&start_int, start.addr.v6.s6_addr, sizeof(start_int));
+ memcpy(&end_int, end.addr.v6.s6_addr, sizeof(end_int));
if (uint128_gt(ntohlll(start_int), ntohlll(end_int))) {
ERROR("End address must be greater than or equal to start address");
return -1;
* IPv4 addresses
*/
} else {
- if (ntohl((uint32_t)(start.ipaddr.v4.s_addr)) >
- ntohl((uint32_t)(end.ipaddr.v4.s_addr))) {
+ if (ntohl((uint32_t)(start.addr.v4.s_addr)) >
+ ntohl((uint32_t)(end.addr.v4.s_addr))) {
ERROR("End address must be greater than or equal to start address");
return -1;
}
if (!rad_cond_assert((prefix > 0) && (prefix <= 128))) return -1;
/* Don't be tempted to cast */
- memcpy(&ip, start.ipaddr.v6.s6_addr, sizeof(ip));
+ memcpy(&ip, start.addr.v6.s6_addr, sizeof(ip));
ip = ntohlll(ip);
/* Generate a mask that covers the prefix bits, and sets them high */
/* Decrement by one */
if (ex_broadcast) ip = uint128_sub(ip, uint128_new(0, 1));
- memcpy(&end.ipaddr.v6.s6_addr, &ip, sizeof(end.ipaddr.v6.s6_addr));
+ memcpy(&end.addr.v6.s6_addr, &ip, sizeof(end.addr.v6.s6_addr));
} else {
uint32_t ip;
/* cond assert to satisfy clang scan */
if (!rad_cond_assert((prefix > 0) && (prefix <= 32))) return -1;
- ip = ntohl(start.ipaddr.v4.s_addr);
+ ip = ntohl(start.addr.v4.s_addr);
/* Generate a mask that covers the prefix bits and sets them high */
ip |= uint32_gen_mask(prefix - start.prefix) << (32 - prefix);
/* Decrement by one */
if (ex_broadcast) ip--;
- end.ipaddr.v4.s_addr = htonl(ip);
+ end.addr.v4.s_addr = htonl(ip);
}
*start_out = start;
* originator's IP address.
*/
if (nas_address == 0) {
- nas_address = request->packet->src_ipaddr.ipaddr.v4.s_addr;
+ nas_address = request->packet->src_ipaddr.addr.v4.s_addr;
}
s = request->client->shortname;
if (!s || s[0] == 0) s = uue(&(nas_address));
FR_DEBUG_STRERROR_PRINTF("Expected at least 4 bytes of header data, got %zu bytes", data_len);
invalid:
FR_DEBUG_STRERROR_PRINTF("Invalid data from %s: %s",
- inet_ntop(src_ipaddr->af, &src_ipaddr->ipaddr, buffer, sizeof(buffer)),
+ inet_ntop(src_ipaddr->af, &src_ipaddr->addr, buffer, sizeof(buffer)),
fr_strerror());
(void) udp_recv_discard(sockfd);
* destination is not link local. Ignore it.
*/
if (src_any && (ps->src_ipaddr.af == AF_INET) &&
- (((ps->src_ipaddr.ipaddr.v4.s_addr >> 24) & 0xff) == 127) &&
- (((request->dst_ipaddr.ipaddr.v4.s_addr >> 24) & 0xff) != 127)) continue;
+ (((ps->src_ipaddr.addr.v4.s_addr >> 24) & 0xff) == 127) &&
+ (((request->dst_ipaddr.addr.v4.s_addr >> 24) & 0xff) != 127)) continue;
/*
* We're sourcing from *, and they asked for a
fr_strerror_printf("Possible DoS attack from host %s: Too many attributes in request "
"(received %d, max %d are allowed)",
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
host_ipaddr, sizeof(host_ipaddr)),
num_attributes, fr_max_attributes);
return -1;
if (!fr_radius_ok(packet->data, &packet->data_len, require_ma, reason)) {
FR_DEBUG_STRERROR_PRINTF("Bad packet received from host %s - %s",
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
host_ipaddr, sizeof(host_ipaddr)),
fr_strerror());
return false;
if (fr_radius_verify(packet->data, original_data,
(uint8_t const *) secret, talloc_array_length(secret) - 1) < 0) {
fr_strerror_printf("Received packet from %s with %s",
- inet_ntop(packet->src_ipaddr.af, &packet->src_ipaddr.ipaddr,
+ inet_ntop(packet->src_ipaddr.af, &packet->src_ipaddr.addr,
buffer, sizeof(buffer)),
fr_strerror());
return -1;
fprintf(fr_log_fp, " Src IP:\t%s\n",
inet_ntop(packet->src_ipaddr.af,
- &packet->src_ipaddr.ipaddr,
+ &packet->src_ipaddr.addr,
buffer, sizeof(buffer)));
fprintf(fr_log_fp, " port:\t%u\n", packet->src_port);
fprintf(fr_log_fp, " Dst IP:\t%s\n",
inet_ntop(packet->dst_ipaddr.af,
- &packet->dst_ipaddr.ipaddr,
+ &packet->dst_ipaddr.addr,
buffer, sizeof(buffer)));
fprintf(fr_log_fp, " port:\t%u\n", packet->dst_port);
}
memset(&my_ipaddr, 0, sizeof(my_ipaddr));
my_ipaddr.af = AF_INET;
- my_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_LOOPBACK);
+ my_ipaddr.addr.v4.s_addr = htonl(INADDR_LOOPBACK);
my_port = 1812;
while ((c = getopt(argc, argv, "c:hi:qs:w:x")) != EOF) switch (c) {
memset(&my_ipaddr, 0, sizeof(my_ipaddr));
my_ipaddr.af = AF_INET;
- my_ipaddr.ipaddr.v4.s_addr = htonl(INADDR_LOOPBACK);
+ my_ipaddr.addr.v4.s_addr = htonl(INADDR_LOOPBACK);
my_port = 1812;
while ((c = getopt(argc, argv, "i:n:s:w:x")) != EOF) switch (c) {
projects / thirdparty / freeradius-server.git / commitdiff
