Fix the actual place that was pointed out, for previous commit.
[asterisk/asterisk.git] / main / stun.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2008, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  *
22  * \brief STUN Support
23  *
24  * \author Mark Spencer <markster@digium.com>
25  *
26  * \note STUN is defined in RFC 3489.
27  */
28
29 #include "asterisk.h"
30
31 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
32
33 #include "asterisk/_private.h"
34 #include "asterisk/stun.h"
35 #include "asterisk/cli.h"
36 #include "asterisk/utils.h"
37 #include "asterisk/channel.h"
38
39 static int stundebug;                   /*!< Are we debugging stun? */
40
41 /*!
42  * \brief STUN support code
43  *
44  * This code provides some support for doing STUN transactions.
45  * Eventually it should be moved elsewhere as other protocols
46  * than RTP can benefit from it - e.g. SIP.
47  * STUN is described in RFC3489 and it is based on the exchange
48  * of UDP packets between a client and one or more servers to
49  * determine the externally visible address (and port) of the client
50  * once it has gone through the NAT boxes that connect it to the
51  * outside.
52  * The simplest request packet is just the header defined in
53  * struct stun_header, and from the response we may just look at
54  * one attribute, STUN_MAPPED_ADDRESS, that we find in the response.
55  * By doing more transactions with different server addresses we
56  * may determine more about the behaviour of the NAT boxes, of
57  * course - the details are in the RFC.
58  *
59  * All STUN packets start with a simple header made of a type,
60  * length (excluding the header) and a 16-byte random transaction id.
61  * Following the header we may have zero or more attributes, each
62  * structured as a type, length and a value (whose format depends
63  * on the type, but often contains addresses).
64  * Of course all fields are in network format.
65  */
66
67 typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;
68
69 struct stun_header {
70         unsigned short msgtype;
71         unsigned short msglen;
72         stun_trans_id  id;
73         unsigned char ies[0];
74 } __attribute__((packed));
75
76 struct stun_attr {
77         unsigned short attr;
78         unsigned short len;
79         unsigned char value[0];
80 } __attribute__((packed));
81
82 /*
83  * The format normally used for addresses carried by STUN messages.
84  */
85 struct stun_addr {
86         unsigned char unused;
87         unsigned char family;
88         unsigned short port;
89         unsigned int addr;
90 } __attribute__((packed));
91
92 /*! \brief STUN message types
93  * 'BIND' refers to transactions used to determine the externally
94  * visible addresses. 'SEC' refers to transactions used to establish
95  * a session key for subsequent requests.
96  * 'SEC' functionality is not supported here.
97  */
98
99 #define STUN_BINDREQ    0x0001
100 #define STUN_BINDRESP   0x0101
101 #define STUN_BINDERR    0x0111
102 #define STUN_SECREQ     0x0002
103 #define STUN_SECRESP    0x0102
104 #define STUN_SECERR     0x0112
105
106 /*! \brief Basic attribute types in stun messages.
107  * Messages can also contain custom attributes (codes above 0x7fff)
108  */
109 #define STUN_MAPPED_ADDRESS     0x0001
110 #define STUN_RESPONSE_ADDRESS   0x0002
111 #define STUN_CHANGE_REQUEST     0x0003
112 #define STUN_SOURCE_ADDRESS     0x0004
113 #define STUN_CHANGED_ADDRESS    0x0005
114 #define STUN_USERNAME           0x0006
115 #define STUN_PASSWORD           0x0007
116 #define STUN_MESSAGE_INTEGRITY  0x0008
117 #define STUN_ERROR_CODE         0x0009
118 #define STUN_UNKNOWN_ATTRIBUTES 0x000a
119 #define STUN_REFLECTED_FROM     0x000b
120
121 /*! \brief helper function to print message names */
122 static const char *stun_msg2str(int msg)
123 {
124         switch (msg) {
125         case STUN_BINDREQ:
126                 return "Binding Request";
127         case STUN_BINDRESP:
128                 return "Binding Response";
129         case STUN_BINDERR:
130                 return "Binding Error Response";
131         case STUN_SECREQ:
132                 return "Shared Secret Request";
133         case STUN_SECRESP:
134                 return "Shared Secret Response";
135         case STUN_SECERR:
136                 return "Shared Secret Error Response";
137         }
138         return "Non-RFC3489 Message";
139 }
140
141 /*! \brief helper function to print attribute names */
142 static const char *stun_attr2str(int msg)
143 {
144         switch (msg) {
145         case STUN_MAPPED_ADDRESS:
146                 return "Mapped Address";
147         case STUN_RESPONSE_ADDRESS:
148                 return "Response Address";
149         case STUN_CHANGE_REQUEST:
150                 return "Change Request";
151         case STUN_SOURCE_ADDRESS:
152                 return "Source Address";
153         case STUN_CHANGED_ADDRESS:
154                 return "Changed Address";
155         case STUN_USERNAME:
156                 return "Username";
157         case STUN_PASSWORD:
158                 return "Password";
159         case STUN_MESSAGE_INTEGRITY:
160                 return "Message Integrity";
161         case STUN_ERROR_CODE:
162                 return "Error Code";
163         case STUN_UNKNOWN_ATTRIBUTES:
164                 return "Unknown Attributes";
165         case STUN_REFLECTED_FROM:
166                 return "Reflected From";
167         }
168         return "Non-RFC3489 Attribute";
169 }
170
171 /*! \brief here we store credentials extracted from a message */
172 struct stun_state {
173         const char *username;
174         const char *password;
175 };
176
177 static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
178 {
179         if (stundebug)
180                 ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
181                             stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
182         switch (ntohs(attr->attr)) {
183         case STUN_USERNAME:
184                 state->username = (const char *) (attr->value);
185                 break;
186         case STUN_PASSWORD:
187                 state->password = (const char *) (attr->value);
188                 break;
189         default:
190                 if (stundebug)
191                         ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n",
192                                     stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
193         }
194         return 0;
195 }
196
197 /*! \brief append a string to an STUN message */
198 static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
199 {
200         int size = sizeof(**attr) + strlen(s);
201         if (*left > size) {
202                 (*attr)->attr = htons(attrval);
203                 (*attr)->len = htons(strlen(s));
204                 memcpy((*attr)->value, s, strlen(s));
205                 (*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
206                 *len += size;
207                 *left -= size;
208         }
209 }
210
211 /*! \brief append an address to an STUN message */
212 static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
213 {
214         int size = sizeof(**attr) + 8;
215         struct stun_addr *addr;
216         if (*left > size) {
217                 (*attr)->attr = htons(attrval);
218                 (*attr)->len = htons(8);
219                 addr = (struct stun_addr *)((*attr)->value);
220                 addr->unused = 0;
221                 addr->family = 0x01;
222                 addr->port = sin->sin_port;
223                 addr->addr = sin->sin_addr.s_addr;
224                 (*attr) = (struct stun_attr *)((*attr)->value + 8);
225                 *len += size;
226                 *left -= size;
227         }
228 }
229
230 /*! \brief wrapper to send an STUN message */
231 static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
232 {
233         return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
234                       (struct sockaddr *)dst, sizeof(*dst));
235 }
236
237 /*! \brief helper function to generate a random request id */
238 static void stun_req_id(struct stun_header *req)
239 {
240         int x;
241         for (x = 0; x < 4; x++)
242                 req->id.id[x] = ast_random();
243 }
244
245 /*! \brief handle an incoming STUN message.
246  *
247  * Do some basic sanity checks on packet size and content,
248  * try to extract a bit of information, and possibly reply.
249  * At the moment this only processes BIND requests, and returns
250  * the externally visible address of the request.
251  * If a callback is specified, invoke it with the attribute.
252  */
253 int ast_stun_handle_packet(int s, struct sockaddr_in *src, unsigned char *data, size_t len, stun_cb_f *stun_cb, void *arg)
254 {
255         struct stun_header *hdr = (struct stun_header *)data;
256         struct stun_attr *attr;
257         struct stun_state st;
258         int ret = AST_STUN_IGNORE;
259         int x;
260
261         /* On entry, 'len' is the length of the udp payload. After the
262          * initial checks it becomes the size of unprocessed options,
263          * while 'data' is advanced accordingly.
264          */
265         if (len < sizeof(struct stun_header)) {
266                 ast_debug(1, "Runt STUN packet (only %d, wanting at least %d)\n", (int) len, (int) sizeof(struct stun_header));
267                 return -1;
268         }
269         len -= sizeof(struct stun_header);
270         data += sizeof(struct stun_header);
271         x = ntohs(hdr->msglen); /* len as advertised in the message */
272         if (stundebug)
273                 ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), x);
274         if (x > len) {
275                 ast_debug(1, "Scrambled STUN packet length (got %d, expecting %d)\n", x, (int)len);
276         } else
277                 len = x;
278         memset(&st, 0, sizeof(st));
279         while (len) {
280                 if (len < sizeof(struct stun_attr)) {
281                         ast_debug(1, "Runt Attribute (got %d, expecting %d)\n", (int)len, (int) sizeof(struct stun_attr));
282                         break;
283                 }
284                 attr = (struct stun_attr *)data;
285                 /* compute total attribute length */
286                 x = ntohs(attr->len) + sizeof(struct stun_attr);
287                 if (x > len) {
288                         ast_debug(1, "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", x, (int)len);
289                         break;
290                 }
291                 if (stun_cb)
292                         stun_cb(attr, arg);
293                 if (stun_process_attr(&st, attr)) {
294                         ast_debug(1, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
295                         break;
296                 }
297                 /* Clear attribute id: in case previous entry was a string,
298                  * this will act as the terminator for the string.
299                  */
300                 attr->attr = 0;
301                 data += x;
302                 len -= x;
303         }
304         /* Null terminate any string.
305          * XXX NOTE, we write past the size of the buffer passed by the
306          * caller, so this is potentially dangerous. The only thing that
307          * saves us is that usually we read the incoming message in a
308          * much larger buffer in the struct ast_rtp
309          */
310         *data = '\0';
311
312         /* Now prepare to generate a reply, which at the moment is done
313          * only for properly formed (len == 0) STUN_BINDREQ messages.
314          */
315         if (len == 0) {
316                 unsigned char respdata[1024];
317                 struct stun_header *resp = (struct stun_header *)respdata;
318                 int resplen = 0;        /* len excluding header */
319                 int respleft = sizeof(respdata) - sizeof(struct stun_header);
320
321                 resp->id = hdr->id;
322                 resp->msgtype = 0;
323                 resp->msglen = 0;
324                 attr = (struct stun_attr *)resp->ies;
325                 switch (ntohs(hdr->msgtype)) {
326                 case STUN_BINDREQ:
327                         if (stundebug)
328                                 ast_verbose("STUN Bind Request, username: %s\n",
329                                             st.username ? st.username : "<none>");
330                         if (st.username)
331                                 append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
332                         append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
333                         resp->msglen = htons(resplen);
334                         resp->msgtype = htons(STUN_BINDRESP);
335                         stun_send(s, src, resp);
336                         ret = AST_STUN_ACCEPT;
337                         break;
338                 default:
339                         if (stundebug)
340                                 ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
341                 }
342         }
343         return ret;
344 }
345
346 /*! \brief Extract the STUN_MAPPED_ADDRESS from the stun response.
347  * This is used as a callback for stun_handle_response
348  * when called from ast_stun_request.
349  */
350 static int stun_get_mapped(struct stun_attr *attr, void *arg)
351 {
352         struct stun_addr *addr = (struct stun_addr *)(attr + 1);
353         struct sockaddr_in *sa = (struct sockaddr_in *)arg;
354
355         if (ntohs(attr->attr) != STUN_MAPPED_ADDRESS || ntohs(attr->len) != 8)
356                 return 1;       /* not us. */
357         sa->sin_port = addr->port;
358         sa->sin_addr.s_addr = addr->addr;
359         return 0;
360 }
361
362 /*! \brief Generic STUN request
363  * Send a generic stun request to the server specified,
364  * possibly waiting for a reply and filling the 'reply' field with
365  * the externally visible address. Note that in this case the request
366  * will be blocking.
367  * (Note, the interface may change slightly in the future).
368  *
369  * \param s the socket used to send the request
370  * \param dst the address of the STUN server
371  * \param username if non null, add the username in the request
372  * \param answer if non null, the function waits for a response and
373  *    puts here the externally visible address.
374  * \return 0 on success, other values on error.
375  */
376 int ast_stun_request(int s, struct sockaddr_in *dst,
377         const char *username, struct sockaddr_in *answer)
378 {
379         struct stun_header *req;
380         unsigned char reqdata[1024];
381         int reqlen, reqleft;
382         struct stun_attr *attr;
383         int res = 0;
384         int retry;
385
386         req = (struct stun_header *)reqdata;
387         stun_req_id(req);
388         reqlen = 0;
389         reqleft = sizeof(reqdata) - sizeof(struct stun_header);
390         req->msgtype = 0;
391         req->msglen = 0;
392         attr = (struct stun_attr *)req->ies;
393         if (username)
394                 append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft);
395         req->msglen = htons(reqlen);
396         req->msgtype = htons(STUN_BINDREQ);
397         for (retry = 0; retry < 3; retry++) {   /* XXX make retries configurable */
398                 /* send request, possibly wait for reply */
399                 unsigned char reply_buf[1024];
400                 fd_set rfds;
401                 struct timeval to = { 3, 0 };   /* timeout, make it configurable */
402                 struct sockaddr_in src;
403                 socklen_t srclen;
404
405                 res = stun_send(s, dst, req);
406                 if (res < 0) {
407                         ast_log(LOG_WARNING, "ast_stun_request send #%d failed error %d, retry\n",
408                                 retry, res);
409                         continue;
410                 }
411                 if (answer == NULL)
412                         break;
413                 FD_ZERO(&rfds);
414                 FD_SET(s, &rfds);
415                 res = ast_select(s + 1, &rfds, NULL, NULL, &to);
416                 if (res <= 0)   /* timeout or error */
417                         continue;
418                 memset(&src, 0, sizeof(src));
419                 srclen = sizeof(src);
420                 /* XXX pass -1 in the size, because stun_handle_packet might
421                  * write past the end of the buffer.
422                  */
423                 res = recvfrom(s, reply_buf, sizeof(reply_buf) - 1,
424                         0, (struct sockaddr *)&src, &srclen);
425                 if (res < 0) {
426                         ast_log(LOG_WARNING, "ast_stun_request recvfrom #%d failed error %d, retry\n",
427                                 retry, res);
428                         continue;
429                 }
430                 memset(answer, 0, sizeof(struct sockaddr_in));
431                 ast_stun_handle_packet(s, &src, reply_buf, res,
432                         stun_get_mapped, answer);
433                 res = 0; /* signal regular exit */
434                 break;
435         }
436         return res;
437 }
438
439 static char *handle_cli_stun_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
440 {
441         switch (cmd) {
442         case CLI_INIT:
443                 e->command = "stun set debug {on|off}";
444                 e->usage =
445                         "Usage: stun set debug {on|off}\n"
446                         "       Enable/Disable STUN (Simple Traversal of UDP through NATs)\n"
447                         "       debugging\n";
448                 return NULL;
449         case CLI_GENERATE:
450                 return NULL;
451         }
452
453         if (a->argc != e->args)
454                 return CLI_SHOWUSAGE;
455
456         if (!strncasecmp(a->argv[e->args-1], "on", 2))
457                 stundebug = 1;
458         else if (!strncasecmp(a->argv[e->args-1], "off", 3))
459                 stundebug = 0;
460         else
461                 return CLI_SHOWUSAGE;
462
463         ast_cli(a->fd, "STUN Debugging %s\n", stundebug ? "Enabled" : "Disabled");
464         return CLI_SUCCESS;
465 }
466
467 static struct ast_cli_entry cli_stun[] = {
468         AST_CLI_DEFINE(handle_cli_stun_set_debug, "Enable/Disable STUN debugging"),
469 };
470
471 /*! \brief Initialize the STUN system in Asterisk */
472 void ast_stun_init(void)
473 {
474         ast_cli_register_multiple(cli_stun, sizeof(cli_stun) / sizeof(struct ast_cli_entry));
475 }