]> git.meshlink.io Git - meshlink/blob - examples/channels.c
Handle meshlink_channel_close() being called in callbacks.
[meshlink] / examples / channels.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <strings.h>
5 #include "../src/meshlink.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, "invite")) {
92                 char *invitation;
93
94                 if(!arg) {
95                         fprintf(stderr, "/invite requires an argument!\n");
96                         return;
97                 }
98
99                 invitation = meshlink_invite(mesh, NULL, arg);
100
101                 if(!invitation) {
102                         fprintf(stderr, "Could not invite '%s': %s\n", arg, meshlink_strerror(meshlink_errno));
103                         return;
104                 }
105
106                 printf("Invitation for %s: %s\n", arg, invitation);
107                 free(invitation);
108         } else if(!strcasecmp(buf, "join")) {
109                 if(!arg) {
110                         fprintf(stderr, "/join requires an argument!\n");
111                         return;
112                 }
113
114                 meshlink_stop(mesh);
115
116                 if(!meshlink_join(mesh, arg)) {
117                         fprintf(stderr, "Could not join using invitation: %s\n", meshlink_strerror(meshlink_errno));
118                 } else {
119                         fprintf(stderr, "Invitation accepted!\n");
120                 }
121
122                 if(!meshlink_start(mesh)) {
123                         fprintf(stderr, "Could not restart MeshLink: %s\n", meshlink_strerror(meshlink_errno));
124                         exit(1);
125                 }
126         } else if(!strcasecmp(buf, "kick")) {
127                 if(!arg) {
128                         fprintf(stderr, "/kick requires an argument!\n");
129                         return;
130                 }
131
132                 meshlink_node_t *node = meshlink_get_node(mesh, arg);
133
134                 if(!node) {
135                         fprintf(stderr, "Error looking up '%s': %s\n", arg, meshlink_strerror(meshlink_errno));
136                         return;
137                 }
138
139                 if(!meshlink_blacklist(mesh, node)) {
140                         fprintf(stderr, "Error blacklising '%s': %s", arg, meshlink_strerror(meshlink_errno));
141                         return;
142                 }
143
144                 printf("Node '%s' blacklisted.\n", arg);
145         } else if(!strcasecmp(buf, "whitelist")) {
146                 if(!arg) {
147                         fprintf(stderr, "/whitelist requires an argument!\n");
148                         return;
149                 }
150
151                 meshlink_node_t *node = meshlink_get_node(mesh, arg);
152
153                 if(!node) {
154                         fprintf(stderr, "Error looking up '%s': %s\n", arg, meshlink_strerror(meshlink_errno));
155                         return;
156                 }
157
158                 if(!meshlink_whitelist(mesh, node)) {
159                         fprintf(stderr, "Error whitelising '%s': %s", arg, meshlink_strerror(meshlink_errno));
160                         return;
161                 }
162
163                 printf("Node '%s' whitelisted.\n", arg);
164         } else if(!strcasecmp(buf, "who")) {
165                 if(!arg) {
166                         nodes = meshlink_get_all_nodes(mesh, nodes, &nnodes);
167
168                         if(!nnodes) {
169                                 fprintf(stderr, "Could not get list of nodes: %s\n", meshlink_strerror(meshlink_errno));
170                         } else {
171                                 printf("%zu known nodes:", nnodes);
172
173                                 for(size_t i = 0; i < nnodes; i++) {
174                                         printf(" %s", nodes[i]->name);
175                                 }
176
177                                 printf("\n");
178                         }
179                 } else {
180                         meshlink_node_t *node = meshlink_get_node(mesh, arg);
181
182                         if(!node) {
183                                 fprintf(stderr, "Error looking up '%s': %s\n", arg, meshlink_strerror(meshlink_errno));
184                         } else {
185                                 printf("Node %s found\n", arg);
186                         }
187                 }
188         } else if(!strcasecmp(buf, "quit")) {
189                 printf("Bye!\n");
190                 fclose(stdin);
191         } else if(!strcasecmp(buf, "help")) {
192                 printf(
193                         "<name>: <message>     Send a message to the given node.\n"
194                         "                      Subsequent messages don't need the <name>: prefix.\n"
195                         "/invite <name>        Create an invitation for a new node.\n"
196                         "/join <invitation>    Join an existing mesh using an invitation.\n"
197                         "/kick <name>          Blacklist the given node.\n"
198                         "/who [<name>]         List all nodes or show information about the given node.\n"
199                         "/quit                 Exit this program.\n"
200                 );
201         } else {
202                 fprintf(stderr, "Unknown command '/%s'\n", buf);
203         }
204 }
205
206 static void parse_input(meshlink_handle_t *mesh, char *buf) {
207         static meshlink_node_t *destination;
208         size_t len;
209
210         if(!buf) {
211                 return;
212         }
213
214         // Remove newline.
215
216         len = strlen(buf);
217
218         if(len && buf[len - 1] == '\n') {
219                 buf[--len] = 0;
220         }
221
222         if(len && buf[len - 1] == '\r') {
223                 buf[--len] = 0;
224         }
225
226         // Ignore empty lines.
227
228         if(!len) {
229                 return;
230         }
231
232         // Commands start with '/'
233
234         if(*buf == '/') {
235                 parse_command(mesh, buf + 1);
236                 return;
237         }
238
239         // Lines in the form "name: message..." set the destination node.
240
241         char *msg = buf;
242         char *colon = strchr(buf, ':');
243
244         if(colon) {
245                 *colon = 0;
246                 msg = colon + 1;
247
248                 if(*msg == ' ') {
249                         msg++;
250                 }
251
252                 destination = meshlink_get_node(mesh, buf);
253
254                 if(!destination) {
255                         fprintf(stderr, "Error looking up '%s': %s\n", buf, meshlink_strerror(meshlink_errno));
256                         return;
257                 }
258         }
259
260         if(!destination) {
261                 fprintf(stderr, "Who are you talking to? Write 'name: message...'\n");
262                 return;
263         }
264
265         // We want to have one channel per node.
266         // We keep the pointer to the meshlink_channel_t in the priv field of that node.
267         meshlink_channel_t *channel = destination->priv;
268
269         if(!channel) {
270                 fprintf(stderr, "Opening chat channel to '%s'\n", destination->name);
271                 channel = meshlink_channel_open(mesh, destination, CHAT_PORT, channel_receive, NULL, 0);
272
273                 if(!channel) {
274                         fprintf(stderr, "Could not create channel to '%s': %s\n", destination->name, meshlink_strerror(meshlink_errno));
275                         return;
276                 }
277
278                 destination->priv = channel;
279                 meshlink_set_channel_poll_cb(mesh, channel, channel_poll);
280         }
281
282         if(!meshlink_channel_send(mesh, channel, msg, strlen(msg))) {
283                 fprintf(stderr, "Could not send message to '%s': %s\n", destination->name, meshlink_strerror(meshlink_errno));
284                 return;
285         }
286
287         printf("Message sent to '%s'.\n", destination->name);
288 }
289
290 int main(int argc, char *argv[]) {
291         const char *confbase = ".chat";
292         const char *nick = NULL;
293         char buf[1024];
294
295         if(argc > 1) {
296                 confbase = argv[1];
297         }
298
299         if(argc > 2) {
300                 nick = argv[2];
301         }
302
303         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_message);
304
305         meshlink_handle_t *mesh = meshlink_open(confbase, nick, "chat", DEV_CLASS_STATIONARY);
306
307         if(!mesh) {
308                 fprintf(stderr, "Could not open MeshLink: %s\n", meshlink_strerror(meshlink_errno));
309                 return 1;
310         }
311
312         meshlink_set_node_status_cb(mesh, node_status);
313         meshlink_set_log_cb(mesh, MESHLINK_INFO, log_message);
314
315         // Set the channel accept callback. This implicitly turns on channels for all nodes.
316         // This replaces the call to meshlink_set_receive_cb().
317         meshlink_set_channel_accept_cb(mesh, channel_accept);
318
319         if(!meshlink_start(mesh)) {
320                 fprintf(stderr, "Could not start MeshLink: %s\n", meshlink_strerror(meshlink_errno));
321                 return 1;
322         }
323
324         printf("Chat started.\nType /help for a list of commands.\n");
325
326         while(fgets(buf, sizeof(buf), stdin)) {
327                 parse_input(mesh, buf);
328         }
329
330         printf("Chat stopping.\n");
331
332         meshlink_stop(mesh);
333         meshlink_close(mesh);
334
335         return 0;
336 }