int main(_unused int argc, char* const argv[])
{
openlog("odhcp6c", LOG_PERROR | LOG_PID, LOG_DAEMON);
// Allocate ressources
const char *pidfile = NULL;
const char *script = "/usr/sbin/odhcp6c-update";
ssize_t l;
uint8_t buf[134];
char *optpos;
uint16_t opttype;
enum odhcp6c_ia_mode ia_na_mode = IA_MODE_TRY;
bool help = false, daemonize = false;
int c, request_pd = 0;
while ((c = getopt(argc, argv, "N:P:c:r:s:p:Sqdh")) != -1) {
switch (c) {
case 'S':
allow_slaac_only = false;
break;
case 'N':
if (!strcmp(optarg, "force"))
ia_na_mode = IA_MODE_FORCE;
else if (!strcmp(optarg, "none"))
ia_na_mode = IA_MODE_NONE;
else if (!strcmp(optarg, "try"))
ia_na_mode = IA_MODE_TRY;
else
help = true;
break;
case 'P':
allow_slaac_only = false;
request_pd = strtoul(optarg, NULL, 10);
if (request_pd == 0)
request_pd = -1;
break;
case 'c':
l = script_unhexlify(&buf[4], sizeof(buf) - 4, optarg);
if (l > 0) {
buf[0] = 0;
buf[1] = DHCPV6_OPT_CLIENTID;
buf[2] = 0;
buf[4] = l;
odhcp6c_add_state(STATE_CLIENT_ID, buf, l + 4);
} else {
help = true;
}
break;
case 'q':
log_quiet = true;
break;
case 'r':
optpos = optarg;
while (optpos[0]) {
opttype = htons(strtoul(optarg, &optpos, 10));
if (optpos == optarg)
break;
else if (optpos[0])
optarg = &optpos[1];
odhcp6c_add_state(STATE_ORO, &opttype, 2);
}
break;
case 's':
script = optarg;
break;
case 'd':
daemonize = true;
break;
case 'p':
pidfile = optarg;
break;
default:
help = true;
break;
}
}
const char *ifname = argv[optind];
if (help || !ifname)
return usage();
if ((urandom_fd = open("/dev/urandom", O_CLOEXEC | O_RDONLY)) < 0 ||
init_dhcpv6(ifname, request_pd) || ra_init(ifname) ||
script_init(script, ifname)) {
dhcpv6_syslog(LOG_ERR, "failed to initialize: %s", strerror(errno));
return 3;
}
signal(SIGIO, sighandler);
signal(SIGHUP, sighandler);
signal(SIGINT, sighandler);
signal(SIGCHLD, sighandler);
signal(SIGTERM, sighandler);
signal(SIGUSR1, sighandler);
signal(SIGUSR2, sighandler);
if (daemonize) {
openlog("odhcp6c", LOG_PID, LOG_DAEMON); // Disable LOG_PERROR
if (daemon(0, 0)) {
dhcpv6_syslog(LOG_ERR, "Failed to daemonize: %s",
strerror(errno));
return 4;
}
char pidbuf[128];
if (!pidfile) {
snprintf(pidbuf, sizeof(pidbuf),
"/var/run/odhcp6c.%s.pid", ifname);
pidfile = pidbuf;
}
int fd = open(pidfile, O_WRONLY | O_CREAT);
if (fd >= 0) {
char buf[8];
int len = snprintf(buf, sizeof(buf), "%i\n", getpid());
write(fd, buf, len);
close(fd);
}
}
script_call("started");
while (do_signal != SIGTERM) { // Main logic
odhcp6c_clear_state(STATE_SERVER_ID);
odhcp6c_clear_state(STATE_SERVER_CAND);
odhcp6c_clear_state(STATE_IA_PD);
odhcp6c_clear_state(STATE_SNTP_IP);
odhcp6c_clear_state(STATE_SNTP_FQDN);
odhcp6c_clear_state(STATE_SIP_IP);
odhcp6c_clear_state(STATE_SIP_FQDN);
dhcpv6_set_ia_na_mode(ia_na_mode);
bound = false;
dhcpv6_syslog(LOG_NOTICE, "(re)starting transaction on %s", ifname);
do_signal = 0;
int res = dhcpv6_request(DHCPV6_MSG_SOLICIT);
odhcp6c_signal_process();
if (res < 0) {
continue; // Might happen if we got a signal
} else if (res == DHCPV6_STATELESS) { // Stateless mode
while (do_signal == 0 || do_signal == SIGUSR1) {
do_signal = 0;
res = dhcpv6_request(DHCPV6_MSG_INFO_REQ);
odhcp6c_signal_process();
if (do_signal == SIGUSR1)
continue;
else if (res < 0)
break;
else if (res > 0)
script_call("informed");
bound = true;
dhcpv6_syslog(LOG_NOTICE, "entering stateless-mode on %s", ifname);
if (dhcpv6_poll_reconfigure() > 0)
script_call("informed");
}
continue;
}
// Stateful mode
if (dhcpv6_request(DHCPV6_MSG_REQUEST) < 0)
continue;
odhcp6c_signal_process();
script_call("bound");
bound = true;
dhcpv6_syslog(LOG_NOTICE, "entering stateful-mode on %s", ifname);
while (do_signal == 0 || do_signal == SIGUSR1) {
// Renew Cycle
// Wait for T1 to expire or until we get a reconfigure
int res = dhcpv6_poll_reconfigure();
odhcp6c_signal_process();
if (res >= 0) {
if (res > 0)
script_call("updated");
continue;
}
// Handle signal, if necessary
if (do_signal == SIGUSR1)
do_signal = 0; // Acknowledged
else if (do_signal > 0)
break; // Other signal type
size_t ia_pd_len, ia_na_len, ia_pd_new, ia_na_new;
odhcp6c_get_state(STATE_IA_PD, &ia_pd_len);
odhcp6c_get_state(STATE_IA_NA, &ia_na_len);
// If we have any IAs, send renew, otherwise request
int r;
if (ia_pd_len == 0 && ia_na_len == 0)
r = dhcpv6_request(DHCPV6_MSG_REQUEST);
else
r = dhcpv6_request(DHCPV6_MSG_RENEW);
odhcp6c_signal_process();
if (r > 0) // Publish updates
script_call("updated");
if (r >= 0)
continue; // Renew was successful
odhcp6c_clear_state(STATE_SERVER_ID); // Remove binding
// If we have IAs, try rebind otherwise restart
res = dhcpv6_request(DHCPV6_MSG_REBIND);
odhcp6c_signal_process();
odhcp6c_get_state(STATE_IA_PD, &ia_pd_new);
odhcp6c_get_state(STATE_IA_NA, &ia_na_new);
if (res < 0 || (ia_pd_new == 0 && ia_pd_len) ||
(ia_na_new == 0 && ia_na_len))
break; // We lost all our IAs, restart
else if (res > 0)
script_call("rebound");
}
size_t ia_pd_len, ia_na_len, server_id_len;
odhcp6c_get_state(STATE_IA_PD, &ia_pd_len);
odhcp6c_get_state(STATE_IA_NA, &ia_na_len);
odhcp6c_get_state(STATE_SERVER_ID, &server_id_len);
// Add all prefixes to lost prefixes
bound = false;
script_call("unbound");
if (server_id_len > 0 && (ia_pd_len > 0 || ia_na_len > 0))
dhcpv6_request(DHCPV6_MSG_RELEASE);
odhcp6c_clear_state(STATE_IA_NA);
odhcp6c_clear_state(STATE_IA_PD);
}
script_call("stopped");
return 0;
}
int init_dhcpv6(const char *ifname, unsigned int options, int sol_timeout)
{
client_options = options;
dhcpv6_retx[DHCPV6_MSG_SOLICIT].max_timeo = sol_timeout;
#ifdef SOCK_CLOEXEC
sock = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
#else
sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
sock = fflags(sock, O_CLOEXEC);
#endif
if (sock < 0)
return -1;
// Detect interface
struct ifreq ifr;
strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
if (ioctl(sock, SIOCGIFINDEX, &ifr) < 0)
return -1;
ifindex = ifr.ifr_ifindex;
// Create client DUID
size_t client_id_len;
odhcp6c_get_state(STATE_CLIENT_ID, &client_id_len);
if (client_id_len == 0) {
uint8_t duid[14] = {0, DHCPV6_OPT_CLIENTID, 0, 10, 0,
DHCPV6_DUID_LLADDR, 0, 1};
if (ioctl(sock, SIOCGIFHWADDR, &ifr) >= 0)
memcpy(&duid[8], ifr.ifr_hwaddr.sa_data, ETHER_ADDR_LEN);
uint8_t zero[ETHER_ADDR_LEN] = {0, 0, 0, 0, 0, 0};
struct ifreq ifs[100], *ifp, *ifend;
struct ifconf ifc;
ifc.ifc_req = ifs;
ifc.ifc_len = sizeof(ifs);
if (!memcmp(&duid[8], zero, ETHER_ADDR_LEN) &&
ioctl(sock, SIOCGIFCONF, &ifc) >= 0) {
// If our interface doesn't have an address...
ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
for (ifp = ifc.ifc_req; ifp < ifend &&
!memcmp(&duid[8], zero, ETHER_ADDR_LEN); ifp++) {
memcpy(ifr.ifr_name, ifp->ifr_name,
sizeof(ifr.ifr_name));
if (ioctl(sock, SIOCGIFHWADDR, &ifr) < 0)
continue;
memcpy(&duid[8], ifr.ifr_hwaddr.sa_data,
ETHER_ADDR_LEN);
}
}
odhcp6c_add_state(STATE_CLIENT_ID, duid, sizeof(duid));
}
// Create ORO
if (!(client_options & DHCPV6_STRICT_OPTIONS)) {
uint16_t oro[] = {
htons(DHCPV6_OPT_SIP_SERVER_D),
htons(DHCPV6_OPT_SIP_SERVER_A),
htons(DHCPV6_OPT_DNS_SERVERS),
htons(DHCPV6_OPT_DNS_DOMAIN),
htons(DHCPV6_OPT_SNTP_SERVERS),
htons(DHCPV6_OPT_NTP_SERVER),
htons(DHCPV6_OPT_AFTR_NAME),
htons(DHCPV6_OPT_PD_EXCLUDE),
htons(DHCPV6_OPT_SOL_MAX_RT),
htons(DHCPV6_OPT_INF_MAX_RT),
#ifdef EXT_CER_ID
htons(DHCPV6_OPT_CER_ID),
#endif
htons(DHCPV6_OPT_S46_CONT_MAPE),
htons(DHCPV6_OPT_S46_CONT_MAPT),
htons(DHCPV6_OPT_S46_CONT_LW),
};
odhcp6c_add_state(STATE_ORO, oro, sizeof(oro));
}
// Configure IPv6-options
int val = 1;
setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof(val));
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
setsockopt(sock, IPPROTO_IPV6, IPV6_RECVPKTINFO, &val, sizeof(val));
setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen(ifname));
struct sockaddr_in6 client_addr = { .sin6_family = AF_INET6,
.sin6_port = htons(DHCPV6_CLIENT_PORT), .sin6_flowinfo = 0 };
if (bind(sock, (struct sockaddr*)&client_addr, sizeof(client_addr)) < 0)
return -1;
return 0;
}
enum {
IOV_HDR=0,
IOV_ORO,
IOV_ORO_REFRESH,
IOV_CL_ID,
IOV_SRV_ID,
IOV_VENDOR_CLASS_HDR,
IOV_VENDOR_CLASS,
IOV_USER_CLASS_HDR,
IOV_USER_CLASS,
IOV_RECONF_ACCEPT,
IOV_FQDN,
IOV_HDR_IA_NA,
IOV_IA_NA,
IOV_IA_PD,
IOV_TOTAL
};
int dhcpv6_set_ia_mode(enum odhcp6c_ia_mode na, enum odhcp6c_ia_mode pd)
{
int mode = DHCPV6_UNKNOWN;
na_mode = na;
pd_mode = pd;
if (na_mode == IA_MODE_NONE && pd_mode == IA_MODE_NONE)
mode = DHCPV6_STATELESS;
else if (na_mode == IA_MODE_FORCE || pd_mode == IA_MODE_FORCE)
mode = DHCPV6_STATEFUL;
return mode;
}
int main(_unused int argc, char* const argv[])
{
// Allocate ressources
const char *pidfile = NULL;
const char *script = "/usr/sbin/odhcp6c-update";
ssize_t l;
uint8_t buf[134];
char *optpos;
uint16_t opttype;
uint16_t optlen;
enum odhcp6c_ia_mode ia_na_mode = IA_MODE_TRY;
enum odhcp6c_ia_mode ia_pd_mode = IA_MODE_NONE;
int ia_pd_iaid_index = 0;
static struct in6_addr ifid = IN6ADDR_ANY_INIT;
int sol_timeout = DHCPV6_SOL_MAX_RT;
#ifdef EXT_BFD_PING
int bfd_interval = 0, bfd_loss = 3;
#endif
bool help = false, daemonize = false;
int logopt = LOG_PID;
int c;
unsigned int client_options = DHCPV6_CLIENT_FQDN | DHCPV6_ACCEPT_RECONFIGURE;
while ((c = getopt(argc, argv, "S::N:V:P:FB:c:i:r:Ru:s:kt:m:hedp:fa")) != -1) {
switch (c) {
case 'S':
allow_slaac_only = (optarg) ? atoi(optarg) : -1;
break;
case 'N':
if (!strcmp(optarg, "force")) {
ia_na_mode = IA_MODE_FORCE;
allow_slaac_only = -1;
} else if (!strcmp(optarg, "none")) {
ia_na_mode = IA_MODE_NONE;
} else if (!strcmp(optarg, "try")) {
ia_na_mode = IA_MODE_TRY;
} else{
help = true;
}
break;
case 'V':
l = script_unhexlify(buf, sizeof(buf), optarg);
if (!l)
help=true;
odhcp6c_add_state(STATE_VENDORCLASS, buf, l);
break;
case 'P':
if (ia_pd_mode == IA_MODE_NONE)
ia_pd_mode = IA_MODE_TRY;
if (allow_slaac_only >= 0 && allow_slaac_only < 10)
allow_slaac_only = 10;
char *iaid_begin;
int iaid_len = 0;
int prefix_length = strtoul(optarg, &iaid_begin, 10);
if (*iaid_begin != '\0' && *iaid_begin != ',' && *iaid_begin != ':') {
syslog(LOG_ERR, "invalid argument: '%s'", optarg);
return 1;
}
struct odhcp6c_request_prefix prefix = { 0, prefix_length };
if (*iaid_begin == ',' && (iaid_len = strlen(iaid_begin)) > 1)
memcpy(&prefix.iaid, iaid_begin + 1, iaid_len > 4 ? 4 : iaid_len);
else if (*iaid_begin == ':')
prefix.iaid = htonl((uint32_t)strtoul(&iaid_begin[1], NULL, 16));
else
prefix.iaid = htonl(++ia_pd_iaid_index);
odhcp6c_add_state(STATE_IA_PD_INIT, &prefix, sizeof(prefix));
break;
case 'F':
allow_slaac_only = -1;
ia_pd_mode = IA_MODE_FORCE;
break;
#ifdef EXT_BFD_PING
case 'B':
bfd_interval = atoi(optarg);
break;
#endif
case 'c':
l = script_unhexlify(&buf[4], sizeof(buf) - 4, optarg);
if (l > 0) {
buf[0] = 0;
buf[1] = DHCPV6_OPT_CLIENTID;
buf[2] = 0;
buf[3] = l;
odhcp6c_add_state(STATE_CLIENT_ID, buf, l + 4);
} else {
help = true;
}
break;
case 'i':
if (inet_pton(AF_INET6, optarg, &ifid) != 1)
help = true;
break;
case 'r':
optpos = optarg;
while (optpos[0]) {
opttype = htons(strtoul(optarg, &optpos, 10));
if (optpos == optarg)
break;
else if (optpos[0])
optarg = &optpos[1];
odhcp6c_add_state(STATE_ORO, &opttype, 2);
}
break;
case 'R':
client_options |= DHCPV6_STRICT_OPTIONS;
break;
case 'u':
optlen = htons(strlen(optarg));
odhcp6c_add_state(STATE_USERCLASS, &optlen, 2);
odhcp6c_add_state(STATE_USERCLASS, optarg, strlen(optarg));
break;
case 's':
script = optarg;
break;
case 'k':
release = false;
break;
case 't':
sol_timeout = atoi(optarg);
break;
case 'm':
min_update_interval = atoi(optarg);
break;
case 'e':
logopt |= LOG_PERROR;
break;
case 'd':
daemonize = true;
break;
case 'p':
pidfile = optarg;
break;
case 'f':
client_options &= ~DHCPV6_CLIENT_FQDN;
break;
case 'a':
client_options &= ~DHCPV6_ACCEPT_RECONFIGURE;
break;
default:
help = true;
break;
}
}
openlog("odhcp6c", logopt, LOG_DAEMON);
const char *ifname = argv[optind];
if (help || !ifname)
return usage();
signal(SIGIO, sighandler);
signal(SIGHUP, sighandler);
signal(SIGINT, sighandler);
signal(SIGCHLD, sighandler);
signal(SIGTERM, sighandler);
signal(SIGUSR1, sighandler);
signal(SIGUSR2, sighandler);
if ((urandom_fd = open("/dev/urandom", O_CLOEXEC | O_RDONLY)) < 0 ||
init_dhcpv6(ifname, client_options, sol_timeout) ||
ra_init(ifname, &ifid) || script_init(script, ifname)) {
syslog(LOG_ERR, "failed to initialize: %s", strerror(errno));
return 3;
}
if (daemonize) {
openlog("odhcp6c", LOG_PID, LOG_DAEMON); // Disable LOG_PERROR
if (daemon(0, 0)) {
syslog(LOG_ERR, "Failed to daemonize: %s",
strerror(errno));
return 4;
}
char pidbuf[128];
if (!pidfile) {
snprintf(pidbuf, sizeof(pidbuf),
"/var/run/odhcp6c.%s.pid", ifname);
pidfile = pidbuf;
}
int fd = open(pidfile, O_WRONLY | O_CREAT, 0644);
if (fd >= 0) {
char buf[8];
int len = snprintf(buf, sizeof(buf), "%i\n", getpid());
write(fd, buf, len);
close(fd);
}
}
script_call("started");
while (!signal_term) { // Main logic
odhcp6c_clear_state(STATE_SERVER_ID);
odhcp6c_clear_state(STATE_IA_NA);
odhcp6c_clear_state(STATE_IA_PD);
odhcp6c_clear_state(STATE_SNTP_IP);
odhcp6c_clear_state(STATE_NTP_IP);
odhcp6c_clear_state(STATE_NTP_FQDN);
odhcp6c_clear_state(STATE_SIP_IP);
odhcp6c_clear_state(STATE_SIP_FQDN);
dhcpv6_set_ia_mode(ia_na_mode, ia_pd_mode);
bound = false;
syslog(LOG_NOTICE, "(re)starting transaction on %s", ifname);
signal_usr1 = signal_usr2 = false;
int mode = dhcpv6_request(DHCPV6_MSG_SOLICIT);
odhcp6c_signal_process();
if (mode < 0)
continue;
do {
int res = dhcpv6_request(mode == DHCPV6_STATELESS ?
DHCPV6_MSG_INFO_REQ : DHCPV6_MSG_REQUEST);
bool signalled = odhcp6c_signal_process();
if (res > 0)
break;
else if (signalled) {
mode = -1;
break;
}
mode = dhcpv6_promote_server_cand();
} while (mode > DHCPV6_UNKNOWN);
if (mode < 0)
continue;
switch (mode) {
case DHCPV6_STATELESS:
bound = true;
syslog(LOG_NOTICE, "entering stateless-mode on %s", ifname);
while (!signal_usr2 && !signal_term) {
signal_usr1 = false;
script_call("informed");
int res = dhcpv6_poll_reconfigure();
odhcp6c_signal_process();
if (res > 0)
continue;
if (signal_usr1) {
signal_usr1 = false; // Acknowledged
continue;
}
if (signal_usr2 || signal_term)
break;
res = dhcpv6_request(DHCPV6_MSG_INFO_REQ);
odhcp6c_signal_process();
if (signal_usr1)
continue;
else if (res < 0)
break;
}
break;
case DHCPV6_STATEFUL:
script_call("bound");
bound = true;
syslog(LOG_NOTICE, "entering stateful-mode on %s", ifname);
#ifdef EXT_BFD_PING
if (bfd_interval > 0)
bfd_start(ifname, bfd_loss, bfd_interval);
#endif
while (!signal_usr2 && !signal_term) {
// Renew Cycle
// Wait for T1 to expire or until we get a reconfigure
int res = dhcpv6_poll_reconfigure();
odhcp6c_signal_process();
if (res > 0) {
script_call("updated");
continue;
}
// Handle signal, if necessary
if (signal_usr1)
signal_usr1 = false; // Acknowledged
if (signal_usr2 || signal_term)
break; // Other signal type
// Send renew as T1 expired
res = dhcpv6_request(DHCPV6_MSG_RENEW);
odhcp6c_signal_process();
if (res > 0) { // Renew was succesfull
// Publish updates
script_call("updated");
continue; // Renew was successful
}
odhcp6c_clear_state(STATE_SERVER_ID); // Remove binding
size_t ia_pd_len, ia_na_len;
odhcp6c_get_state(STATE_IA_PD, &ia_pd_len);
odhcp6c_get_state(STATE_IA_NA, &ia_na_len);
if (ia_pd_len == 0 && ia_na_len == 0)
break;
// If we have IAs, try rebind otherwise restart
res = dhcpv6_request(DHCPV6_MSG_REBIND);
odhcp6c_signal_process();
if (res > 0)
script_call("rebound");
else {
#ifdef EXT_BFD_PING
bfd_stop();
#endif
break;
}
}
break;
default:
break;
}
size_t ia_pd_len, ia_na_len, server_id_len;
odhcp6c_get_state(STATE_IA_PD, &ia_pd_len);
odhcp6c_get_state(STATE_IA_NA, &ia_na_len);
odhcp6c_get_state(STATE_SERVER_ID, &server_id_len);
// Add all prefixes to lost prefixes
bound = false;
script_call("unbound");
if (server_id_len > 0 && (ia_pd_len > 0 || ia_na_len > 0) && release)
dhcpv6_request(DHCPV6_MSG_RELEASE);
odhcp6c_clear_state(STATE_IA_NA);
odhcp6c_clear_state(STATE_IA_PD);
}
script_call("stopped");
return 0;
}
