void quit(int sig)
{
if (sig != -1) {
script_call("shutdown", NULL);
}
base_shutdown();
video_shutdown();
audio_shutdown();
common_shutdown();
exit(0);
}
bool odhcp6c_signal_process(void)
{
if (do_signal == SIGIO) {
do_signal = 0;
bool updated = ra_process();
updated |= ra_rtnl_process();
if (updated && (bound || allow_slaac_only)) {
odhcp6c_expire();
script_call("ra-updated");
}
}
return do_signal != 0;
}
void init(int argc, char *argv[])
{
common_init(argc, argv);
if (unz_exists("config.lua")) {
script_load("config.lua");
}
audio_init();
video_init();
base_init();
script_load("game.lua");
script_call("init", NULL);
}
/**************************************************************************
lua_dostring replacement with error message showing on errors.
**************************************************************************/
static int script_dostring(lua_State *L, const char *str, const char *name)
{
int status;
status = luaL_loadbuffer(L, str, strlen(str), name);
if (status) {
script_report(state, status, str);
} else {
status = script_call(L, 0, LUA_MULTRET);
if (status) {
script_report(state, status, str);
}
}
return status;
}
bool odhcp6c_signal_process(void)
{
if (do_signal == SIGIO) {
do_signal = 0;
bool ra_rtnled = ra_rtnl_process();
bool ra_updated = ra_process();
if (ra_rtnled || (ra_updated && (bound || allow_slaac_only == 0)))
script_call("ra-updated"); // Immediate process urgent events
else if (ra_updated && !bound && allow_slaac_only > 0)
script_delay_call("ra-updated", allow_slaac_only);
}
return do_signal != 0;
}
bool odhcp6c_signal_process(void)
{
while (signal_io) {
signal_io = false;
bool ra_updated = ra_process();
if (ra_link_up())
signal_usr2 = true;
if (ra_updated && (bound || allow_slaac_only >= 0))
script_call("ra-updated"); // Immediate process urgent events
}
return signal_usr1 || signal_usr2 || signal_term;
}
bool odhcp6c_signal_process(void)
{
while (signal_io) {
signal_io = false;
bool ra_updated = ra_process();
if (ra_link_up()) {
signal_usr2 = true;
ra = false;
}
if (ra_updated && (bound || allow_slaac_only >= 0)) {
script_call("ra-updated", (!ra && !bound) ?
script_sync_delay : script_accu_delay, false);
ra = true;
}
}
return signal_usr1 || signal_usr2 || signal_term;
}
bool odhcp6c_signal_process(void)
{
if (do_signal == SIGIO) {
do_signal = 0;
bool ra_updated = ra_process();
if (ra_link_up())
do_signal = SIGUSR2;
if (ra_updated && (bound || allow_slaac_only == 0))
script_call("ra-updated"); // Immediate process urgent events
else if (ra_updated && !bound && allow_slaac_only > 0)
script_delay_call("ra-updated", allow_slaac_only);
#ifdef EXT_BFD_PING
bfd_receive();
#endif
}
return do_signal != 0;
}
bool odhcp6c_signal_process(void)
{
while (signal_io) {
signal_io = false;
bool ra_updated = ra_process();
if (ra_link_up())
signal_usr2 = true;
if (ra_updated && (bound || allow_slaac_only == 0))
script_call("ra-updated"); // Immediate process urgent events
else if (ra_updated && !bound && allow_slaac_only > 0)
script_delay_call("ra-updated", allow_slaac_only);
#ifdef EXT_BFD_PING
bfd_receive();
#endif
}
return signal_usr1 || signal_usr2 || signal_term;
}
/**************************************************************************
Invoke the 'callback_name' Lua function.
**************************************************************************/
bool script_callback_invoke(const char *callback_name,
int nargs, va_list args)
{
int nres;
bool res;
/* The function name */
lua_getglobal(state, callback_name);
if (!lua_isfunction(state, -1)) {
freelog(LOG_ERROR, "lua error: Unknown callback '%s'", callback_name);
lua_pop(state, 1);
return FALSE;
}
script_callback_push_args(nargs, args);
/* Call the function with nargs arguments, return 1 results */
if (script_call(state, nargs, 1)) {
return FALSE;
}
nres = lua_gettop(state);
if (nres == 1) {
if (lua_isboolean(state, -1)) {
res = lua_toboolean(state, -1);
/* Shall we stop the emission of this signal? */
if (res) {
return TRUE;
}
}
}
lua_pop(state, nres);
return FALSE;
}
void BTActionNode::Delegate::abort(BehaviorTree::VirtualMachine& vm, BehaviorTree::IndexType index, void* context, BehaviorTree::VMRunningData& running_data) {
super::abort(vm, index, context, running_data);
script_call(BTStringNames::get_singleton()->_abort, index, context);
}
BehaviorTree::E_State BTActionNode::Delegate::update(BehaviorTree::IndexType index, void* context, BehaviorTree::VMRunningData&) {
Variant result_state = script_call(BTStringNames::get_singleton()->_update, index, context);
ERR_EXPLAIN("Variant type is not int.");
ERR_FAIL_COND_V( result_state.get_type() != Variant::INT, BehaviorTree::BH_ERROR );
return static_cast<BehaviorTree::E_State>(static_cast<int>(result_state));
}
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 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;
}