X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Fmeshlink.c;h=69dd71415519252a6198b02a59da07f7dc1834f1;hb=f712fdc0b3de22566cdf06954256c62f46f25542;hp=66d87ee986cde60a8b3689fb0820b1bbbb7f0f51;hpb=56e0dd5ad3936663d398500f80c9a502553659df;p=meshlink diff --git a/src/meshlink.c b/src/meshlink.c index 66d87ee9..69dd7141 100644 --- a/src/meshlink.c +++ b/src/meshlink.c @@ -1,6 +1,6 @@ /* meshlink.c -- Implementation of the MeshLink API. - Copyright (C) 2014, 2017 Guus Sliepen + Copyright (C) 2014-2018 Guus Sliepen This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -56,64 +56,13 @@ meshlink_log_level_t global_log_level; //TODO: this can go away completely const var_t variables[] = { /* Server configuration */ - {"AddressFamily", VAR_SERVER}, - {"AutoConnect", VAR_SERVER | VAR_SAFE}, - {"BindToAddress", VAR_SERVER | VAR_MULTIPLE}, - {"BindToInterface", VAR_SERVER}, - {"Broadcast", VAR_SERVER | VAR_SAFE}, {"ConnectTo", VAR_SERVER | VAR_MULTIPLE | VAR_SAFE}, - {"DecrementTTL", VAR_SERVER}, - {"Device", VAR_SERVER}, - {"DeviceType", VAR_SERVER}, - {"DirectOnly", VAR_SERVER}, - {"ECDSAPrivateKeyFile", VAR_SERVER}, - {"ExperimentalProtocol", VAR_SERVER}, - {"Forwarding", VAR_SERVER}, - {"GraphDumpFile", VAR_SERVER | VAR_OBSOLETE}, - {"Hostnames", VAR_SERVER}, - {"IffOneQueue", VAR_SERVER}, - {"Interface", VAR_SERVER}, - {"KeyExpire", VAR_SERVER}, - {"ListenAddress", VAR_SERVER | VAR_MULTIPLE}, - {"LocalDiscovery", VAR_SERVER}, - {"MACExpire", VAR_SERVER}, - {"MaxConnectionBurst", VAR_SERVER}, - {"MaxOutputBufferSize", VAR_SERVER}, - {"MaxTimeout", VAR_SERVER}, - {"Mode", VAR_SERVER | VAR_SAFE}, {"Name", VAR_SERVER}, - {"PingInterval", VAR_SERVER}, - {"PingTimeout", VAR_SERVER}, - {"PriorityInheritance", VAR_SERVER}, - {"PrivateKey", VAR_SERVER | VAR_OBSOLETE}, - {"PrivateKeyFile", VAR_SERVER}, - {"ProcessPriority", VAR_SERVER}, - {"Proxy", VAR_SERVER}, - {"ReplayWindow", VAR_SERVER}, - {"ScriptsExtension", VAR_SERVER}, - {"ScriptsInterpreter", VAR_SERVER}, - {"StrictSubnets", VAR_SERVER}, - {"TunnelServer", VAR_SERVER}, - {"VDEGroup", VAR_SERVER}, - {"VDEPort", VAR_SERVER}, /* Host configuration */ + {"CanonicalAddress", VAR_HOST}, {"Address", VAR_HOST | VAR_MULTIPLE}, - {"Cipher", VAR_SERVER | VAR_HOST}, - {"ClampMSS", VAR_SERVER | VAR_HOST}, - {"Compression", VAR_SERVER | VAR_HOST}, - {"Digest", VAR_SERVER | VAR_HOST}, {"ECDSAPublicKey", VAR_HOST}, - {"ECDSAPublicKeyFile", VAR_SERVER | VAR_HOST}, - {"IndirectData", VAR_SERVER | VAR_HOST}, - {"MACLength", VAR_SERVER | VAR_HOST}, - {"PMTU", VAR_SERVER | VAR_HOST}, - {"PMTUDiscovery", VAR_SERVER | VAR_HOST}, {"Port", VAR_HOST}, - {"PublicKey", VAR_HOST | VAR_OBSOLETE}, - {"PublicKeyFile", VAR_SERVER | VAR_HOST | VAR_OBSOLETE}, - {"Subnet", VAR_HOST | VAR_MULTIPLE | VAR_SAFE}, - {"TCPOnly", VAR_SERVER | VAR_HOST}, - {"Weight", VAR_HOST | VAR_SAFE}, {NULL, 0} }; @@ -148,6 +97,7 @@ static int rstrip(char *value) { static void scan_for_hostname(const char *filename, char **hostname, char **port) { char line[4096]; + bool canonical = false; if(!filename || (*hostname && *port)) { return; @@ -187,25 +137,33 @@ static void scan_for_hostname(const char *filename, char **hostname, char **port p += strspn(p, "\t "); p[strcspn(p, "\t ")] = 0; - // p is now pointing to the port - - // Check that the hostname is a symbolic name (it's not a numeric IPv4 or IPv6 address) - if(!q[strspn(q, "0123456789.")] || strchr(q, ':')) { - continue; - } + // p is now pointing to the port, if present if(!*port && !strcasecmp(line, "Port")) { *port = xstrdup(q); - } else if(!*hostname && !strcasecmp(line, "Address")) { + } else if(!canonical && !*hostname && !strcasecmp(line, "Address")) { + // Check that the hostname is a symbolic name (it's not a numeric IPv4 or IPv6 address) + if(!q[strspn(q, "0123456789.")] || strchr(q, ':')) { + continue; + } + *hostname = xstrdup(q); + if(*p) { + free(*port); + *port = xstrdup(p); + } + } else if(!strcasecmp(line, "CanonicalAddress")) { + *hostname = xstrdup(q); + canonical = true; + if(*p) { free(*port); *port = xstrdup(p); } } - if(*hostname && *port) { + if(canonical && *hostname && *port) { break; } } @@ -214,6 +172,10 @@ static void scan_for_hostname(const char *filename, char **hostname, char **port } static bool is_valid_hostname(const char *hostname) { + if(!*hostname) { + return false; + } + for(const char *p = hostname; *p; p++) { if(!(isalnum(*p) || *p == '-' || *p == '.' || *p == ':')) { return false; @@ -223,6 +185,26 @@ static bool is_valid_hostname(const char *hostname) { return true; } +static bool is_valid_port(const char *port) { + if(!*port) { + return false; + } + + if(isdigit(*port)) { + char *end; + unsigned long int result = strtoul(port, &end, 10); + return result && result < 65536 && !*end; + } + + for(const char *p = port; *p; p++) { + if(!(isalnum(*p) || *p == '-')) { + return false; + } + } + + return true; +} + static void set_timeout(int sock, int timeout) { #ifdef _WIN32 DWORD tv = timeout; @@ -388,7 +370,7 @@ static char *get_my_hostname(meshlink_handle_t *mesh) { return NULL; } - if(!strcmp(hostname[0], hostname[1])) { + if(hostname[0] && hostname[1] && !strcmp(hostname[0], hostname[1])) { free(hostname[1]); hostname[1] = NULL; } @@ -552,6 +534,31 @@ int check_port(meshlink_handle_t *mesh) { return 0; } +static void deltree(const char *dirname) { + DIR *d = opendir(dirname); + + if(d) { + struct dirent *ent; + + while((ent = readdir(d))) { + if(ent->d_name[0] == '.') { + continue; + } + + char filename[PATH_MAX]; + snprintf(filename, sizeof(filename), "%s" SLASH "%s", dirname, ent->d_name); + + if(unlink(filename)) { + deltree(filename); + } + } + + closedir(d); + } + + rmdir(dirname); +} + static bool finalize_join(meshlink_handle_t *mesh) { char *name = xstrdup(get_value(mesh->data, "Name")); @@ -577,6 +584,19 @@ static bool finalize_join(meshlink_handle_t *mesh) { fprintf(f, "Name = %s\n", name); + // Wipe all old host config files and invitations + snprintf(filename, sizeof(filename), "%s" SLASH "hosts", mesh->confbase); + deltree(filename); + + if(mkdir(filename, 0777) && errno != EEXIST) { + logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", filename, strerror(errno)); + return false; + } + + snprintf(filename, sizeof(filename), "%s" SLASH "invitations", mesh->confbase); + deltree(filename); + + // Create a new host config file for ourself snprintf(filename, sizeof(filename), "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name); FILE *fh = fopen(filename, "w"); @@ -619,7 +639,7 @@ static bool finalize_join(meshlink_handle_t *mesh) { continue; } - // Check the list of known variables //TODO: most variables will not be available in meshlink, only name and key will be absolutely necessary + // Check the list of known variables bool found = false; int i; @@ -708,8 +728,10 @@ static bool finalize_join(meshlink_handle_t *mesh) { sptps_send_record(&(mesh->sptps), 1, b64key, strlen(b64key)); free(b64key); + free(mesh->name); free(mesh->self->name); free(mesh->self->connection->name); + mesh->name = xstrdup(name); mesh->self->name = xstrdup(name); mesh->self->connection->name = name; @@ -1026,6 +1048,12 @@ meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const c return NULL; } + if(strchr(appname, ' ')) { + logger(NULL, MESHLINK_ERROR, "Invalid appname given!\n"); + meshlink_errno = MESHLINK_EINVAL; + return NULL; + } + if(!name || !*name) { logger(NULL, MESHLINK_ERROR, "No name given!\n"); //return NULL; @@ -1051,6 +1079,7 @@ meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const c mesh->appname = xstrdup(appname); mesh->devclass = devclass; mesh->discovery = true; + mesh->invitation_timeout = 604800; // 1 week if(usingname) { mesh->name = xstrdup(name); @@ -1179,16 +1208,21 @@ bool meshlink_start(meshlink_handle_t *mesh) { logger(mesh, MESHLINK_DEBUG, "Could not start thread: %s\n", strerror(errno)); memset(&mesh->thread, 0, sizeof(mesh)->thread); meshlink_errno = MESHLINK_EINTERNAL; + event_loop_stop(&mesh->loop); pthread_mutex_unlock(&(mesh->mesh_mutex)); return false; } mesh->threadstarted = true; +#if HAVE_CATTA + if(mesh->discovery) { discovery_start(mesh); } +#endif + pthread_mutex_unlock(&(mesh->mesh_mutex)); return true; } @@ -1202,11 +1236,15 @@ void meshlink_stop(meshlink_handle_t *mesh) { pthread_mutex_lock(&(mesh->mesh_mutex)); logger(mesh, MESHLINK_DEBUG, "meshlink_stop called\n"); +#if HAVE_CATTA + // Stop discovery if(mesh->discovery) { discovery_stop(mesh); } +#endif + // Shut down the main thread event_loop_stop(&mesh->loop); @@ -1225,12 +1263,14 @@ void meshlink_stop(meshlink_handle_t *mesh) { } } - // Wait for the main thread to finish - pthread_mutex_unlock(&(mesh->mesh_mutex)); - pthread_join(mesh->thread, NULL); - pthread_mutex_lock(&(mesh->mesh_mutex)); + if(mesh->threadstarted) { + // Wait for the main thread to finish + pthread_mutex_unlock(&(mesh->mesh_mutex)); + pthread_join(mesh->thread, NULL); + pthread_mutex_lock(&(mesh->mesh_mutex)); - mesh->threadstarted = false; + mesh->threadstarted = false; + } // Close all metaconnections if(mesh->connections) { @@ -1244,10 +1284,9 @@ void meshlink_stop(meshlink_handle_t *mesh) { if(mesh->outgoings) { list_delete_list(mesh->outgoings); + mesh->outgoings = NULL; } - mesh->outgoings = NULL; - pthread_mutex_unlock(&(mesh->mesh_mutex)); } @@ -1292,32 +1331,6 @@ void meshlink_close(meshlink_handle_t *mesh) { free(mesh); } -static void deltree(const char *dirname) { - DIR *d = opendir(dirname); - - if(d) { - struct dirent *ent; - - while((ent = readdir(d))) { - if(ent->d_name[0] == '.') { - continue; - } - - char filename[PATH_MAX]; - snprintf(filename, sizeof(filename), "%s" SLASH "%s", dirname, ent->d_name); - - if(unlink(filename)) { - deltree(filename); - } - } - - closedir(d); - } - - rmdir(dirname); - return; -} - bool meshlink_destroy(const char *confbase) { if(!confbase) { meshlink_errno = MESHLINK_EINVAL; @@ -1365,6 +1378,17 @@ void meshlink_set_node_status_cb(meshlink_handle_t *mesh, meshlink_node_status_c pthread_mutex_unlock(&(mesh->mesh_mutex)); } +void meshlink_set_node_duplicate_cb(meshlink_handle_t *mesh, meshlink_node_duplicate_cb_t cb) { + if(!mesh) { + meshlink_errno = MESHLINK_EINVAL; + return; + } + + pthread_mutex_lock(&(mesh->mesh_mutex)); + mesh->node_duplicate_cb = cb; + pthread_mutex_unlock(&(mesh->mesh_mutex)); +} + void meshlink_set_log_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, meshlink_log_cb_t cb) { if(mesh) { pthread_mutex_lock(&(mesh->mesh_mutex)); @@ -1725,8 +1749,8 @@ static bool refresh_invitation_key(meshlink_handle_t *mesh) { return mesh->invitation_key; } -bool meshlink_add_address(meshlink_handle_t *mesh, const char *address) { - if(!mesh || !address) { +bool meshlink_set_canonical_address(meshlink_handle_t *mesh, meshlink_node_t *node, const char *address, const char *port) { + if(!mesh || !node || !address) { meshlink_errno = MESHLINK_EINVAL; return false; } @@ -1737,15 +1761,32 @@ bool meshlink_add_address(meshlink_handle_t *mesh, const char *address) { return false; } - bool rval = false; + if(port && !is_valid_port(port)) { + logger(mesh, MESHLINK_DEBUG, "Invalid character in port: %s\n", address); + meshlink_errno = MESHLINK_EINVAL; + return false; + } + + char *canonical_address; + + if(port) { + xasprintf(&canonical_address, "%s %s", address, port); + } else { + canonical_address = xstrdup(address); + } pthread_mutex_lock(&(mesh->mesh_mutex)); - rval = append_config_file(mesh, mesh->self->name, "Address", address); + bool rval = modify_config_file(mesh, node->name, "CanonicalAddress", canonical_address, 1); pthread_mutex_unlock(&(mesh->mesh_mutex)); + free(canonical_address); return rval; } +bool meshlink_add_address(meshlink_handle_t *mesh, const char *address) { + return meshlink_set_canonical_address(mesh, (meshlink_node_t *)mesh->self, address, NULL); +} + bool meshlink_add_external_address(meshlink_handle_t *mesh) { if(!mesh) { meshlink_errno = MESHLINK_EINVAL; @@ -1831,6 +1872,10 @@ done: return rval; } +void meshlink_set_invitation_timeout(meshlink_handle_t *mesh, int timeout) { + mesh->invitation_timeout = timeout; +} + char *meshlink_invite(meshlink_handle_t *mesh, const char *name) { if(!mesh) { meshlink_errno = MESHLINK_EINVAL; @@ -1924,8 +1969,6 @@ char *meshlink_invite(meshlink_handle_t *mesh, const char *name) { // Fill in the details. fprintf(f, "Name = %s\n", name); - //if(netname) - // fprintf(f, "NetName = %s\n", netname); fprintf(f, "ConnectTo = %s\n", mesh->self->name); // Copy Broadcast and Mode @@ -2102,7 +2145,7 @@ bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) { mesh->blen = 0; - if(!sendline(mesh->sock, "0 ?%s %d.%d", b64key, PROT_MAJOR, 1)) { + if(!sendline(mesh->sock, "0 ?%s %d.%d %s", b64key, PROT_MAJOR, 1, mesh->appname)) { logger(mesh, MESHLINK_DEBUG, "Error sending request to %s port %s: %s\n", address, port, strerror(errno)); closesocket(mesh->sock); meshlink_errno = MESHLINK_ENETWORK; @@ -2337,8 +2380,14 @@ void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) { //Make blacklisting persistent in the config file append_config_file(mesh, n->name, "blacklisted", "yes"); + //Immediately terminate any connections we have with the blacklisted node + for list_each(connection_t, c, mesh->connections) { + if(c->node == n) { + terminate_connection(mesh, c, c->status.active); + } + } + pthread_mutex_unlock(&(mesh->mesh_mutex)); - return; } void meshlink_whitelist(meshlink_handle_t *mesh, meshlink_node_t *node) { @@ -2450,6 +2499,11 @@ static void channel_accept(struct utcp_connection *utcp_connection, uint16_t por static ssize_t channel_send(struct utcp *utcp, const void *data, size_t len) { node_t *n = utcp->priv; + + if(n->status.destroyed) { + return -1; + } + meshlink_handle_t *mesh = n->mesh; return meshlink_send(mesh, (meshlink_node_t *)n, data, len) ? (ssize_t)len : -1; } @@ -2623,7 +2677,18 @@ void update_node_status(meshlink_handle_t *mesh, node_t *n) { } } +void handle_duplicate_node(meshlink_handle_t *mesh, node_t *n) { + if(!mesh->node_duplicate_cb || n->status.duplicate) { + return; + } + + n->status.duplicate = true; + mesh->node_duplicate_cb(mesh, (meshlink_node_t *)n); +} + void meshlink_enable_discovery(meshlink_handle_t *mesh, bool enable) { +#if HAVE_CATTA + if(!mesh) { meshlink_errno = MESHLINK_EINVAL; return; @@ -2647,6 +2712,11 @@ void meshlink_enable_discovery(meshlink_handle_t *mesh, bool enable) { end: pthread_mutex_unlock(&mesh->mesh_mutex); +#else + (void)mesh; + (void)enable; + meshlink_errno = MESHLINK_ENOTSUP; +#endif } static void __attribute__((constructor)) meshlink_init(void) {