+#endif
+
+ int replaywin_int;
+
+ if(get_config_int(lookup_config(&config_tree, "ReplayWindow"), &replaywin_int)) {
+ if(replaywin_int < 0) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "ReplayWindow cannot be negative!");
+ return false;
+ }
+
+ replaywin = (unsigned)replaywin_int;
+ sptps_replaywin = replaywin;
+ }
+
+#ifndef DISABLE_LEGACY
+ /* Generate packet encryption key */
+
+ char *cipher;
+
+ if(!get_config_string(lookup_config(&config_tree, "Cipher"), &cipher)) {
+ cipher = xstrdup("aes-256-cbc");
+ }
+
+ if(!strcasecmp(cipher, "none")) {
+ myself->incipher = NULL;
+ } else {
+ myself->incipher = cipher_alloc();
+
+ if(!cipher_open_by_name(myself->incipher, cipher)) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "Unrecognized cipher type!");
+ cipher_free(myself->incipher);
+ myself->incipher = NULL;
+ free(cipher);
+ return false;
+ }
+ }
+
+ free(cipher);
+
+ timeout_add(&keyexpire_timeout, keyexpire_handler, &keyexpire_timeout, &(struct timeval) {
+ keylifetime, jitter()
+ });
+
+ /* Check if we want to use message authentication codes... */
+
+ int maclength = 4;
+ get_config_int(lookup_config(&config_tree, "MACLength"), &maclength);
+
+ if(maclength < 0) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "Bogus MAC length!");
+ return false;
+ }
+
+ char *digest;
+
+ if(!get_config_string(lookup_config(&config_tree, "Digest"), &digest)) {
+ digest = xstrdup("sha256");
+ }
+
+ if(!strcasecmp(digest, "none")) {
+ myself->indigest = NULL;
+ } else {
+ myself->indigest = digest_alloc();
+
+ if(!digest_open_by_name(myself->indigest, digest, maclength)) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "Unrecognized digest type!");
+ digest_free(myself->indigest);
+ myself->indigest = NULL;
+ free(digest);
+ return false;
+ }
+ }
+
+ free(digest);
+#endif
+
+ /* Compression */
+ int incompression = 0;
+
+ if(get_config_int(lookup_config(&config_tree, "Compression"), &incompression)) {
+ myself->incompression = incompression;
+
+ switch(myself->incompression) {
+ case COMPRESS_LZ4:
+#ifdef HAVE_LZ4
+ break;
+#else
+ logger(DEBUG_ALWAYS, LOG_ERR, "Bogus compression level!");
+ logger(DEBUG_ALWAYS, LOG_ERR, "LZ4 compression is unavailable on this node.");
+ return false;
+#endif
+
+ case COMPRESS_LZO_HI:
+ case COMPRESS_LZO_LO:
+#ifdef HAVE_LZO
+ break;
+#else
+ logger(DEBUG_ALWAYS, LOG_ERR, "Bogus compression level!");
+ logger(DEBUG_ALWAYS, LOG_ERR, "LZO compression is unavailable on this node.");
+ return false;
+#endif
+
+ case COMPRESS_ZLIB_9:
+ case COMPRESS_ZLIB_8:
+ case COMPRESS_ZLIB_7:
+ case COMPRESS_ZLIB_6:
+ case COMPRESS_ZLIB_5:
+ case COMPRESS_ZLIB_4:
+ case COMPRESS_ZLIB_3:
+ case COMPRESS_ZLIB_2:
+ case COMPRESS_ZLIB_1:
+#ifdef HAVE_ZLIB
+ break;
+#else
+ logger(DEBUG_ALWAYS, LOG_ERR, "Bogus compression level!");
+ logger(DEBUG_ALWAYS, LOG_ERR, "ZLIB compression is unavailable on this node.");
+ return false;
+#endif
+
+ case COMPRESS_NONE:
+ break;
+
+ default:
+ logger(DEBUG_ALWAYS, LOG_ERR, "Bogus compression level!");
+ logger(DEBUG_ALWAYS, LOG_ERR, "Compression level %i is unrecognized by this node.", myself->incompression);
+ return false;
+ }
+ } else {
+ myself->incompression = COMPRESS_NONE;
+ }
+
+ /* Done */
+
+ myself->nexthop = myself;
+ myself->via = myself;
+ myself->status.reachable = true;
+ myself->last_state_change = now.tv_sec;
+ myself->status.sptps = experimental;
+ node_add(myself);
+
+ graph();
+
+ load_all_nodes();
+
+ /* Open device */
+
+ devops = os_devops;
+
+ if(get_config_string(lookup_config(&config_tree, "DeviceType"), &type)) {
+ if(!strcasecmp(type, DEVICE_DUMMY)) {
+ devops = dummy_devops;
+ } else if(!strcasecmp(type, "raw_socket")) {
+ devops = raw_socket_devops;
+ } else if(!strcasecmp(type, "multicast")) {
+ devops = multicast_devops;
+ }
+
+#ifdef HAVE_SYS_UN_H
+ else if(!strcasecmp(type, "fd")) {
+ devops = fd_devops;
+ }
+
+#endif
+#ifdef ENABLE_UML
+ else if(!strcasecmp(type, "uml")) {
+ devops = uml_devops;
+ }
+
+#endif
+#ifdef ENABLE_VDE
+ else if(!strcasecmp(type, "vde")) {
+ devops = vde_devops;
+ }
+
+#endif
+ free(type);
+ }
+
+ get_config_bool(lookup_config(&config_tree, "DeviceStandby"), &device_standby);
+
+ if(!devops.setup()) {
+ return false;
+ }
+
+ if(device_fd >= 0) {
+ io_add(&device_io, handle_device_data, NULL, device_fd, IO_READ);
+ }
+
+ /* Open sockets */
+
+ if(!do_detach && getenv("LISTEN_FDS")) {
+ sockaddr_t sa;
+ socklen_t salen;
+
+ listen_sockets = atoi(getenv("LISTEN_FDS"));
+#ifdef HAVE_UNSETENV
+ unsetenv("LISTEN_FDS");
+#endif
+
+ if(listen_sockets > MAXSOCKETS) {
+ listen_sockets = MAXSOCKETS;
+ logger(DEBUG_ALWAYS, LOG_ERR, "Too many listening sockets");
+ return false;
+ }
+
+ for(int i = 0; i < listen_sockets; i++) {
+ const int tcp_fd = i + 3;
+ salen = sizeof(sa);
+
+ if(getsockname(tcp_fd, &sa.sa, &salen) < 0) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "Could not get address of listen fd %d: %s", tcp_fd, sockstrerror(sockerrno));
+ return false;
+ }
+
+#ifdef FD_CLOEXEC
+ fcntl(tcp_fd, F_SETFD, FD_CLOEXEC);
+#endif
+
+ int udp_fd = setup_vpn_in_socket(&sa);
+
+ if(udp_fd < 0) {
+ return false;
+ }
+
+ io_add(&listen_socket[i].tcp, (io_cb_t)handle_new_meta_connection, &listen_socket[i], tcp_fd, IO_READ);
+ io_add(&listen_socket[i].udp, (io_cb_t)handle_incoming_vpn_data, &listen_socket[i], udp_fd, IO_READ);
+
+ if(debug_level >= DEBUG_CONNECTIONS) {
+ char *hostname = sockaddr2hostname(&sa);
+ logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Listening on %s", hostname);
+ free(hostname);
+ }
+
+ memcpy(&listen_socket[i].sa, &sa, salen);
+ }
+ } else {
+ listen_sockets = 0;
+ int cfgs = 0;
+
+ for(config_t *cfg = lookup_config(&config_tree, "BindToAddress"); cfg; cfg = lookup_config_next(&config_tree, cfg)) {
+ cfgs++;
+ get_config_string(cfg, &address);
+
+ if(!add_listen_address(address, true)) {
+ return false;
+ }
+ }
+
+ for(config_t *cfg = lookup_config(&config_tree, "ListenAddress"); cfg; cfg = lookup_config_next(&config_tree, cfg)) {
+ cfgs++;
+ get_config_string(cfg, &address);
+
+ if(!add_listen_address(address, false)) {
+ return false;
+ }
+ }
+
+ if(!cfgs)
+ if(!add_listen_address(address, NULL)) {
+ return false;
+ }
+ }
+
+ if(!listen_sockets) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "Unable to create any listening socket!");
+ return false;
+ }
+
+ /* If no Port option was specified, set myport to the port used by the first listening socket. */
+
+ if(!port_specified || atoi(myport.tcp) == 0) {
+ listen_socket_t *sock = &listen_socket[0];
+
+ uint16_t tcp = get_bound_port(sock->tcp.fd);
+ free(myport.tcp);
+ myport.tcp = int_to_str(tcp);
+
+ uint16_t udp = get_bound_port(sock->udp.fd);
+ free(myport.udp);
+ myport.udp = int_to_str(udp);
+ }
+
+ xasprintf(&myself->hostname, "MYSELF port %s", myport.tcp);
+ myself->connection->hostname = xstrdup(myself->hostname);
+
+ char *upnp = NULL;
+ get_config_string(lookup_config(&config_tree, "UPnP"), &upnp);
+ bool upnp_tcp = false;
+ bool upnp_udp = false;
+
+ if(upnp) {
+ if(!strcasecmp(upnp, "yes")) {
+ upnp_tcp = upnp_udp = true;
+ } else if(!strcasecmp(upnp, "udponly")) {
+ upnp_udp = true;
+ }
+
+ free(upnp);
+ }
+
+ if(upnp_tcp || upnp_udp) {
+#ifdef HAVE_MINIUPNPC
+ upnp_init(upnp_tcp, upnp_udp);
+#else
+ logger(DEBUG_ALWAYS, LOG_WARNING, "UPnP was requested, but tinc isn't built with miniupnpc support!");
+#endif
+ }
+
+ /* Done. */
+
+ last_config_check = now.tv_sec;
+
+ return true;
+}
+
+/*
+ initialize network
+*/
+bool setup_network(void) {