1 /*
2 * Copyright 2013 University of Chicago
3 * Contact: Bryce Allen
4 * Copyright 2013 Collabora Ltd.
5 * Contact: Youness Alaoui
6 *
7 * The contents of this file are subject to the Mozilla Public License Version
8 * 1.1 (the "License"); you may not use this file except in compliance with
9 * the License. You may obtain a copy of the License at
10 * http://www.mozilla.org/MPL/
11 *
12 * Software distributed under the License is distributed on an "AS IS" basis,
13 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
14 * for the specific language governing rights and limitations under the
15 * License.
16 *
17 * Alternatively, the contents of this file may be used under the terms of the
18 * the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
19 * case the provisions of LGPL are applicable instead of those above. If you
20 * wish to allow use of your version of this file only under the terms of the
21 * LGPL and not to allow others to use your version of this file under the
22 * MPL, indicate your decision by deleting the provisions above and replace
23 * them with the notice and other provisions required by the LGPL. If you do
24 * not delete the provisions above, a recipient may use your version of this
25 * file under either the MPL or the LGPL.
26 */
27
28 /*
29 * Example using libnice to negotiate a UDP connection between two clients,
30 * possibly on the same network or behind different NATs and/or stateful
31 * firewalls.
32 *
33 * Build:
34 * gcc -o simple-example simple-example.c `pkg-config --cflags --libs nice`
35 *
36 * Run two clients, one controlling and one controlled:
37 * simple-example 0 $(host -4 -t A stun.stunprotocol.org | awk '{ print $4 }')
38 * simple-example 1 $(host -4 -t A stun.stunprotocol.org | awk '{ print $4 }')
39 */
40 #include <stdlib.h>
41 #include <stdio.h>
42 #include <string.h>
43 #include <ctype.h>
44
45 #include <agent.h>
46
47 #include <gio/gnetworking.h>
48
49 static GMainLoop *gloop;
50 static GIOChannel* io_stdin;
51 static guint stream_id;
52
53 static const gchar *candidate_type_name[] = {"host", "srflx", "prflx", "relay"};
54
55 static const gchar *state_name[] = {"disconnected", "gathering", "connecting",
56 "connected", "ready", "failed"};
57
58 static int print_local_data(NiceAgent *agent, guint stream_id,
59 guint component_id);
60 static int parse_remote_data(NiceAgent *agent, guint stream_id,
61 guint component_id, char *line);
62 static void cb_candidate_gathering_done(NiceAgent *agent, guint stream_id,
63 gpointer data);
64 static void cb_new_selected_pair(NiceAgent *agent, guint stream_id,
65 guint component_id, gchar *lfoundation,
66 gchar *rfoundation, gpointer data);
67 static void cb_component_state_changed(NiceAgent *agent, guint stream_id,
68 guint component_id, guint state,
69 gpointer data);
70 static void cb_nice_recv(NiceAgent *agent, guint stream_id, guint component_id,
71 guint len, gchar *buf, gpointer data);
72 static gboolean stdin_remote_info_cb (GIOChannel *source, GIOCondition cond,
73 gpointer data);
74 static gboolean stdin_send_data_cb (GIOChannel *source, GIOCondition cond,
75 gpointer data);
76
77 int
main(int argc,char * argv[])78 main(int argc, char *argv[])
79 {
80 NiceAgent *agent;
81 gchar *stun_addr = NULL;
82 guint stun_port = 0;
83 gboolean controlling;
84
85 // Parse arguments
86 if (argc > 4 || argc < 2 || argv[1][1] != '\0') {
87 fprintf(stderr, "Usage: %s 0|1 stun_addr [stun_port]\n", argv[0]);
88 return EXIT_FAILURE;
89 }
90 controlling = argv[1][0] - '0';
91 if (controlling != 0 && controlling != 1) {
92 fprintf(stderr, "Usage: %s 0|1 stun_addr [stun_port]\n", argv[0]);
93 return EXIT_FAILURE;
94 }
95
96 if (argc > 2) {
97 stun_addr = argv[2];
98 if (argc > 3)
99 stun_port = atoi(argv[3]);
100 else
101 stun_port = 3478;
102
103 g_debug("Using stun server '[%s]:%u'\n", stun_addr, stun_port);
104 }
105
106 g_networking_init();
107
108 gloop = g_main_loop_new(NULL, FALSE);
109 #ifdef G_OS_WIN32
110 io_stdin = g_io_channel_win32_new_fd(_fileno(stdin));
111 #else
112 io_stdin = g_io_channel_unix_new(fileno(stdin));
113 #endif
114
115 // Create the nice agent
116 agent = nice_agent_new(g_main_loop_get_context (gloop),
117 NICE_COMPATIBILITY_RFC5245);
118 if (agent == NULL)
119 g_error("Failed to create agent");
120
121 // Set the STUN settings and controlling mode
122 if (stun_addr) {
123 g_object_set(agent, "stun-server", stun_addr, NULL);
124 g_object_set(agent, "stun-server-port", stun_port, NULL);
125 }
126 g_object_set(agent, "controlling-mode", controlling, NULL);
127
128 // Connect to the signals
129 g_signal_connect(agent, "candidate-gathering-done",
130 G_CALLBACK(cb_candidate_gathering_done), NULL);
131 g_signal_connect(agent, "new-selected-pair",
132 G_CALLBACK(cb_new_selected_pair), NULL);
133 g_signal_connect(agent, "component-state-changed",
134 G_CALLBACK(cb_component_state_changed), NULL);
135
136 // Create a new stream with one component
137 stream_id = nice_agent_add_stream(agent, 1);
138 if (stream_id == 0)
139 g_error("Failed to add stream");
140
141 // Attach to the component to receive the data
142 // Without this call, candidates cannot be gathered
143 nice_agent_attach_recv(agent, stream_id, 1,
144 g_main_loop_get_context (gloop), cb_nice_recv, NULL);
145
146 // Start gathering local candidates
147 if (!nice_agent_gather_candidates(agent, stream_id))
148 g_error("Failed to start candidate gathering");
149
150 g_debug("waiting for candidate-gathering-done signal...");
151
152 // Run the mainloop. Everything else will happen asynchronously
153 // when the candidates are done gathering.
154 g_main_loop_run (gloop);
155
156 g_main_loop_unref(gloop);
157 g_object_unref(agent);
158 g_io_channel_unref (io_stdin);
159
160 return EXIT_SUCCESS;
161 }
162
163 static void
cb_candidate_gathering_done(NiceAgent * agent,guint _stream_id,gpointer data)164 cb_candidate_gathering_done(NiceAgent *agent, guint _stream_id,
165 gpointer data)
166 {
167
168 g_debug("SIGNAL candidate gathering done\n");
169
170 // Candidate gathering is done. Send our local candidates on stdout
171 printf("Copy this line to remote client:\n");
172 printf("\n ");
173 print_local_data(agent, _stream_id, 1);
174 printf("\n");
175
176 // Listen on stdin for the remote candidate list
177 printf("Enter remote data (single line, no wrapping):\n");
178 g_io_add_watch(io_stdin, G_IO_IN, stdin_remote_info_cb, agent);
179 printf("> ");
180 fflush (stdout);
181 }
182
183 static gboolean
stdin_remote_info_cb(GIOChannel * source,GIOCondition cond,gpointer data)184 stdin_remote_info_cb (GIOChannel *source, GIOCondition cond,
185 gpointer data)
186 {
187 NiceAgent *agent = data;
188 gchar *line = NULL;
189 int rval;
190 gboolean ret = TRUE;
191
192 if (g_io_channel_read_line (source, &line, NULL, NULL, NULL) ==
193 G_IO_STATUS_NORMAL) {
194
195 // Parse remote candidate list and set it on the agent
196 rval = parse_remote_data(agent, stream_id, 1, line);
197 if (rval == EXIT_SUCCESS) {
198 // Return FALSE so we stop listening to stdin since we parsed the
199 // candidates correctly
200 ret = FALSE;
201 g_debug("waiting for state READY or FAILED signal...");
202 } else {
203 fprintf(stderr, "ERROR: failed to parse remote data\n");
204 printf("Enter remote data (single line, no wrapping):\n");
205 printf("> ");
206 fflush (stdout);
207 }
208 g_free (line);
209 }
210
211 return ret;
212 }
213
214 static void
cb_component_state_changed(NiceAgent * agent,guint _stream_id,guint component_id,guint state,gpointer data)215 cb_component_state_changed(NiceAgent *agent, guint _stream_id,
216 guint component_id, guint state,
217 gpointer data)
218 {
219
220 g_debug("SIGNAL: state changed %d %d %s[%d]\n",
221 _stream_id, component_id, state_name[state], state);
222
223 if (state == NICE_COMPONENT_STATE_CONNECTED) {
224 NiceCandidate *local, *remote;
225
226 // Get current selected candidate pair and print IP address used
227 if (nice_agent_get_selected_pair (agent, _stream_id, component_id,
228 &local, &remote)) {
229 gchar ipaddr[INET6_ADDRSTRLEN];
230
231 nice_address_to_string(&local->addr, ipaddr);
232 printf("\nNegotiation complete: ([%s]:%d,",
233 ipaddr, nice_address_get_port(&local->addr));
234 nice_address_to_string(&remote->addr, ipaddr);
235 printf(" [%s]:%d)\n", ipaddr, nice_address_get_port(&remote->addr));
236 }
237
238 // Listen to stdin and send data written to it
239 printf("\nSend lines to remote (Ctrl-D to quit):\n");
240 g_io_add_watch(io_stdin, G_IO_IN, stdin_send_data_cb, agent);
241 printf("> ");
242 fflush (stdout);
243 } else if (state == NICE_COMPONENT_STATE_FAILED) {
244 g_main_loop_quit (gloop);
245 }
246 }
247
248 static gboolean
stdin_send_data_cb(GIOChannel * source,GIOCondition cond,gpointer data)249 stdin_send_data_cb (GIOChannel *source, GIOCondition cond,
250 gpointer data)
251 {
252 NiceAgent *agent = data;
253 gchar *line = NULL;
254
255 if (g_io_channel_read_line (source, &line, NULL, NULL, NULL) ==
256 G_IO_STATUS_NORMAL) {
257 nice_agent_send(agent, stream_id, 1, strlen(line), line);
258 g_free (line);
259 printf("> ");
260 fflush (stdout);
261 } else {
262 nice_agent_send(agent, stream_id, 1, 1, "\0");
263 // Ctrl-D was pressed.
264 g_main_loop_quit (gloop);
265 }
266
267 return TRUE;
268 }
269
270 static void
cb_new_selected_pair(NiceAgent * agent,guint _stream_id,guint component_id,gchar * lfoundation,gchar * rfoundation,gpointer data)271 cb_new_selected_pair(NiceAgent *agent, guint _stream_id,
272 guint component_id, gchar *lfoundation,
273 gchar *rfoundation, gpointer data)
274 {
275 g_debug("SIGNAL: selected pair %s %s", lfoundation, rfoundation);
276 }
277
278 static void
cb_nice_recv(NiceAgent * agent,guint _stream_id,guint component_id,guint len,gchar * buf,gpointer data)279 cb_nice_recv(NiceAgent *agent, guint _stream_id, guint component_id,
280 guint len, gchar *buf, gpointer data)
281 {
282 if (len == 1 && buf[0] == '\0')
283 g_main_loop_quit (gloop);
284 printf("%.*s", len, buf);
285 fflush(stdout);
286 }
287
288 static NiceCandidate *
parse_candidate(char * scand,guint _stream_id)289 parse_candidate(char *scand, guint _stream_id)
290 {
291 NiceCandidate *cand = NULL;
292 NiceCandidateType ntype = NICE_CANDIDATE_TYPE_HOST;
293 gchar **tokens = NULL;
294 guint i;
295
296 tokens = g_strsplit (scand, ",", 5);
297 for (i = 0; tokens[i]; i++);
298 if (i != 5)
299 goto end;
300
301 for (i = 0; i < G_N_ELEMENTS (candidate_type_name); i++) {
302 if (strcmp(tokens[4], candidate_type_name[i]) == 0) {
303 ntype = i;
304 break;
305 }
306 }
307 if (i == G_N_ELEMENTS (candidate_type_name))
308 goto end;
309
310 cand = nice_candidate_new(ntype);
311 cand->component_id = 1;
312 cand->stream_id = _stream_id;
313 cand->transport = NICE_CANDIDATE_TRANSPORT_UDP;
314 strncpy(cand->foundation, tokens[0], NICE_CANDIDATE_MAX_FOUNDATION - 1);
315 cand->foundation[NICE_CANDIDATE_MAX_FOUNDATION - 1] = 0;
316 cand->priority = atoi (tokens[1]);
317
318 if (!nice_address_set_from_string(&cand->addr, tokens[2])) {
319 g_message("failed to parse addr: %s", tokens[2]);
320 nice_candidate_free(cand);
321 cand = NULL;
322 goto end;
323 }
324
325 nice_address_set_port(&cand->addr, atoi (tokens[3]));
326
327 end:
328 g_strfreev(tokens);
329
330 return cand;
331 }
332
333
334 static int
print_local_data(NiceAgent * agent,guint _stream_id,guint component_id)335 print_local_data (NiceAgent *agent, guint _stream_id, guint component_id)
336 {
337 int result = EXIT_FAILURE;
338 gchar *local_ufrag = NULL;
339 gchar *local_password = NULL;
340 gchar ipaddr[INET6_ADDRSTRLEN];
341 GSList *cands = NULL, *item;
342
343 if (!nice_agent_get_local_credentials(agent, _stream_id,
344 &local_ufrag, &local_password))
345 goto end;
346
347 cands = nice_agent_get_local_candidates(agent, _stream_id, component_id);
348 if (cands == NULL)
349 goto end;
350
351 printf("%s %s", local_ufrag, local_password);
352
353 for (item = cands; item; item = item->next) {
354 NiceCandidate *c = (NiceCandidate *)item->data;
355
356 nice_address_to_string(&c->addr, ipaddr);
357
358 // (foundation),(prio),(addr),(port),(type)
359 printf(" %s,%u,%s,%u,%s",
360 c->foundation,
361 c->priority,
362 ipaddr,
363 nice_address_get_port(&c->addr),
364 candidate_type_name[c->type]);
365 }
366 printf("\n");
367 result = EXIT_SUCCESS;
368
369 end:
370 if (local_ufrag)
371 g_free(local_ufrag);
372 if (local_password)
373 g_free(local_password);
374 if (cands)
375 g_slist_free_full(cands, (GDestroyNotify)&nice_candidate_free);
376
377 return result;
378 }
379
380
381 static int
parse_remote_data(NiceAgent * agent,guint _stream_id,guint component_id,char * line)382 parse_remote_data(NiceAgent *agent, guint _stream_id,
383 guint component_id, char *line)
384 {
385 GSList *remote_candidates = NULL;
386 gchar **line_argv = NULL;
387 const gchar *ufrag = NULL;
388 const gchar *passwd = NULL;
389 int result = EXIT_FAILURE;
390 int i;
391
392 line_argv = g_strsplit_set (line, " \t\n", 0);
393 for (i = 0; line_argv && line_argv[i]; i++) {
394 if (strlen (line_argv[i]) == 0)
395 continue;
396
397 // first two args are remote ufrag and password
398 if (!ufrag) {
399 ufrag = line_argv[i];
400 } else if (!passwd) {
401 passwd = line_argv[i];
402 } else {
403 // Remaining args are serialized canidates (at least one is required)
404 NiceCandidate *c = parse_candidate(line_argv[i], _stream_id);
405
406 if (c == NULL) {
407 g_message("failed to parse candidate: %s", line_argv[i]);
408 goto end;
409 }
410 remote_candidates = g_slist_prepend(remote_candidates, c);
411 }
412 }
413 if (ufrag == NULL || passwd == NULL || remote_candidates == NULL) {
414 g_message("line must have at least ufrag, password, and one candidate");
415 goto end;
416 }
417
418 if (!nice_agent_set_remote_credentials(agent, _stream_id, ufrag, passwd)) {
419 g_message("failed to set remote credentials");
420 goto end;
421 }
422
423 // Note: this will trigger the start of negotiation.
424 if (nice_agent_set_remote_candidates(agent, _stream_id, component_id,
425 remote_candidates) < 1) {
426 g_message("failed to set remote candidates");
427 goto end;
428 }
429
430 result = EXIT_SUCCESS;
431
432 end:
433 if (line_argv != NULL)
434 g_strfreev(line_argv);
435 if (remote_candidates != NULL)
436 g_slist_free_full(remote_candidates, (GDestroyNotify)&nice_candidate_free);
437
438 return result;
439 }
440