media formats: re-architect handling of media for performance improvements
[asterisk/asterisk.git] / channels / sip / route.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * See http://www.asterisk.org for more information about
7  * the Asterisk project. Please do not directly contact
8  * any of the maintainers of this project for assistance;
9  * the project provides a web site, mailing lists and IRC
10  * channels for your use.
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License Version 2. See the LICENSE file
14  * at the top of the source tree.
15  */
16
17 /*!
18  * \file
19  * \brief sip_route functions
20  */
21
22 /*** MODULEINFO
23         <support_level>core</support_level>
24  ***/
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include "asterisk/utils.h"
31
32 #include "include/route.h"
33 #include "include/reqresp_parser.h"
34
35 /*!
36  * \brief Traverse route hops
37  */
38 #define sip_route_traverse(route,elem) AST_LIST_TRAVERSE(&(route)->list, elem, list)
39 #define sip_route_first(route) AST_LIST_FIRST(&(route)->list)
40
41 /*!
42  * \brief Structure to save a route hop
43  */
44 struct sip_route_hop {
45         AST_LIST_ENTRY(sip_route_hop) list;
46         char uri[0];
47 };
48
49 const char *sip_route_add(struct sip_route *route, const char *uri, size_t len, int inserthead)
50 {
51         struct sip_route_hop *hop;
52
53         if (!uri || len < 1 || uri[0] == '\0') {
54                 return NULL;
55         }
56
57         /* Expand len to include null terminator */
58         len++;
59
60         /* ast_calloc is not needed because all fields are initialized in this block */
61         hop = ast_malloc(sizeof(struct sip_route_hop) + len);
62         if (!hop) {
63                 return NULL;
64         }
65         ast_copy_string(hop->uri, uri, len);
66
67         if (inserthead) {
68                 AST_LIST_INSERT_HEAD(&route->list, hop, list);
69                 route->type = route_invalidated;
70         } else {
71                 if (sip_route_empty(route)) {
72                         route->type = route_invalidated;
73                 }
74                 AST_LIST_INSERT_TAIL(&route->list, hop, list);
75                 hop->list.next = NULL;
76         }
77
78         return hop->uri;
79 }
80
81 void sip_route_process_header(struct sip_route *route, const char *header, int inserthead)
82 {
83         const char *hop;
84         int len = 0;
85         const char *uri;
86
87         if (!route) {
88                 ast_log(LOG_ERROR, "sip_route_process_header requires non-null route");
89                 ast_do_crash();
90                 return;
91         }
92
93         while (!get_in_brackets_const(header, &uri, &len)) {
94                 header = strchr(header, ',');
95                 if (header >= uri && header <= (uri + len)) {
96                         /* comma inside brackets */
97                         const char *next_br = strchr(header, '<');
98                         if (next_br && next_br <= (uri + len)) {
99                                 header++;
100                                 continue;
101                         }
102                         continue;
103                 }
104                 if ((hop = sip_route_add(route, uri, len, inserthead))) {
105                         ast_debug(2, "sip_route_process_header: <%s>\n", hop);
106                 }
107                 header = strchr(uri + len + 1, ',');
108                 if (header == NULL) {
109                         /* No more field-values, we're done with this header */
110                         break;
111                 }
112                 /* Advance past comma */
113                 header++;
114         }
115 }
116
117 void sip_route_copy(struct sip_route *dst, const struct sip_route *src)
118 {
119         struct sip_route_hop *hop;
120
121         /* make sure dst is empty */
122         sip_route_clear(dst);
123
124         sip_route_traverse(src, hop) {
125                 const char *uri = sip_route_add(dst, hop->uri, strlen(hop->uri), 0);
126                 if (uri) {
127                         ast_debug(2, "sip_route_copy: copied hop: <%s>\n", uri);
128                 }
129         }
130
131         dst->type = src->type;
132 }
133
134 void sip_route_clear(struct sip_route *route)
135 {
136         struct sip_route_hop *hop;
137
138         while ((hop = AST_LIST_REMOVE_HEAD(&route->list, list))) {
139                 ast_free(hop);
140         }
141
142         route->type = route_loose;
143 }
144
145 void sip_route_dump(const struct sip_route *route)
146 {
147         if (sip_route_empty(route)) {
148                 ast_verbose("sip_route_dump: no route/path\n");
149         } else {
150                 struct sip_route_hop *hop;
151                 sip_route_traverse(route, hop) {
152                         ast_verbose("sip_route_dump: route/path hop: <%s>\n", hop->uri);
153                 }
154         }
155 }
156
157 struct ast_str *sip_route_list(const struct sip_route *route, int formatcli, int skip)
158 {
159         struct sip_route_hop *hop;
160         const char *comma;
161         struct ast_str *buf;
162         int i = 0 - skip;
163
164         buf = ast_str_create(64);
165         if (!buf) {
166                 return NULL;
167         }
168
169         comma = formatcli ? ", " : ",";
170
171         sip_route_traverse(route, hop) {
172                 if (i >= 0) {
173                         ast_str_append(&buf, 0, "%s<%s>", i ? comma : "", hop->uri);
174                 }
175                 i++;
176         }
177
178         if (formatcli && i <= 0) {
179                 ast_str_append(&buf, 0, "N/A");
180         }
181
182         return buf;
183 }
184
185 int sip_route_is_strict(struct sip_route *route)
186 {
187         if (!route) {
188                 return 0;
189         }
190
191         if (route->type == route_invalidated) {
192                 struct sip_route_hop *hop = sip_route_first(route);
193                 int ret = hop && (strstr(hop->uri, ";lr") == NULL);
194                 route->type = ret ? route_strict : route_loose;
195                 return ret;
196         }
197
198         return (route->type == route_strict) ? 1 : 0;
199 }
200
201 const char *sip_route_first_uri(const struct sip_route *route)
202 {
203         struct sip_route_hop *hop = sip_route_first(route);
204         return hop ? hop->uri : NULL;
205 }