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
 *
 */

Pekka Pessi's avatar
Pekka Pessi committed
25
/**@internal
Pekka Pessi's avatar
Pekka Pessi committed
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
 * @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>
Pekka Pessi's avatar
Pekka Pessi committed
42
#include <string.h>
Pekka Pessi's avatar
Pekka Pessi committed
43

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

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

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

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

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

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

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

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

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

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

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

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

  return 0;
}

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

  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,
151
		       su_socket_t socket,
Pekka Pessi's avatar
Pekka Pessi committed
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 218
		       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,
219
			 su_socket_t socket,
Pekka Pessi's avatar
Pekka Pessi committed
220
			 void *from, 
Pekka Pessi's avatar
Pekka Pessi committed
221 222
			 socklen_t fromlen)
{
223
  stun_bound_t *ss, *changed = NULL, ss0[1];
Pekka Pessi's avatar
Pekka Pessi committed
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 264
  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
265
    int scope = su_sockaddr_scope(from, fromlen);
266
    stun_bound_t *changed_ip = NULL, *same_scope = NULL;
Pekka Pessi's avatar
Pekka Pessi committed
267
    
Pekka Pessi's avatar
Pekka Pessi committed
268 269 270 271
    sin = from;

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

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

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

Pekka Pessi's avatar
Pekka Pessi committed
294 295 296 297
    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
298
    if (changed == NULL) 
Pekka Pessi's avatar
Pekka Pessi committed
299
      changed = same_scope;
Pekka Pessi's avatar
Pekka Pessi committed
300 301 302
  }

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

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

  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,
343
			       su_socket_t socket, 
Pekka Pessi's avatar
Pekka Pessi committed
344
			       void *from, socklen_t fromlen)
Pekka Pessi's avatar
Pekka Pessi committed
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 389
{
  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;
}