void configuration::sanity_check_values()
{
if(conf[DTLS_BIND_PORT] == 0 || conf[DTLS_OUTGOING_PORT] == 0) {
// use random but persistent ports for these
std::ofstream conffile(conf[CONFIG_FILE], std::ios_base::out | std::ios_base::binary | std::ios_base::app);
if(conf[DTLS_BIND_PORT] == 0) {
uint16_t port = ntohs(get_random_port());
iout() << "Assigned DTLS_BIND_PORT random port " << port;
conffile << "\nDTLS_BIND_PORT=" << port << '\n';
assign_value(DTLS_BIND_PORT, port);
}
if(conf[DTLS_OUTGOING_PORT] == 0) {
uint16_t port = ntohs(get_random_port());
iout() << "Assigned DTLS_OUTGOING_PORT random port " << port;
conffile << "\nDTLS_OUTGOING_PORT=" << port << '\n';
assign_value(DTLS_OUTGOING_PORT, port);
}
}
if(conf[DTLS_BIND_PORT] == conf[DTLS_OUTGOING_PORT] || conf[DTLS_BIND6_PORT] == conf[DTLS_OUTGOING_PORT]) {
eout() << "DTLS_BIND_PORT or DTLS_OUTGOING_PORT not initialized to separate valid ports, these should have been set to random ports during installation."
<< " You must set DTLS_BIND_PORT and DTLS_OUTGOING_PORT to separate port numbers in the snow configuration file."
<< " If you have more than one device try to choose different ports for each device.";
abort();
}
check_port(conf[DTLS_OUTGOING_PORT], "DTLS_OUTGOING_PORT");
check_port(conf[DTLS_BIND_PORT], "DTLS_BIND_PORT");
check_port(conf[DTLS_BIND6_PORT], "DTLS_BIND6_PORT");
check_port(conf[DHT_PORT], "DHT_PORT");
check_port(conf[NAMESERV_PORT], "NAMESERV_PORT");
check_nonzero(conf[NAMESERV_TIMEOUT_SECS], "NAMESERV_TIMEOUT_SECS");
check_nonzero(conf[DTLS_IDLE_TIMEOUT_SECS], "DTLS_IDLE_TIMEOUT_SECS");
check_nonzero(conf[HEARTBEAT_SECONDS], "HEARTBEAT_SECONDS");
check_nonzero(conf[HEARTBEAT_RETRIES], "HEARTBEAT_RETRIES");
if(conf[NAT_IP_GRACE_PERIOD_SECONDS] < 1800) {
wout() << "NAT IP grace period of " << conf[NAT_IP_GRACE_PERIOD_SECONDS] << " from configuration file is too short, using minimum grace period of 1800 seconds";
assign_value(NAT_IP_GRACE_PERIOD_SECONDS, 1800);
}
if(conf[DHT_BOOTSTRAP_TARGET]==0) {
wout() << "DHT_BOOTSTRAP_TARGET cannot be zero, using default value";
assign_value(DHT_BOOTSTRAP_TARGET, 6);
}
if(conf[DHT_MAX_PEERS] <= 3) {
wout() << "DHT_MAX_PEERS cannot be " << conf[DHT_MAX_PEERS] << ", must be at least 4, using default value of 99";
assign_value(DHT_MAX_PEERS, 99);
}
if(conf[NATPOOL_NETMASK_BITS] > 20 || conf[NATPOOL_NETMASK_BITS] < 4) {
eout() << "NATPOOL_NETMASK_BITS must be between 4 and 20";
abort();
}
uint32_t addr, netmask = ~htonl((1 << (32 - conf[NATPOOL_NETMASK_BITS])) - 1);
if(inet_pton(AF_INET, conf[NATPOOL_NETWORK].c_str(), &addr) != 1 || (addr & ~netmask) != 0) {
eout() << "NATPOOL_NETWORK/NATPOOL_NETMASK_BITS as " << conf[NATPOOL_NETWORK] << "/" << conf[NATPOOL_NETMASK_BITS] << " is not a valid subnet.";
abort();
}
if(conf[VIRTUAL_INTERFACE_MTU] > 65535 || conf[VIRTUAL_INTERFACE_MTU] < 576) {
eout() << "VIRTUAL_INTERFACE_MTU cannot be " << conf[VIRTUAL_INTERFACE_MTU];
abort();
}
}
void configuration::sanity_check_values()
{
if(conf[MAX_UDP_SIZE] > UINT16_MAX || conf[MAX_UDP_SIZE] < 512) {
wout() << "Invalid max UDP bufsize (" << conf[MAX_UDP_SIZE] << "), reverting to default (65535)";
assign_value(MAX_UDP_SIZE, UINT16_MAX);
}
if(conf[MAX_CLIENT_UDP_RESPONSE] > UINT16_MAX || conf[MAX_CLIENT_UDP_RESPONSE] < 512) {
wout() << "Invalid max client UDP response size (" << conf[MAX_CLIENT_UDP_RESPONSE] << "), reverting to default value (8192)";
assign_value(MAX_CLIENT_UDP_RESPONSE, 8192);
}
if(conf[QUERY_RETRY_MS] > 5000 || conf[QUERY_RETRY_MS] < 10) {
wout() << "Invalid query retry timeout (" << conf[QUERY_RETRY_MS] << " ms), reverting to default (500 ms)";
assign_value(QUERY_RETRY_MS, 500);
}
if(conf[DNS_PORT] > UINT16_MAX || conf[DNS_PORT] == 0) {
wout() << "Invalid DNS port (" << conf[DNS_PORT] << "), reverting to default port (53)";
assign_value(DNS_PORT, 53);
}
if(conf[SNOW_NAMESERV_PORT] > UINT16_MAX || conf[SNOW_NAMESERV_PORT] == 0) {
wout() << "Invalid snow nameserv port (" << conf[SNOW_NAMESERV_PORT] << "), reverting to default port (8)";
assign_value(SNOW_NAMESERV_PORT, 8);
}
if(conf[MAX_TTL] > 604800)
assign_value(MAX_TTL, 604800);
if(conf[DEFAULT_STATIC_TTL] > conf[MAX_TTL])
assign_value(DEFAULT_STATIC_TTL, conf[MAX_TTL]);
if(conf[CACHE_SIZE] < 1024)
assign_value(CACHE_SIZE, 1024);
if(conf[CACHE_SIZE] > 1024*1024*1024)
assign_value(CACHE_SIZE, 1024*1024*1024);
}
static value_object eval_aux(expr* node)
{
if (node == NULL)
return make_null();
if (node->type == EXP_ASSIGN)
return assign_value(node->left, node->right);
value_object left = eval_aux(node->left);
value_object right = eval_aux(node->right);
switch (node->type)
{
case EXP_PLUS:
return add_values(left, right);
case EXP_MINUS:
return sub_values(left, right);
case EXP_TIMES:
return mul_values(left, right);
case EXP_DIV:
return div_values(left, right);
case EXP_INT:
return make_int(atoi(node->text));
case EXP_FLOAT:
return make_float(to_float64(node->text));
case EXP_NATIVE:
return make_native(atof(node->text));
case EXP_CALL:
return eval_function(node->text, node->args);
case EXP_ID:
return get_variable_value(node->text);
case EXP_UNMINUS:
return negate_value(left);
}
}
int main(int argc, char *argv[])
{
int *p = malloc(10 * sizeof(int));
printf("%p\n",p);
printf("%p\n",&p);
assign_value(p);
for (int i = 0; i < 10; ++i)
{
printf("%d\n", *(i + p));
}
printf("\n");
// p = tmp;
return 0;
}
int
set_values(void)
{
int fd = -1, n = 0, val = -1, f_c = 0;
char buf[MAX_VALUES_LEN], *bp = NULL, *fp = NULL, *vp = NULL;
if ( NULL == field ) {
return (0);
} else {
if ( NULL == values ) {
if ( NULL == value_path ) {
return (0);
} else {
if ( (fd = open(value_path, O_RDONLY)) < 0 ) {
ERR("Open initial values file FAIL"); return (-1);
} else {
memset(buf, 0, MAX_VALUES_LEN);
if ( (n = read(fd, buf, MAX_VALUES_LEN-1)) < 0 ) {
ERR("Read initial values file FAIL."); return (-1);
} else if ( 0 <= n ) {
buf[n] = '\0'; values = buf;
}
(void)close(fd);
}
}
}
bp = &(values[0]);
while ( NULL != (fp = str_sep(&bp, &field_separator)) ) {
if ( ++f_c > field_count ) {
ERR("field_count=%d exceeded by f_c=%d", field_count, f_c);
return (-1);
} else if ( assign_value(field[f_c-1], fp) < 0 ) {
return (-1);
}
}
}
return (0);
}
configuration::configuration()
{
// set defaults
#ifdef WINDOWS
assign_value(CONFIG_FILE, get_env_var("PROGRAMFILES") + "\\sdns\\sdns.conf");
assign_value(ROOT_HINTS_FILE, get_env_var("PROGRAMFILES") + "\\sdns\\root.names");
assign_value(STATIC_RECORDS_FILE, get_env_var("PROGRAMFILES") + "\\sdns\\local.names");
assign_value(DNS_FORWARDERS_DIR, get_env_var("PROGRAMFILES") + "\\sdns\\forwarders");
#else
assign_value(CONFIG_FILE, "/etc/sdns/sdns.conf");
assign_value(ROOT_HINTS_FILE, "/etc/sdns/root.names");
assign_value(STATIC_RECORDS_FILE, "/etc/sdns/local.names");
assign_value(DNS_FORWARDERS_DIR, "/etc/sdns/forwarders");
#endif
assign_value(SDNS_USER, "");
assign_value(BIND4_ADDRS, std::vector<uint32_t>(1, htonl(INADDR_LOOPBACK)));
assign_value(BIND6_ADDRS, std::vector<in6_addr>(1, in6addr_loopback));
assign_value(RETRIES_PER_NAMESERVER_ADDR, 4);
// had tried setting max depth at 10 and download.windowsupdate.com could not resolve first try with empty cache because it has five (5) chained CNAMEs
// which exceeded depth 10 between following CNAMEs and following referrals
assign_value(MAX_DNS_QUERY_DEPTH, 25);
assign_value(MAX_UDP_SIZE, 65535);
assign_value(MAX_CLIENT_UDP_RESPONSE, 8192);
assign_value(QUERY_RETRY_MS, 500);
assign_value(DNS_PORT, 53);
assign_value(SNOW_NAMESERV_PORT, 8);
assign_value(SNOW_NAMESERV_TIMEOUT_SECS, 1);
assign_value(SNOW_NAMESERV_TIMEOUT_RETRIES, 8);
assign_value(CACHE_SIZE, 1024*1024);
assign_value(MAX_TTL, 86400);
assign_value(DEFAULT_STATIC_TTL, 1800);
assign_value(MAX_TCP_CLIENTS, 250);
assign_value(SNOW, true);
}
configuration::configuration()
{
// set defaults
// strings
#ifdef WINDOWS
//std::string programdata = get_env_var("PROGRAMDATA"); // [new ALLUSERSPROFILE, doesn't exist on XP/2003]
std::string programdata = get_env_var("ALLUSERSPROFILE");
assign_value(CONFIG_FILE, programdata+"/Application Data/snow/snow.conf");
assign_value(KEY_FILE, programdata+"/Application Data/snow/key.pem");
assign_value(CERT_FILE, programdata+"/Application Data/snow/cert.pem");
assign_value(KNOWN_PEERS_FILE, programdata+"/Application Data/snow/known_peers");
assign_value(DH_PARAMS_FILE, programdata+"/Application Data/snow/DH_params");
assign_value(CLONE_DEVICE, "/dev/net/tun"); // (not used on windows)
assign_value(VIRTUAL_INTERFACE, "auto"); // in config file, "{[GUID]}" of the interface; auto means try to find in registry
assign_value(ADDRESS_ASSIGNMENT_FILE, programdata+"/Application Data/snow/address_assignments");
assign_value(PERMANENT_ADDRESS_ASSIGNMENT_FILE, programdata+"/Application Data/snow/permanent_address_assignments");
#else
assign_value(CONFIG_FILE, "/etc/snow/snow.conf");
assign_value(KEY_FILE, "/etc/snow/key.pem");
assign_value(CERT_FILE, "/etc/snow/cert.pem");
assign_value(KNOWN_PEERS_FILE, "/var/lib/snow/known_peers");
assign_value(DH_PARAMS_FILE, "/etc/snow/DH_params");
assign_value(CLONE_DEVICE, "/dev/net/tun");
assign_value(VIRTUAL_INTERFACE, "snow0");
assign_value(ADDRESS_ASSIGNMENT_FILE, "/var/lib/snow/address_assignments");
assign_value(PERMANENT_ADDRESS_ASSIGNMENT_FILE, "/etc/snow/permanent_address_assignments");
assign_value(SNOW_USER, "");
#endif
assign_value(NATPOOL_NETWORK, "172.16.0.0");
assign_value(PUBLIC_IPV4_ADDRS, std::vector<uint32_t>());
// unsigned integers
assign_value(DTLS_BIND_PORT, 0); // 0 is not valid, must set an arbitrary value in the configuration file
assign_value(DTLS_BIND6_PORT, 8);
assign_value(DTLS_OUTGOING_PORT, 0); // 0 is not valid, must set an arbitrary value in the configuration file
assign_value(DHT_PORT, 8);
assign_value(NAMESERV_PORT, 8);
assign_value(NAMESERV_TIMEOUT_SECS, 7);
assign_value(DTLS_IDLE_TIMEOUT_SECS, 4000);
assign_value(HEARTBEAT_SECONDS, 115);
assign_value(HEARTBEAT_RETRIES, 5);
assign_value(NAT_IP_GRACE_PERIOD_SECONDS, 7200);
assign_value(DHT_BOOTSTRAP_TARGET, 6);
assign_value(DHT_MAX_PEERS, 99);
assign_value(NATPOOL_NETMASK_BITS, 12);
assign_value(VIRTUAL_INTERFACE_MTU, 1419);
// boolean values
assign_value(DHT_RFC1918_ADDRESSES, true);
assign_value(DHT_LINK_LOCAL_ADDRESSES, false);
assign_value(NEVER_TRUST_PEER_VISIBLE_IPADDRS, false);
}
nsphere()
: m_radius(0)
{
assign_value(m_center, coordinate_type());
}
/*****************************************************************************
Gets called by picl_walk_tree_by_class. Then it cycles through the properties
until we find what we are looking for. Once we are done, we return
PICL_WALK_TERMINATE to stop picl_walk_tree_by_class from traversing the tree.
Note that PICL_PTYPE_UNSIGNED_INT and PICL_PTYPE_INT can either be 4-bytes
or 8-bytes.
*****************************************************************************/
static int probe_cpu(picl_nodehdl_t node_hdl, void* dummy_arg) {
picl_prophdl_t p_hdl;
picl_prophdl_t table_hdl;
picl_propinfo_t p_info;
long long long_long_val;
unsigned int uint_val;
int index;
int int_val;
int val;
char string_val[PICL_PROPNAMELEN_MAX];
val = picl_get_first_prop(node_hdl, &p_hdl);
while (val == PICL_SUCCESS) {
called_cpu_probe = 1;
val = picl_get_propinfo(p_hdl, &p_info);
if (val == PICL_SUCCESS) {
for (index = 0; index < NUM_ITEMS; index++) {
if (strcasecmp(p_info.name, items[index]) == 0) {
if (p_info.type == PICL_PTYPE_UNSIGNED_INT) {
if (p_info.size == sizeof(uint_val)) {
val = picl_get_propval(p_hdl, &uint_val, sizeof(uint_val));
if (val == PICL_SUCCESS) {
long_long_val = uint_val;
assign_value(index, long_long_val);
}
}
else if (p_info.size == sizeof(long_long_val)) {
val = picl_get_propval(p_hdl, &long_long_val,
sizeof(long_long_val));
if (val == PICL_SUCCESS) {
assign_value(index, long_long_val);
}
}
}
else if (p_info.type == PICL_PTYPE_INT) {
if (p_info.size == sizeof(int_val)) {
val = picl_get_propval(p_hdl, &int_val, sizeof(int_val));
if (val == PICL_SUCCESS) {
long_long_val = int_val;
assign_value(index, long_long_val);
}
}
else if (p_info.size == sizeof(long_long_val)) {
val = picl_get_propval(p_hdl, &long_long_val,
sizeof(long_long_val));
if (val == PICL_SUCCESS) {
assign_value(index, long_long_val);
}
}
}
else if (p_info.type == PICL_PTYPE_CHARSTRING) {
val = picl_get_propval(p_hdl, &string_val, sizeof(string_val));
if (val == PICL_SUCCESS) {
assign_string_value(index, string_val);
}
}
else if (p_info.type == PICL_PTYPE_TABLE) {
val = picl_get_propval(p_hdl, &table_hdl, p_info.size);
if (val == PICL_SUCCESS) {
search_table(index, table_hdl);
}
}
break;
} else if (index == NUM_ITEMS-1) {
if (p_info.type == PICL_PTYPE_CHARSTRING) {
val = picl_get_propval(p_hdl, &string_val, sizeof(string_val));
if (val == PICL_SUCCESS) {
}
}
}
}
}
val = picl_get_next_prop(p_hdl, &p_hdl);
}
return PICL_WALK_TERMINATE;
}
