]> git.meshlink.io Git - meshlink-tiny/blob - examples/channels.c
d3df2d948b404165d8f917d82ad03dbfab30fac6
[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 node_status(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) {
65         (void)mesh;
66
67         if(reachable) {
68                 printf("%s joined.\n", node->name);
69         } else {
70                 printf("%s left.\n", node->name);
71         }
72 }
73
74 static void parse_command(meshlink_handle_t *mesh, char *buf) {
75         char *arg = strchr(buf, ' ');
76
77         if(arg) {
78                 *arg++ = 0;
79         }
80
81         if(!strcasecmp(buf, "join")) {
82                 if(!arg) {
83                         fprintf(stderr, "/join requires an argument!\n");
84                         return;
85                 }
86
87                 meshlink_stop(mesh);
88
89                 if(!meshlink_join(mesh, arg)) {
90                         fprintf(stderr, "Could not join using invitation: %s\n", meshlink_strerror(meshlink_errno));
91                 } else {
92                         fprintf(stderr, "Invitation accepted!\n");
93                 }
94
95                 if(!meshlink_start(mesh)) {
96                         fprintf(stderr, "Could not restart MeshLink: %s\n", meshlink_strerror(meshlink_errno));
97                         exit(1);
98                 }
99         } else if(!strcasecmp(buf, "quit")) {
100                 printf("Bye!\n");
101                 fclose(stdin);
102         } else if(!strcasecmp(buf, "help")) {
103                 printf(
104                         "<name>: <message>     Send a message to the given node.\n"
105                         "                      Subsequent messages don't need the <name>: prefix.\n"
106                         "/join <invitation>    Join an existing mesh using an invitation.\n"
107                         "/kick <name>          Blacklist the given node.\n"
108                         "/who [<name>]         List all nodes or show information about the given node.\n"
109                         "/quit                 Exit this program.\n"
110                 );
111         } else {
112                 fprintf(stderr, "Unknown command '/%s'\n", buf);
113         }
114 }
115
116 static void parse_input(meshlink_handle_t *mesh, char *buf) {
117         static meshlink_node_t *destination;
118         size_t len;
119
120         if(!buf) {
121                 return;
122         }
123
124         // Remove newline.
125
126         len = strlen(buf);
127
128         if(len && buf[len - 1] == '\n') {
129                 buf[--len] = 0;
130         }
131
132         if(len && buf[len - 1] == '\r') {
133                 buf[--len] = 0;
134         }
135
136         // Ignore empty lines.
137
138         if(!len) {
139                 return;
140         }
141
142         // Commands start with '/'
143
144         if(*buf == '/') {
145                 parse_command(mesh, buf + 1);
146                 return;
147         }
148
149         // Lines in the form "name: message..." set the destination node.
150
151         char *msg = buf;
152         char *colon = strchr(buf, ':');
153
154         if(colon) {
155                 *colon = 0;
156                 msg = colon + 1;
157
158                 if(*msg == ' ') {
159                         msg++;
160                 }
161
162                 destination = meshlink_get_node(mesh, buf);
163
164                 if(!destination) {
165                         fprintf(stderr, "Error looking up '%s': %s\n", buf, meshlink_strerror(meshlink_errno));
166                         return;
167                 }
168         }
169
170         if(!destination) {
171                 fprintf(stderr, "Who are you talking to? Write 'name: message...'\n");
172                 return;
173         }
174
175         // We want to have one channel per node.
176         // We keep the pointer to the meshlink_channel_t in the priv field of that node.
177         meshlink_channel_t *channel = destination->priv;
178
179         if(!channel) {
180                 fprintf(stderr, "Opening chat channel to '%s'\n", destination->name);
181                 channel = meshlink_channel_open_ex(mesh, destination, CHAT_PORT, channel_receive, NULL, 0, MESHLINK_CHANNEL_UDP);
182
183                 if(!channel) {
184                         fprintf(stderr, "Could not create channel to '%s': %s\n", destination->name, meshlink_strerror(meshlink_errno));
185                         return;
186                 }
187
188                 destination->priv = channel;
189         }
190
191         if(!meshlink_channel_send(mesh, channel, msg, strlen(msg))) {
192                 fprintf(stderr, "Could not send message to '%s': %s\n", destination->name, meshlink_strerror(meshlink_errno));
193                 return;
194         }
195
196         printf("Message sent to '%s'.\n", destination->name);
197 }
198
199 int main(int argc, char *argv[]) {
200         const char *confbase = ".chat";
201         const char *nick = NULL;
202         char buf[1024];
203
204         if(argc > 1) {
205                 confbase = argv[1];
206         }
207
208         if(argc > 2) {
209                 nick = argv[2];
210         }
211
212         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_message);
213
214         meshlink_handle_t *mesh = meshlink_open(confbase, nick, "chat", DEV_CLASS_STATIONARY);
215
216         if(!mesh) {
217                 fprintf(stderr, "Could not open MeshLink: %s\n", meshlink_strerror(meshlink_errno));
218                 return 1;
219         }
220
221         meshlink_set_node_status_cb(mesh, node_status);
222         meshlink_set_log_cb(mesh, MESHLINK_INFO, log_message);
223
224         // Set the channel accept callback. This implicitly turns on channels for all nodes.
225         // This replaces the call to meshlink_set_receive_cb().
226         meshlink_set_channel_accept_cb(mesh, channel_accept);
227
228         if(!meshlink_start(mesh)) {
229                 fprintf(stderr, "Could not start MeshLink: %s\n", meshlink_strerror(meshlink_errno));
230                 return 1;
231         }
232
233         printf("Chat started.\nType /help for a list of commands.\n");
234
235         while(fgets(buf, sizeof(buf), stdin)) {
236                 parse_input(mesh, buf);
237         }
238
239         printf("Chat stopping.\n");
240
241         meshlink_stop(mesh);
242         meshlink_close(mesh);
243
244         return 0;
245 }