git.meshlink.io Git - meshlink/blob - src/meshlink.c

   1 /*
   2     meshlink.c -- Implementation of the MeshLink API.
   3     Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "system.h"
  21
  22 #include "meshlink_internal.h"
  23 #include "protocol.h"
  24 #include "xalloc.h"
  25
  26 static const char *errstr[] = {
  27         [MESHLINK_OK] = "No error",
  28         [MESHLINK_ENOMEM] = "Out of memory",
  29         [MESHLINK_ENOENT] = "No such node",
  30 };
  31
  32 const char *meshlink_strerror(meshlink_errno_t errno) {
  33         return errstr[errno];
  34 }
  35
  36 static meshlink_handle_t *meshlink_setup(meshlink_handle_t *mesh) {
  37         return mesh;
  38 }
  39
  40 meshlink_handle_t *meshlink_open(const char *confbase, const char *name) {
  41         if(!confbase || !*confbase) {
  42                 fprintf(stderr, "No confbase given!\n");
  43                 return NULL;
  44         }
  45
  46         if(!name || !*name) {
  47                 fprintf(stderr, "No name given!\n");
  48                 return NULL;
  49         }
  50
  51         if(!check_id(name)) {
  52                 fprintf(stderr, "Invalid name given!\n");
  53                 return NULL;
  54         }
  55
  56         meshlink_handle_t *mesh = xzalloc(sizeof *mesh);
  57         mesh->confbase = xstrdup(confbase);
  58         mesh->name = xstrdup(name);
  59
  60         char filename[PATH_MAX];
  61         snprintf(filename, sizeof filename, "%s" SLASH "meshlink.conf", confbase);
  62
  63         FILE *f = fopen(filename, "r");
  64
  65         if(!f && errno == ENOENT)
  66                 return meshlink_setup(mesh);
  67
  68         if(!f) {
  69                 fprintf(stderr, "Could not open %s: %s\n", filename, strerror(errno));
  70                 return meshlink_close(mesh), NULL;
  71         }
  72
  73         char buf[1024] = "";
  74         if(!fgets(buf, sizeof buf, f)) {
  75                 fprintf(stderr, "Could not read line from %s: %s\n", filename, strerror(errno));
  76                 fclose(f);
  77                 return meshlink_close(mesh), NULL;
  78         }
  79
  80         fclose(f);
  81
  82         size_t len = strlen(buf);
  83         if(len && buf[len - 1] == '\n')
  84                 buf[--len] = 0;
  85         if(len && buf[len - 1] == '\r')
  86                 buf[--len] = 0;
  87
  88         if(strncmp(buf, "Name = ", 7) || !check_id(buf + 7)) {
  89                 fprintf(stderr, "Could not read Name from %s\n", filename);
  90                 return meshlink_close(mesh), NULL;
  91         }
  92
  93         if(strcmp(buf + 7, name)) {
  94                 fprintf(stderr, "Name in %s is %s, not the same as %s\n", filename, buf + 7, name);
  95                 free(mesh->name);
  96                 mesh->name = xstrdup(buf + 7);
  97         }
  98
  99         snprintf(filename, sizeof filename, "%s" SLASH "ed25519_key.priv", mesh->confbase);
 100         f = fopen(filename, "r");
 101         if(!f) {
 102                 fprintf(stderr, "Could not open %s: %s\n", filename, strerror(errno));
 103                 return meshlink_close(mesh), NULL;
 104         }
 105
 106         mesh->self->ecdsa = ecdsa_read_pem_private_key(f);
 107         fclose(f);
 108
 109         if(!mesh->self->ecdsa) {
 110                 fprintf(stderr, "Could not read keypair!\n");
 111                 return meshlink_close(mesh), NULL;
 112         }
 113
 114         return mesh;
 115 }
 116
 117 bool meshlink_start(meshlink_handle_t *mesh) {
 118         return false;
 119 }
 120
 121 void meshlink_stop(meshlink_handle_t *mesh) {
 122 }
 123
 124 void meshlink_close(meshlink_handle_t *mesh) {
 125 }
 126
 127 void meshlink_set_receive_cb(meshlink_handle_t *mesh, meshlink_receive_cb_t cb) {
 128         mesh->receive_cb = cb;
 129 }
 130
 131 void meshlink_set_node_status_cb(meshlink_handle_t *mesh, meshlink_node_status_cb_t cb) {
 132         mesh->node_status_cb = cb;
 133 }
 134
 135 void meshlink_set_log_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, meshlink_log_cb_t cb) {
 136         mesh->log_cb = cb;
 137         mesh->log_level = level;
 138 }
 139
 140 bool meshlink_send(meshlink_handle_t *mesh, meshlink_node_t *destination, const void *data, unsigned int len) {
 141         return false;
 142 }
 143
 144 meshlink_node_t *meshlink_get_node(meshlink_handle_t *mesh, const char *name) {
 145         return NULL;
 146 }
 147
 148 size_t meshlink_get_all_nodes(meshlink_handle_t *mesh, meshlink_node_t **nodes, size_t nmemb) {
 149         return 0;
 150 }
 151
 152 char *meshlink_sign(meshlink_handle_t *mesh, const char *data, size_t len) {
 153         return NULL;
 154 }
 155
 156 bool meshlink_verify(meshlink_handle_t *mesh, meshlink_node_t *source, const char *data, size_t len, const char *signature) {
 157         return false;
 158 }
 159
 160 char *meshlink_invite(meshlink_handle_t *mesh, const char *name) {
 161         return NULL;
 162 }
 163
 164 bool meshlink_join(meshlink_handle_t *mesh, const char *invitation) {
 165         return false;
 166 }
 167
 168 char *meshlink_export(meshlink_handle_t *mesh) {
 169         return NULL;
 170 }
 171
 172 bool meshlink_import(meshlink_handle_t *mesh, const char *data) {
 173         return false;
 174 }
 175
 176 void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) {
 177 }
 178