route.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2013, Digium, Inc.
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*!
 * \file
 * \brief sip_route functions
 */

/*** MODULEINFO
   <support_level>deprecated</support_level>
 ***/

#include "asterisk.h"

#include "asterisk/utils.h"

#include "include/route.h"
#include "include/reqresp_parser.h"

/*!
 * \brief Traverse route hops
 */
#define sip_route_traverse(route,elem) AST_LIST_TRAVERSE(&(route)->list, elem, list)
#define sip_route_first(route) AST_LIST_FIRST(&(route)->list)

/*!
 * \brief Structure to save a route hop
 */
struct sip_route_hop {
   AST_LIST_ENTRY(sip_route_hop) list;
   char uri[0];
};

const char *sip_route_add(struct sip_route *route, const char *uri, size_t len, int inserthead)
{
   struct sip_route_hop *hop;

   if (!uri || len < 1 || uri[0] == '\0') {
      return NULL;
   }

   /* Expand len to include null terminator */
   len++;

   /* ast_calloc is not needed because all fields are initialized in this block */
   hop = ast_malloc(sizeof(struct sip_route_hop) + len);
   if (!hop) {
      return NULL;
   }
   ast_copy_string(hop->uri, uri, len);

   if (inserthead) {
      AST_LIST_INSERT_HEAD(&route->list, hop, list);
      route->type = route_invalidated;
   } else {
      if (sip_route_empty(route)) {
         route->type = route_invalidated;
      }
      AST_LIST_INSERT_TAIL(&route->list, hop, list);
      hop->list.next = NULL;
   }

   return hop->uri;
}

void sip_route_process_header(struct sip_route *route, const char *header, int inserthead)
{
   const char *hop;
   int len = 0;
   const char *uri;

   if (!route) {
      ast_log(LOG_ERROR, "sip_route_process_header requires non-null route");
      ast_do_crash();
      return;
   }

   while (!get_in_brackets_const(header, &uri, &len)) {
      header = strchr(header, ',');
      if (header >= uri && header <= (uri + len)) {
         /* comma inside brackets */
         const char *next_br = strchr(header, '<');
         if (next_br && next_br <= (uri + len)) {
            header++;
            continue;
         }
         continue;
      }
      if ((hop = sip_route_add(route, uri, len, inserthead))) {
         ast_debug(2, "sip_route_process_header: <%s>\n", hop);
      }
      header = strchr(uri + len + 1, ',');
      if (header == NULL) {
         /* No more field-values, we're done with this header */
         break;
      }
      /* Advance past comma */
      header++;
   }
}

void sip_route_copy(struct sip_route *dst, const struct sip_route *src)
{
   struct sip_route_hop *hop;

   /* make sure dst is empty */
   sip_route_clear(dst);

   sip_route_traverse(src, hop) {
      const char *uri = sip_route_add(dst, hop->uri, strlen(hop->uri), 0);
      if (uri) {
         ast_debug(2, "sip_route_copy: copied hop: <%s>\n", uri);
      }
   }

   dst->type = src->type;
}

void sip_route_clear(struct sip_route *route)
{
   struct sip_route_hop *hop;

   while ((hop = AST_LIST_REMOVE_HEAD(&route->list, list))) {
      ast_free(hop);
   }

   route->type = route_loose;
}

void sip_route_dump(const struct sip_route *route)
{
   if (sip_route_empty(route)) {
      ast_verbose("sip_route_dump: no route/path\n");
   } else {
      struct sip_route_hop *hop;
      sip_route_traverse(route, hop) {
         ast_verbose("sip_route_dump: route/path hop: <%s>\n", hop->uri);
      }
   }
}

struct ast_str *sip_route_list(const struct sip_route *route, int formatcli, int skip)
{
   struct sip_route_hop *hop;
   const char *comma;
   struct ast_str *buf;
   int i = 0 - skip;

   buf = ast_str_create(64);
   if (!buf) {
      return NULL;
   }

   comma = formatcli ? ", " : ",";

   sip_route_traverse(route, hop) {
      if (i >= 0) {
         ast_str_append(&buf, 0, "%s<%s>", i ? comma : "", hop->uri);
      }
      i++;
   }

   if (formatcli && i <= 0) {
      ast_str_append(&buf, 0, "N/A");
   }

   return buf;
}

int sip_route_is_strict(struct sip_route *route)
{
   if (!route) {
      return 0;
   }

   if (route->type == route_invalidated) {
      struct sip_route_hop *hop = sip_route_first(route);
      int ret = hop && (strstr(hop->uri, ";lr") == NULL);
      route->type = ret ? route_strict : route_loose;
      return ret;
   }

   return (route->type == route_strict) ? 1 : 0;
}

const char *sip_route_first_uri(const struct sip_route *route)
{
   struct sip_route_hop *hop = sip_route_first(route);
   return hop ? hop->uri : NULL;
}