stun_mini.c 9.76 KB
Newer Older
Pekka Pessi's avatar
Pekka Pessi committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * This file is part of the Sofia-SIP package
 *
 * Copyright (C) 2005 Nokia Corporation.
 *
 * Contact: Pekka Pessi <pekka.pessi@nokia.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

25
/**@internal
Pekka Pessi's avatar
Pekka Pessi committed
26
 * @file stun_mini.c
27 28
 * @brief Minimal stun server
 *
Pekka Pessi's avatar
Pekka Pessi committed
29 30 31
 * @author Pekka Pessi <Pekka.Pessi@nokia.com>
 * @author Tat Chan <Tat.Chan@nokia.com>
 * @author Kai Vehmanen <kai.vehmanen@nokia.com>
32
 *
Pekka Pessi's avatar
Pekka Pessi committed
33
 * @date Created: Fri Oct  3 13:40:41 2003 ppessi
34
 *
Pekka Pessi's avatar
Pekka Pessi committed
35 36 37 38 39 40 41
 */

#include "config.h"

#include "stun_internal.h"

#include <assert.h>
42
#include <string.h>
Michael Jerris's avatar
Michael Jerris committed
43
#include <stdlib.h>
Pekka Pessi's avatar
Pekka Pessi committed
44

45
typedef struct stun_bound_s stun_bound_t;
Pekka Pessi's avatar
Pekka Pessi committed
46

47
struct stun_bound_s
Pekka Pessi's avatar
Pekka Pessi committed
48
{
49
  stun_bound_t *ss_next;
50
  su_socket_t ss_socket;
Pekka Pessi's avatar
Pekka Pessi committed
51
  int ss_scope;			/* LI_SCOPE */
Pekka Pessi's avatar
Pekka Pessi committed
52 53 54 55 56 57 58 59 60 61
  socklen_t ss_addrlen;
  union {
    struct sockaddr_in sin[1];
    struct sockaddr_storage storage[1];
    char array[sizeof (struct sockaddr_storage)];
  } ss_addr;
};

struct stun_mini_s
{
62
  stun_bound_t *sockets;
Pekka Pessi's avatar
Pekka Pessi committed
63 64
};

65
static int process_3489_request(stun_mini_t *mini,
Pekka Pessi's avatar
Pekka Pessi committed
66
				stun_msg_t *request, stun_msg_t *response,
67
				su_socket_t socket, void *, socklen_t);
Pekka Pessi's avatar
Pekka Pessi committed
68

69
static int process_bis_request(stun_mini_t *mini,
Pekka Pessi's avatar
Pekka Pessi committed
70
			       stun_msg_t *request, stun_msg_t *response,
71
			       su_socket_t socket, void *, socklen_t);
Pekka Pessi's avatar
Pekka Pessi committed
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

int send_stun_error(stun_msg_t *response,
		    int error,
		    int socket,
		    void *transaction_id,
		    void *from,
		    socklen_t fromlen);

/** Create a stun miniserver */
stun_mini_t *stun_mini_create(void)
{
  return calloc(1, sizeof (stun_mini_t));
}

/** Destroy a stun miniserver */
void stun_mini_destroy(stun_mini_t *mini)
{
  if (mini) {
90
    stun_bound_t *ss, **next;
Pekka Pessi's avatar
Pekka Pessi committed
91 92 93 94 95 96 97 98 99
    for (next = &mini->sockets; *next; ) {
      ss = *next;
      *next = ss->ss_next;
      free(ss);
    }
    free(mini);
  }
}

Pekka Pessi's avatar
Pekka Pessi committed
100
/** Add a socket to stun miniserver. */
101
int stun_mini_add_socket(stun_mini_t *mini, su_socket_t socket)
Pekka Pessi's avatar
Pekka Pessi committed
102
{
103
  stun_bound_t *ss, **next;
Pekka Pessi's avatar
Pekka Pessi committed
104 105 106 107
  struct sockaddr_storage addr[1];
  socklen_t addrlen = sizeof addr;

  if (mini == NULL)
Pekka Pessi's avatar
Pekka Pessi committed
108
    return su_seterrno(EFAULT);
Pekka Pessi's avatar
Pekka Pessi committed
109 110 111

  for (next = &mini->sockets; *next; next = &(*next)->ss_next)
    if (socket == (*next)->ss_socket)
Pekka Pessi's avatar
Pekka Pessi committed
112
      return su_seterrno(EEXIST);
Pekka Pessi's avatar
Pekka Pessi committed
113 114 115 116

  if (getsockname(socket, (void *)addr, &addrlen) < 0)
    return -1;

Pekka Pessi's avatar
Pekka Pessi committed
117 118 119
  if (addr->ss_family != AF_INET)
    return su_seterrno(EAFNOSUPPORT);

120
  ss = calloc(1, offsetof(stun_bound_t, ss_addr.array[addrlen]));
121

Pekka Pessi's avatar
Pekka Pessi committed
122
  ss->ss_socket = socket;
Pekka Pessi's avatar
Pekka Pessi committed
123 124
  ss->ss_scope = su_sockaddr_scope((void *)addr, addrlen);

Pekka Pessi's avatar
Pekka Pessi committed
125
  memcpy(ss->ss_addr.array, addr, ss->ss_addrlen = addrlen);
126

Pekka Pessi's avatar
Pekka Pessi committed
127 128 129 130 131 132
  *next = ss;

  return 0;
}

/** Remove socket from stun miniserver */
133
int stun_mini_remove_socket(stun_mini_t *mini, su_socket_t socket)
Pekka Pessi's avatar
Pekka Pessi committed
134
{
135
  stun_bound_t *ss, **next;
Pekka Pessi's avatar
Pekka Pessi committed
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151

  if (mini == NULL)
    return errno = EFAULT, -1;

  for (next = &mini->sockets; *next; next = &(*next)->ss_next)
    if (socket == (*next)->ss_socket) {
      ss = *next;
      *next = ss->ss_next;
      free(ss);
      return 0;
    }

  return errno = ENOENT, -1;
}

void stun_mini_request(stun_mini_t *mini,
152
		       su_socket_t socket,
Pekka Pessi's avatar
Pekka Pessi committed
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
		       void *msg, ssize_t msglen,
		       void *from, socklen_t fromlen)
{
  int error;
  struct {
    stun_msg_t in[1];
    stun_msg_t out[1];
    stun_msg_t error[1];
  } m;
  char const *verdict = NULL;
  uint8_t *data = msg;
  char buffer[80];
  uint8_t const magic_cookie[4] = { 0x21, 0x12, 0xA4, 0x42 };

  memset(&m, 0, sizeof m);

  if (mini == NULL || msg == NULL || from == NULL)
    return;
171

Pekka Pessi's avatar
Pekka Pessi committed
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
  if (msglen < 20)
    verdict = "runt";
  else if (data[0] == 1)
    verdict = "response";
  else if (data[0] != 0)
    verdict = "garbage";
  else if (data[1] == 2)
    verdict = "shared secret request";
  else if (data[1] != 1)
    verdict = "garbage";

  {
    struct sockaddr_in const *sin = from;

    if (sin->sin_family == AF_INET)
Michael Jerris's avatar
Michael Jerris committed
187
      su_inet_ntop(sin->sin_family, &sin->sin_addr, buffer, sizeof buffer);
Pekka Pessi's avatar
Pekka Pessi committed
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
    else
      sprintf(buffer, "<af=%u>", (unsigned)sin->sin_family);

    fprintf(stderr, "stun %s from %s:%u\n",
	    verdict ? verdict : "request", buffer, ntohs(sin->sin_port));

    if (verdict)
      return;
  }

  m.in->enc_buf.data = msg;
  m.in->enc_buf.size = msglen;

  if (memcmp(data + 4, magic_cookie, sizeof magic_cookie) == 0)
    error = process_3489_request(mini, m.in, m.out, socket, from, fromlen);
  else
    error = process_bis_request(mini, m.in, m.out, socket, from, fromlen);

  if (error)
    send_stun_error(m.error, error, socket, data + 4, from, fromlen);

  m.in->enc_buf.data = NULL;

  stun_free_message(m.in);
  stun_free_message(m.out);
  stun_free_message(m.error);
}

static
int process_3489_request(stun_mini_t *mini,
			 stun_msg_t *request,
			 stun_msg_t *response,
220
			 su_socket_t socket,
221
			 void *from,
Pekka Pessi's avatar
Pekka Pessi committed
222 223
			 socklen_t fromlen)
{
224
  stun_bound_t *ss, *changed = NULL, ss0[1];
Pekka Pessi's avatar
Pekka Pessi committed
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
  stun_attr_t *a, **next;
  stun_attr_sockaddr_t *addr;
  int change_address = 0;

  if (stun_parse_message(request) < 0) {
    fprintf(stderr, "stun: error parsing request\n");
    return STUN_400_BAD_REQUEST;
  }

  if (request->stun_hdr.msg_type != BINDING_REQUEST) {
    fprintf(stderr, "stun: not binding request\n");
    return 0;
  }

  a = stun_get_attr(request->stun_attr, RESPONSE_ADDRESS);
  if (a)
    return STUN_600_GLOBAL_FAILURE;
242

Pekka Pessi's avatar
Pekka Pessi committed
243 244
  /* compose header */
  response->stun_hdr.msg_type = BINDING_RESPONSE;
245
  memcpy(response->stun_hdr.tran_id, request->stun_hdr.tran_id,
Pekka Pessi's avatar
Pekka Pessi committed
246
	 sizeof response->stun_hdr.tran_id);
247

Pekka Pessi's avatar
Pekka Pessi committed
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
  next = &response->stun_attr;

  /* MAPPED-ADDRESS */
  a = malloc(sizeof *a); if (!a) return STUN_500_SERVER_ERROR;
  a->attr_type = MAPPED_ADDRESS;
  addr = malloc(sizeof *addr); if (!addr) return STUN_500_SERVER_ERROR;
  memcpy(addr, from, sizeof *addr);
  a->pattr = addr;
  a->next = NULL;
  *next = a; next = &a->next;

  /* SOURCE-ADDRESS */ /* depends on CHANGE_REQUEST */
  a = stun_get_attr(request->stun_attr, CHANGE_REQUEST);
  if (a)
    change_address = ((stun_attr_changerequest_t *)a->pattr)->value;

  if (change_address) {
    struct sockaddr_in const *sin, *sin2;
Pekka Pessi's avatar
Pekka Pessi committed
266
    int scope = su_sockaddr_scope(from, fromlen);
267
    stun_bound_t *changed_ip = NULL, *same_scope = NULL;
268

Pekka Pessi's avatar
Pekka Pessi committed
269 270 271 272
    sin = from;

    for (changed = mini->sockets; changed; changed = changed->ss_next) {
      sin2 = changed->ss_addr.sin;
Pekka Pessi's avatar
Pekka Pessi committed
273

274
      if (scope != LI_SCOPE_HOST && changed->ss_scope == LI_SCOPE_HOST)
Pekka Pessi's avatar
Pekka Pessi committed
275 276
	continue;

277
      if (scope != LI_SCOPE_SITE && changed->ss_scope == LI_SCOPE_SITE)
Pekka Pessi's avatar
Pekka Pessi committed
278 279 280 281 282 283 284 285 286 287 288 289
	continue;

      if (same_scope == NULL)
	same_scope = changed;

      if (change_address & STUN_CR_CHANGE_IP)
	if (!memcmp(&sin->sin_addr, &sin2->sin_addr, sizeof sin->sin_addr))
	  continue;

      if (changed_ip == NULL)
	changed_ip = changed;

Pekka Pessi's avatar
Pekka Pessi committed
290 291 292 293 294
      if (change_address & STUN_CR_CHANGE_PORT)
	if (sin->sin_port == sin2->sin_port)
	  continue;
    }

Pekka Pessi's avatar
Pekka Pessi committed
295 296 297 298
    if (changed == NULL && (change_address & STUN_CR_CHANGE_IP))
      /* We don't have socekt with both changed port and ip */
      changed = changed_ip;

299
    if (changed == NULL)
Pekka Pessi's avatar
Pekka Pessi committed
300
      changed = same_scope;
Pekka Pessi's avatar
Pekka Pessi committed
301 302 303
  }

  for (ss = mini->sockets; ss; ss = ss->ss_next)
304
    if (socket == ss->ss_socket)
Pekka Pessi's avatar
Pekka Pessi committed
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
      break;

  if (ss == NULL) {
    memset(ss = ss0, 0, sizeof ss0);
    ss->ss_socket = socket;
    ss->ss_addrlen = sizeof ss->ss_addr;
    if (getsockname(socket, (void *)ss->ss_addr.array, &ss->ss_addrlen) < 0)
      return STUN_500_SERVER_ERROR;
  }

  a = malloc(sizeof *a); if (!a) return STUN_500_SERVER_ERROR;
  a->attr_type = SOURCE_ADDRESS;
  addr = malloc(sizeof *addr); if (!addr) return STUN_500_SERVER_ERROR;
  memcpy(addr, ss->ss_addr.array, sizeof *addr);
  a->pattr = addr;
  a->next = NULL;
  *next = a; next = &(a->next);

  if (changed) {
    socket = changed->ss_socket;

    /* CHANGED-ADDRESS */
    a = malloc(sizeof *a); if (!a) return STUN_500_SERVER_ERROR;
    a->attr_type = CHANGED_ADDRESS;
    addr = malloc(sizeof *addr); if (!addr) return STUN_500_SERVER_ERROR;
    memcpy(addr, changed->ss_addr.array, sizeof *addr);

332 333 334 335
    a->pattr = addr;
    a->next = NULL;
    *next = a; next = &(a->next);
  }
Pekka Pessi's avatar
Pekka Pessi committed
336 337 338 339

  stun_send_message(socket, (void *)from, response, NULL);

  return 0;
340
}
Pekka Pessi's avatar
Pekka Pessi committed
341

342
static int process_bis_request(stun_mini_t *mini,
Pekka Pessi's avatar
Pekka Pessi committed
343
			       stun_msg_t *request, stun_msg_t *response,
344
			       su_socket_t socket,
Pekka Pessi's avatar
Pekka Pessi committed
345
			       void *from, socklen_t fromlen)
Pekka Pessi's avatar
Pekka Pessi committed
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
{
  return process_3489_request(mini, request, response, socket, from, fromlen);
}

int send_stun_error(stun_msg_t *response,
		    int error,
		    int socket,
		    void *transaction_id,
		    void *from,
		    socklen_t fromlen)
{
  stun_attr_t *attr;
  stun_attr_errorcode_t *errorcode;
  char const *phrase = stun_response_phrase(error);

  if (!phrase)
    error = STUN_500_SERVER_ERROR, phrase = "Internal Server Error";

  stun_init_message(response);

  response->stun_hdr.msg_type = BINDING_ERROR_RESPONSE;
  response->stun_hdr.msg_len = 0; /* actual len computed later */
368

Pekka Pessi's avatar
Pekka Pessi committed
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
  memcpy(response->stun_hdr.tran_id, transaction_id, 16);

  /* ERROR-CODE */
  attr = malloc(sizeof *attr); if (!attr) return -1;
  response->stun_attr = attr;
  attr->attr_type = ERROR_CODE;

  errorcode = malloc(sizeof(*errorcode));
  if (!errorcode)
    return -1;
  errorcode->code = error;
  errorcode->phrase = malloc(strlen(phrase) + 1);
  if (!errorcode->phrase)
    return -1;
  strcpy(errorcode->phrase, phrase);
  attr->pattr = errorcode;

  stun_send_message(socket, from, response, NULL);

  return 0;
}