stun_mini.c 9.74 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 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
/*
 * 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
 *
 */

/**
 * @file stun_mini.c
 * @brief Minimal stun server 
 * 
 * @author Pekka Pessi <Pekka.Pessi@nokia.com>
 * @author Tat Chan <Tat.Chan@nokia.com>
 * @author Kai Vehmanen <kai.vehmanen@nokia.com>
 *  
 * @date Created: Fri Oct  3 13:40:41 2003 ppessi
 * 
 */

#include "config.h"

#include "stun_internal.h"

#include <assert.h>

43
typedef struct stun_bound_s stun_bound_t;
Pekka Pessi's avatar
Pekka Pessi committed
44

45
struct stun_bound_s
Pekka Pessi's avatar
Pekka Pessi committed
46
{
47
  stun_bound_t *ss_next;
48
  su_socket_t ss_socket;
Pekka Pessi's avatar
Pekka Pessi committed
49
  int ss_scope;			/* LI_SCOPE */
Pekka Pessi's avatar
Pekka Pessi committed
50 51 52 53 54 55 56 57 58 59
  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
{
60
  stun_bound_t *sockets;
Pekka Pessi's avatar
Pekka Pessi committed
61 62 63 64
};

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

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

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) {
88
    stun_bound_t *ss, **next;
Pekka Pessi's avatar
Pekka Pessi committed
89 90 91 92 93 94 95 96 97
    for (next = &mini->sockets; *next; ) {
      ss = *next;
      *next = ss->ss_next;
      free(ss);
    }
    free(mini);
  }
}

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

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

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

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

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

118
  ss = calloc(1, offsetof(stun_bound_t, ss_addr.array[addrlen]));
Pekka Pessi's avatar
Pekka Pessi committed
119 120
  
  ss->ss_socket = socket;
Pekka Pessi's avatar
Pekka Pessi committed
121 122
  ss->ss_scope = su_sockaddr_scope((void *)addr, addrlen);

Pekka Pessi's avatar
Pekka Pessi committed
123 124 125 126 127 128 129 130
  memcpy(ss->ss_addr.array, addr, ss->ss_addrlen = addrlen);
  
  *next = ss;

  return 0;
}

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

  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,
150
		       su_socket_t socket,
Pekka Pessi's avatar
Pekka Pessi committed
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 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
		       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;
    
  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)
      inet_ntop(sin->sin_family, &sin->sin_addr, buffer, sizeof buffer);
    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,
218
			 su_socket_t socket,
Pekka Pessi's avatar
Pekka Pessi committed
219
			 void *from, 
Pekka Pessi's avatar
Pekka Pessi committed
220 221
			 socklen_t fromlen)
{
222
  stun_bound_t *ss, *changed = NULL, ss0[1];
Pekka Pessi's avatar
Pekka Pessi committed
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
  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;
 
  /* compose header */
  response->stun_hdr.msg_type = BINDING_RESPONSE;
  memcpy(response->stun_hdr.tran_id, request->stun_hdr.tran_id, 
	 sizeof response->stun_hdr.tran_id);
  
  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
264
    int scope = su_sockaddr_scope(from, fromlen);
265
    stun_bound_t *changed_ip = NULL, *same_scope = NULL;
Pekka Pessi's avatar
Pekka Pessi committed
266
    
Pekka Pessi's avatar
Pekka Pessi committed
267 268 269 270
    sin = from;

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

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

275
      if (scope != LI_SCOPE_SITE && changed->ss_scope == LI_SCOPE_SITE)
Pekka Pessi's avatar
Pekka Pessi committed
276 277 278 279 280 281 282 283 284 285 286 287
	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
288 289 290 291 292
      if (change_address & STUN_CR_CHANGE_PORT)
	if (sin->sin_port == sin2->sin_port)
	  continue;
    }

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

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

  for (ss = mini->sockets; ss; ss = ss->ss_next)
302
    if (socket == ss->ss_socket)
Pekka Pessi's avatar
Pekka Pessi committed
303 304 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
      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);

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

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

  return 0;
} 

static int process_bis_request(stun_mini_t *mini, 
			       stun_msg_t *request, stun_msg_t *response,
342
			       su_socket_t socket, 
Pekka Pessi's avatar
Pekka Pessi committed
343
			       void *from, socklen_t fromlen)
Pekka Pessi's avatar
Pekka Pessi committed
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
{
  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 */
  
  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;
}