]> git.meshlink.io Git - meshlink-tiny/blob - examples/channels.c
e067ba007a413768ae186be92d3f54a9a893e744
[meshlink-tiny] / examples / channels.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <strings.h>
5 #include "../src/meshlink-tiny.h"
6
7 #define CHAT_PORT 531
8
9 static void log_message(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text) {
10         (void) mesh;
11
12         static const char *levelstr[] = {
13                 [MESHLINK_DEBUG] = "\x1b[34mDEBUG",
14                 [MESHLINK_INFO] = "\x1b[32mINFO",
15                 [MESHLINK_WARNING] = "\x1b[33mWARNING",
16                 [MESHLINK_ERROR] = "\x1b[31mERROR",
17                 [MESHLINK_CRITICAL] = "\x1b[31mCRITICAL",
18         };
19         fprintf(stderr, "%s:\x1b[0m %s\n", levelstr[level], text);
20 }
21
22 static void channel_receive(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
23         if(!len) {
24                 if(meshlink_errno) {
25                         fprintf(stderr, "Error while reading data from %s: %s\n", channel->node->name, meshlink_strerror(meshlink_errno));
26                 } else {
27                         fprintf(stderr, "Chat connection closed by %s\n", channel->node->name);
28                 }
29
30                 channel->node->priv = NULL;
31                 meshlink_channel_close(mesh, channel);
32                 return;
33         }
34
35         // TODO: we now have TCP semantics, don't expect exactly one message per receive call.
36
37         printf("%s says: ", channel->node->name);
38         fwrite(data, len, 1, stdout);
39         fputc('\n', stdout);
40 }
41
42 static bool channel_accept(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
43         (void)data;
44         (void)len;
45
46         // Only accept connections to the chat port
47         if(port != CHAT_PORT) {
48                 fprintf(stderr, "Rejected incoming channel from '%s' to port %u\n", channel->node->name, port);
49                 return false;
50         }
51
52         fprintf(stderr, "Accepted incoming channel from '%s'\n", channel->node->name);
53
54         // Remember the channel
55         channel->node->priv = channel;
56
57         // Set the receive callback
58         meshlink_set_channel_receive_cb(mesh, channel, channel_receive);
59
60         // Accept this channel
61         return true;
62 }
63
64 static void channel_poll(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t len) {
65         (void)len;
66
67         fprintf(stderr, "Channel to '%s' connected\n", channel->node->name);
68         meshlink_set_channel_poll_cb(mesh, channel, NULL);
69 }
70
71 static void node_status(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) {
72         (void)mesh;
73
74         if(reachable) {
75                 printf("%s joined.\n", node->name);
76         } else {
77                 printf("%s left.\n", node->name);
78         }
79 }
80
81 static meshlink_node_t **nodes;
82 static size_t nnodes;
83
84 static void parse_command(meshlink_handle_t *mesh, char *buf) {
85         char *arg = strchr(buf, ' ');
86
87         if(arg) {
88                 *arg++ = 0;
89         }
90
91         if(!strcasecmp(buf, "join")) {
92                 if(!arg) {
93                         fprintf(stderr, "/join requires an argument!\n");
94                         return;
95                 }
96
97                 meshlink_stop(mesh);
98
99                 if(!meshlink_join(mesh, arg)) {
100                         fprintf(stderr, "Could not join using invitation: %s\n", meshlink_strerror(meshlink_errno));
101                 } else {
102                         fprintf(stderr, "Invitation accepted!\n");
103                 }
104
105                 if(!meshlink_start(mesh)) {
106                         fprintf(stderr, "Could not restart MeshLink: %s\n", meshlink_strerror(meshlink_errno));
107                         exit(1);
108                 }
109         } else if(!strcasecmp(buf, "who")) {
110                 if(!arg) {
111                         nodes = meshlink_get_all_nodes(mesh, nodes, &nnodes);
112
113                         if(!nnodes) {
114                                 fprintf(stderr, "Could not get list of nodes: %s\n", meshlink_strerror(meshlink_errno));
115                         } else {
116                                 printf("%zu known nodes:", nnodes);
117
118                                 for(size_t i = 0; i < nnodes; i++) {
119                                         printf(" %s", nodes[i]->name);
120                                 }
121
122                                 printf("\n");
123                         }
124                 } else {
125                         meshlink_node_t *node = meshlink_get_node(mesh, arg);
126
127                         if(!node) {
128                                 fprintf(stderr, "Error looking up '%s': %s\n", arg, meshlink_strerror(meshlink_errno));
129                         } else {
130                                 printf("Node %s found\n", arg);
131                         }
132                 }
133         } else if(!strcasecmp(buf, "quit")) {
134                 printf("Bye!\n");
135                 fclose(stdin);
136         } else if(!strcasecmp(buf, "help")) {
137                 printf(
138                         "<name>: <message>     Send a message to the given node.\n"
139                         "                      Subsequent messages don't need the <name>: prefix.\n"
140                         "/join <invitation>    Join an existing mesh using an invitation.\n"
141                         "/kick <name>          Blacklist the given node.\n"
142                         "/who [<name>]         List all nodes or show information about the given node.\n"
143                         "/quit                 Exit this program.\n"
144                 );
145         } else {
146                 fprintf(stderr, "Unknown command '/%s'\n", buf);
147         }
148 }
149
150 static void parse_input(meshlink_handle_t *mesh, char *buf) {
151         static meshlink_node_t *destination;
152         size_t len;
153
154         if(!buf) {
155                 return;
156         }
157
158         // Remove newline.
159
160         len = strlen(buf);
161
162         if(len && buf[len - 1] == '\n') {
163                 buf[--len] = 0;
164         }
165
166         if(len && buf[len - 1] == '\r') {
167                 buf[--len] = 0;
168         }
169
170         // Ignore empty lines.
171
172         if(!len) {
173                 return;
174         }
175
176         // Commands start with '/'
177
178         if(*buf == '/') {
179                 parse_command(mesh, buf + 1);
180                 return;
181         }
182
183         // Lines in the form "name: message..." set the destination node.
184
185         char *msg = buf;
186         char *colon = strchr(buf, ':');
187
188         if(colon) {
189                 *colon = 0;
190                 msg = colon + 1;
191
192                 if(*msg == ' ') {
193                         msg++;
194                 }
195
196                 destination = meshlink_get_node(mesh, buf);
197
198                 if(!destination) {
199                         fprintf(stderr, "Error looking up '%s': %s\n", buf, meshlink_strerror(meshlink_errno));
200                         return;
201                 }
202         }
203
204         if(!destination) {
205                 fprintf(stderr, "Who are you talking to? Write 'name: message...'\n");
206                 return;
207         }
208
209         // We want to have one channel per node.
210         // We keep the pointer to the meshlink_channel_t in the priv field of that node.
211         meshlink_channel_t *channel = destination->priv;
212
213         if(!channel) {
214                 fprintf(stderr, "Opening chat channel to '%s'\n", destination->name);
215                 channel = meshlink_channel_open(mesh, destination, CHAT_PORT, channel_receive, NULL, 0);
216
217                 if(!channel) {
218                         fprintf(stderr, "Could not create channel to '%s': %s\n", destination->name, meshlink_strerror(meshlink_errno));
219                         return;
220                 }
221
222                 destination->priv = channel;
223                 meshlink_set_channel_poll_cb(mesh, channel, channel_poll);
224         }
225
226         if(!meshlink_channel_send(mesh, channel, msg, strlen(msg))) {
227                 fprintf(stderr, "Could not send message to '%s': %s\n", destination->name, meshlink_strerror(meshlink_errno));
228                 return;
229         }
230
231         printf("Message sent to '%s'.\n", destination->name);
232 }
233
234 int main(int argc, char *argv[]) {
235         const char *confbase = ".chat";
236         const char *nick = NULL;
237         char buf[1024];
238
239         if(argc > 1) {
240                 confbase = argv[1];
241         }
242
243         if(argc > 2) {
244                 nick = argv[2];
245         }
246
247         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_message);
248
249         meshlink_handle_t *mesh = meshlink_open(confbase, nick, "chat", DEV_CLASS_STATIONARY);
250
251         if(!mesh) {
252                 fprintf(stderr, "Could not open MeshLink: %s\n", meshlink_strerror(meshlink_errno));
253                 return 1;
254         }
255
256         meshlink_set_node_status_cb(mesh, node_status);
257         meshlink_set_log_cb(mesh, MESHLINK_INFO, log_message);
258
259         // Set the channel accept callback. This implicitly turns on channels for all nodes.
260         // This replaces the call to meshlink_set_receive_cb().
261         meshlink_set_channel_accept_cb(mesh, channel_accept);
262
263         if(!meshlink_start(mesh)) {
264                 fprintf(stderr, "Could not start MeshLink: %s\n", meshlink_strerror(meshlink_errno));
265                 return 1;
266         }
267
268         printf("Chat started.\nType /help for a list of commands.\n");
269
270         while(fgets(buf, sizeof(buf), stdin)) {
271                 parse_input(mesh, buf);
272         }
273
274         printf("Chat stopping.\n");
275
276         meshlink_stop(mesh);
277         meshlink_close(mesh);
278
279         return 0;
280 }