Merge "res_pjsip: New endpoint option "refer_blind_progress""
[asterisk/asterisk.git] / res / res_sdp_translator_pjmedia.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2017, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 #include "asterisk.h"
20 #include "asterisk/sdp_translator.h"
21 #include "asterisk/sdp_options.h"
22 #include "asterisk/vector.h"
23 #include "asterisk/netsock2.h"
24 #include "asterisk/utils.h"
25 #include "asterisk/config.h"
26 #include "asterisk/test.h"
27 #include "asterisk/module.h"
28
29 #include "asterisk/sdp.h"
30 #ifdef HAVE_PJPROJECT
31 #include <pjlib.h>
32 #include <pjmedia.h>
33 #endif
34
35 /*** MODULEINFO
36         <depend>pjproject</depend>
37         <support_level>core</support_level>
38  ***/
39
40 /*
41  * XXX TODO: The memory in the pool is held onto longer than necessary.  It
42  * is kept and grows for the duration of the associated chan_pjsip session.
43  *
44  * The translation API does not need to be so generic.  The users will know
45  * at compile time what the non-Asterisk SDP format they have or need.  They
46  * should simply call the specific translation functions.  However, to make
47  * this a loadable module we need to be able to keep it in memory when a
48  * dependent module is loaded.
49  *
50  * To address both issues I propose this API:
51  *
52  * void ast_sdp_translate_pjmedia_ref(void) - Inc this module's user ref
53  * void ast_sdp_translate_pjmedia_unref(void) - Dec this module's user ref.
54  *    The res_pjsip_session.c:ast_sip_session_alloc() can call the module ref
55  *    and the session's destructor can call the module unref.
56  *
57  * struct ast_sdp *ast_sdp_translate_pjmedia_from(const pjmedia_sdp_session *pjmedia_sdp);
58  *
59  * pjmedia_sdp_session *ast_sdp_translate_pjmedia_to(const struct ast_sdp *sdp, pj_pool_t *pool);
60  *    Passing in a memory pool allows the memory to be obtained from an
61  *    rdata memory pool that will be released when the message processing
62  *    is complete.  This prevents memory from accumulating for the duration
63  *    of a call.
64  *
65  * int ast_sdp_translate_pjmedia_set_remote_sdp(struct ast_sdp_state *sdp_state, const pjmedia_sdp_session *remote);
66  * const pjmedia_sdp_session *ast_sdp_translate_pjmedia_get_local_sdp(struct ast_sdp_state *sdp_state, pj_pool_t *pool);
67  *    These two functions just do the bookkeeping to translate and set or get
68  *    the requested SDP.
69  *
70  *
71  * XXX TODO: This code doesn't handle allocation failures very well.  i.e.,
72  *   It assumes they will never happen.
73  *
74  * XXX TODO: This code uses ast_alloca() inside loops.  Doing so if the number
75  *   of times through the loop is unconstrained will blow the stack.
76  *   See dupa_pj_str() usage.
77  */
78
79 static pj_caching_pool sdp_caching_pool;
80
81
82 static void *pjmedia_new(void)
83 {
84         pj_pool_t *pool;
85
86         pool = pj_pool_create(&sdp_caching_pool.factory, "pjmedia sdp translator", 1024, 1024, NULL);
87
88         return pool;
89 }
90
91 static void pjmedia_free(void *translator_priv)
92 {
93         pj_pool_t *pool = translator_priv;
94
95         pj_pool_release(pool);
96 }
97
98 #define dupa_pj_str(pjstr) \
99 ({ \
100         char *dest = ast_alloca(pjstr.slen + 1); \
101         memcpy(dest, pjstr.ptr, pjstr.slen); \
102         dest[pjstr.slen] = '\0'; \
103         dest; \
104 })
105
106 static struct ast_sdp_m_line *pjmedia_copy_m_line(struct pjmedia_sdp_media *pjmedia_m_line)
107 {
108         int i;
109
110         struct ast_sdp_c_line *c_line = pjmedia_m_line->conn ?
111                 ast_sdp_c_alloc(dupa_pj_str(pjmedia_m_line->conn->addr_type),
112                 dupa_pj_str(pjmedia_m_line->conn->addr)) : NULL;
113
114         struct ast_sdp_m_line *m_line = ast_sdp_m_alloc(dupa_pj_str(pjmedia_m_line->desc.media),
115                 pjmedia_m_line->desc.port, pjmedia_m_line->desc.port_count,
116                 dupa_pj_str(pjmedia_m_line->desc.transport), c_line);
117
118         for (i = 0; i < pjmedia_m_line->desc.fmt_count; ++i) {
119                 ast_sdp_m_add_payload(m_line,
120                         ast_sdp_payload_alloc(dupa_pj_str(pjmedia_m_line->desc.fmt[i])));
121         }
122
123         for (i = 0; i < pjmedia_m_line->attr_count; ++i) {
124                 ast_sdp_m_add_a(m_line, ast_sdp_a_alloc(dupa_pj_str(pjmedia_m_line->attr[i]->name),
125                         dupa_pj_str(pjmedia_m_line->attr[i]->value)));
126         }
127
128         return m_line;
129 }
130
131 static void pjmedia_copy_a_lines(struct ast_sdp *new_sdp, const pjmedia_sdp_session *pjmedia_sdp)
132 {
133         int i;
134
135         for (i = 0; i < pjmedia_sdp->attr_count; ++i) {
136                 ast_sdp_add_a(new_sdp, ast_sdp_a_alloc(dupa_pj_str(pjmedia_sdp->attr[i]->name),
137                         dupa_pj_str(pjmedia_sdp->attr[i]->value)));
138         }
139 }
140
141 static void pjmedia_copy_m_lines(struct ast_sdp *new_sdp,
142         const struct pjmedia_sdp_session *pjmedia_sdp)
143 {
144         int i;
145
146         for (i = 0; i < pjmedia_sdp->media_count; ++i) {
147                 ast_sdp_add_m(new_sdp, pjmedia_copy_m_line(pjmedia_sdp->media[i]));
148         }
149 }
150
151 static struct ast_sdp *pjmedia_to_sdp(const void *in, void *translator_priv)
152 {
153         const struct pjmedia_sdp_session *pjmedia_sdp = in;
154
155         struct ast_sdp_o_line *o_line = ast_sdp_o_alloc(dupa_pj_str(pjmedia_sdp->origin.user),
156                 pjmedia_sdp->origin.id, pjmedia_sdp->origin.version,
157                 dupa_pj_str(pjmedia_sdp->origin.addr_type), dupa_pj_str(pjmedia_sdp->origin.addr));
158
159         struct ast_sdp_c_line *c_line = pjmedia_sdp->conn ?
160                 ast_sdp_c_alloc(dupa_pj_str(pjmedia_sdp->conn->addr_type),
161                         dupa_pj_str(pjmedia_sdp->conn->addr)) : NULL;
162
163         struct ast_sdp_s_line *s_line = ast_sdp_s_alloc(dupa_pj_str(pjmedia_sdp->name));
164
165         struct ast_sdp_t_line *t_line = ast_sdp_t_alloc(pjmedia_sdp->time.start,
166                 pjmedia_sdp->time.stop);
167
168         struct ast_sdp *new_sdp = ast_sdp_alloc(o_line, c_line, s_line, t_line);
169
170         pjmedia_copy_a_lines(new_sdp, pjmedia_sdp);
171         pjmedia_copy_m_lines(new_sdp, pjmedia_sdp);
172
173         return new_sdp;
174 }
175
176 static void copy_o_line_pjmedia(pj_pool_t *pool, pjmedia_sdp_session *pjmedia_sdp,
177         struct ast_sdp_o_line *o_line)
178 {
179         pjmedia_sdp->origin.id = o_line->session_id;
180         pjmedia_sdp->origin.version = o_line->session_version;
181         pj_strdup2(pool, &pjmedia_sdp->origin.user, o_line->username);
182         pj_strdup2(pool, &pjmedia_sdp->origin.addr_type, o_line->address_type);
183         pj_strdup2(pool, &pjmedia_sdp->origin.addr, o_line->address);
184         pj_strdup2(pool, &pjmedia_sdp->origin.net_type, "IN");
185 }
186
187 static void copy_s_line_pjmedia(pj_pool_t *pool, pjmedia_sdp_session *pjmedia_sdp,
188         struct ast_sdp_s_line *s_line)
189 {
190         pj_strdup2(pool, &pjmedia_sdp->name, s_line->session_name);
191 }
192
193 static void copy_t_line_pjmedia(pj_pool_t *pool, pjmedia_sdp_session *pjmedia_sdp,
194         struct ast_sdp_t_line *t_line)
195 {
196         pjmedia_sdp->time.start = t_line->start_time;
197         pjmedia_sdp->time.stop = t_line->stop_time;
198 }
199
200 static void copy_c_line_pjmedia(pj_pool_t *pool, pjmedia_sdp_conn **conn,
201         struct ast_sdp_c_line *c_line)
202 {
203         pjmedia_sdp_conn *local_conn;
204         local_conn = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_conn);
205         pj_strdup2(pool, &local_conn->addr_type, c_line->address_type);
206         pj_strdup2(pool, &local_conn->addr, c_line->address);
207         pj_strdup2(pool, &local_conn->net_type, "IN");
208
209         *conn = local_conn;
210 }
211
212 static void copy_a_lines_pjmedia(pj_pool_t *pool, pjmedia_sdp_session *pjmedia_sdp,
213         const struct ast_sdp *sdp)
214 {
215         int i;
216
217         for (i = 0; i < ast_sdp_get_a_count(sdp); ++i) {
218                 pjmedia_sdp_attr *attr;
219                 pj_str_t value;
220                 struct ast_sdp_a_line *a_line;
221
222                 a_line = ast_sdp_get_a(sdp, i);
223                 pj_strdup2(pool, &value, a_line->value);
224                 attr = pjmedia_sdp_attr_create(pool, a_line->name, &value);
225                 pjmedia_sdp_session_add_attr(pjmedia_sdp, attr);
226         }
227 }
228
229 static void copy_a_lines_pjmedia_media(pj_pool_t *pool, pjmedia_sdp_media *media,
230         struct ast_sdp_m_line *m_line)
231 {
232         int i;
233
234         for (i = 0; i < ast_sdp_m_get_a_count(m_line); ++i) {
235                 pjmedia_sdp_attr *attr;
236                 pj_str_t value;
237                 struct ast_sdp_a_line *a_line;
238
239                 a_line = ast_sdp_m_get_a(m_line, i);
240                 pj_strdup2(pool, &value, a_line->value);
241                 attr = pjmedia_sdp_attr_create(pool, a_line->name, &value);
242                 pjmedia_sdp_media_add_attr(media, attr);
243         }
244 }
245
246 static void copy_m_line_pjmedia(pj_pool_t *pool, pjmedia_sdp_media *media,
247         struct ast_sdp_m_line *m_line)
248 {
249         int i;
250
251         media->desc.port = m_line->port;
252         media->desc.port_count = m_line->port_count;
253         pj_strdup2(pool, &media->desc.transport, m_line->proto);
254         pj_strdup2(pool, &media->desc.media, m_line->type);
255
256         for (i = 0; i < ast_sdp_m_get_payload_count(m_line); ++i) {
257                 pj_strdup2(pool, &media->desc.fmt[i], ast_sdp_m_get_payload(m_line, i)->fmt);
258                 ++media->desc.fmt_count;
259         }
260         if (m_line->c_line && m_line->c_line->address) {
261                 copy_c_line_pjmedia(pool, &media->conn, m_line->c_line);
262         }
263         copy_a_lines_pjmedia_media(pool, media, m_line);
264 }
265
266 static void copy_m_lines_pjmedia(pj_pool_t *pool, pjmedia_sdp_session *pjmedia_sdp,
267         const struct ast_sdp *sdp)
268 {
269         int i;
270
271         for (i = 0; i < ast_sdp_get_m_count(sdp); ++i) {
272                 pjmedia_sdp_media *media;
273
274                 media = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_media);
275                 copy_m_line_pjmedia(pool, media, ast_sdp_get_m(sdp, i));
276                 pjmedia_sdp->media[pjmedia_sdp->media_count] = media;
277                 ++pjmedia_sdp->media_count;
278         }
279 }
280
281 static const void *sdp_to_pjmedia(const struct ast_sdp *sdp, void *translator_priv)
282 {
283         pj_pool_t *pool = translator_priv;
284         pjmedia_sdp_session *pjmedia_sdp;
285
286         pjmedia_sdp = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_session);
287         copy_o_line_pjmedia(pool, pjmedia_sdp, sdp->o_line);
288         copy_s_line_pjmedia(pool, pjmedia_sdp, sdp->s_line);
289         copy_t_line_pjmedia(pool, pjmedia_sdp, sdp->t_line);
290         copy_c_line_pjmedia(pool, &pjmedia_sdp->conn, sdp->c_line);
291         copy_a_lines_pjmedia(pool, pjmedia_sdp, sdp);
292         copy_m_lines_pjmedia(pool, pjmedia_sdp, sdp);
293         return pjmedia_sdp;
294 }
295
296 static struct ast_sdp_translator_ops pjmedia_translator = {
297         .repr = AST_SDP_IMPL_PJMEDIA,
298         .translator_new = pjmedia_new,
299         .translator_free = pjmedia_free,
300         .to_sdp = pjmedia_to_sdp,
301         .from_sdp = sdp_to_pjmedia,
302 };
303
304 #ifdef TEST_FRAMEWORK
305
306 static int verify_s_line(struct ast_sdp_s_line *s_line, char *expected)
307 {
308         return strcmp(s_line->session_name, expected) == 0;
309 }
310
311 static int verify_c_line(struct ast_sdp_c_line *c_line, char *family, char *addr)
312 {
313         return strcmp(c_line->address_type, family) == 0 && strcmp(c_line->address, addr) == 0;
314 }
315
316 static int verify_t_line(struct ast_sdp_t_line *t_line, uint32_t start, uint32_t end)
317 {
318         return t_line->start_time == start && t_line->stop_time == end;
319 }
320
321 static int verify_m_line(struct ast_sdp *sdp, int index, char *type, int port,
322         int port_count, char *profile, ...)
323 {
324         struct ast_sdp_m_line *m_line;
325         int res;
326         va_list ap;
327         int i;
328
329         m_line = ast_sdp_get_m(sdp, index);
330
331         res = strcmp(m_line->type, type) == 0;
332         res |= m_line->port == port;
333         res |= m_line->port_count == port_count;
334         res |= strcmp(m_line->proto, profile) == 0;
335
336         va_start(ap, profile);
337         for (i = 0; i < ast_sdp_m_get_payload_count(m_line); ++i) {
338                 char *payload;
339
340                 payload = va_arg(ap, char *);
341                 if (!payload) {
342                         res = -1;
343                         break;
344                 }
345                 res |= strcmp(ast_sdp_m_get_payload(m_line, i)->fmt, payload) == 0;
346         }
347         va_end(ap);
348         return res;
349 }
350
351 static int verify_a_line(struct ast_sdp *sdp, int m_index, int a_index, char *name,
352         char *value)
353 {
354         struct ast_sdp_m_line *m_line;
355         struct ast_sdp_a_line *a_line;
356
357         m_line = ast_sdp_get_m(sdp, m_index);
358         a_line = ast_sdp_m_get_a(m_line, a_index);
359
360         return strcmp(a_line->name, name) == 0 && strcmp(a_line->value, value) == 0;
361 }
362
363 AST_TEST_DEFINE(pjmedia_to_sdp_test)
364 {
365         struct ast_sdp_translator *translator;
366         pj_pool_t *pool;
367         char *sdp_str =
368       "v=0\r\n"
369       "o=alice 2890844526 2890844527 IN IP4 host.atlanta.example.com\r\n"
370       "s= \r\n"
371       "c=IN IP4 host.atlanta.example.com\r\n"
372       "t=123 456\r\n"
373       "m=audio 49170 RTP/AVP 0 8 97\r\n"
374       "a=rtpmap:0 PCMU/8000\r\n"
375       "a=rtpmap:8 PCMA/8000\r\n"
376       "a=rtpmap:97 iLBC/8000\r\n"
377           "a=sendrecv\r\n"
378       "m=video 51372 RTP/AVP 31 32\r\n"
379       "a=rtpmap:31 H261/90000\r\n"
380       "a=rtpmap:32 MPV/90000\r\n";
381         pjmedia_sdp_session *pjmedia_sdp;
382         struct ast_sdp *sdp = NULL;
383         pj_status_t status;
384         enum ast_test_result_state res = AST_TEST_PASS;
385
386         switch (cmd) {
387         case TEST_INIT:
388                 info->name = "pjmedia_to_sdp";
389                 info->category = "/main/sdp/";
390                 info->summary = "PJMEDIA to SDP unit test";
391                 info->description =
392                         "Ensures PJMEDIA SDPs are translated correctly";
393                 return AST_TEST_NOT_RUN;
394         case TEST_EXECUTE:
395                 break;
396         }
397
398         pool = pj_pool_create(&sdp_caching_pool.factory, "pjmedia to sdp test", 1024, 1024, NULL);
399
400         translator = ast_sdp_translator_new(AST_SDP_IMPL_PJMEDIA);
401         if (!translator) {
402                 ast_test_status_update(test, "Failed to create SDP translator\n");
403                 res = AST_TEST_FAIL;
404                 goto cleanup;
405         }
406
407         status = pjmedia_sdp_parse(pool, sdp_str, strlen(sdp_str), &pjmedia_sdp);
408         if (status != PJ_SUCCESS) {
409                 ast_test_status_update(test, "Error parsing SDP\n");
410                 res = AST_TEST_FAIL;
411                 goto cleanup;
412         }
413
414         sdp = ast_sdp_translator_to_sdp(translator, pjmedia_sdp);
415
416         if (strcmp(sdp->o_line->username, "alice")) {
417                 ast_test_status_update(test, "Unexpected SDP user '%s'\n", sdp->o_line->username);
418                 res = AST_TEST_FAIL;
419                 goto cleanup;
420         } else if (sdp->o_line->session_id != 2890844526UL) {
421                 ast_test_status_update(test, "Unexpected SDP id '%" PRId64 "lu'\n", sdp->o_line->session_id);
422                 res = AST_TEST_FAIL;
423                 goto cleanup;
424         } else if (sdp->o_line->session_version != 2890844527UL) {
425                 ast_test_status_update(test, "Unexpected SDP version '%" PRId64 "'\n", sdp->o_line->session_version);
426                 res = AST_TEST_FAIL;
427                 goto cleanup;
428         } else if (strcmp(sdp->o_line->address_type, "IP4")) {
429                 ast_test_status_update(test, "Unexpected address family '%s'\n", sdp->o_line->address_type);
430                 res = AST_TEST_FAIL;
431                 goto cleanup;
432         } else if (strcmp(sdp->o_line->address, "host.atlanta.example.com")) {
433                 ast_test_status_update(test, "Unexpected address '%s'\n", sdp->o_line->address);
434                 res = AST_TEST_FAIL;
435                 goto cleanup;
436         }
437
438         if (!verify_s_line(sdp->s_line, " ")) {
439                 ast_test_status_update(test, "Bad s line\n");
440                 res = AST_TEST_FAIL;
441                 goto cleanup;
442         } else if (!verify_c_line(sdp->c_line, "IP4", "host.atlanta.example.com")) {
443                 ast_test_status_update(test, "Bad c line\n");
444                 res = AST_TEST_FAIL;
445                 goto cleanup;
446         } else if (!verify_t_line(sdp->t_line, 123, 456)) {
447                 ast_test_status_update(test, "Bad t line\n");
448                 res = AST_TEST_FAIL;
449                 goto cleanup;
450         }
451
452         if (!verify_m_line(sdp, 0, "audio", 49170, 1, "RTP/AVP", "0", "8", "97", NULL)) {
453                 ast_test_status_update(test, "Bad m line 1\n");
454                 res = AST_TEST_FAIL;
455                 goto cleanup;
456         } else if (!verify_a_line(sdp, 0, 0, "rtpmap", "0 PCMU/8000")) {
457                 ast_test_status_update(test, "Bad a line 1\n");
458                 res = AST_TEST_FAIL;
459                 goto cleanup;
460         } else if (!verify_a_line(sdp, 0, 1, "rtpmap", "8 PCMA/8000")) {
461                 ast_test_status_update(test, "Bad a line 2\n");
462                 res = AST_TEST_FAIL;
463                 goto cleanup;
464         } else if (!verify_a_line(sdp, 0, 2, "rtpmap", "97 iLBC/8000")) {
465                 ast_test_status_update(test, "Bad a line 3\n");
466                 res = AST_TEST_FAIL;
467                 goto cleanup;
468         } else if (!verify_a_line(sdp, 0, 3, "sendrecv", "")) {
469                 ast_test_status_update(test, "Bad a line 3\n");
470                 res = AST_TEST_FAIL;
471                 goto cleanup;
472         } else if (!verify_m_line(sdp, 1, "video", 51372, 1, "RTP/AVP", "31", "32", NULL)) {
473                 ast_test_status_update(test, "Bad m line 2\n");
474                 res = AST_TEST_FAIL;
475                 goto cleanup;
476         } else if (!verify_a_line(sdp, 1, 0, "rtpmap", "31 H261/90000")) {
477                 ast_test_status_update(test, "Bad a line 4\n");
478                 res = AST_TEST_FAIL;
479                 goto cleanup;
480         } else if (!verify_a_line(sdp, 1, 1, "rtpmap", "32 MPV/90000")) {
481                 ast_test_status_update(test, "Bad a line 5\n");
482                 res = AST_TEST_FAIL;
483                 goto cleanup;
484         }
485
486 cleanup:
487         ast_sdp_free(sdp);
488         ast_sdp_translator_free(translator);
489         pj_pool_release(pool);
490         return res;
491 }
492
493 AST_TEST_DEFINE(sdp_to_pjmedia_test)
494 {
495         struct ast_sdp_translator *translator;
496         char *sdp_str =
497       "v=0\r\n"
498       "o=alice 2890844526 2890844526 IN IP4 host.atlanta.example.com\r\n"
499       "s= \r\n"
500       "c=IN IP4 host.atlanta.example.com\r\n"
501       "t=123 456\r\n"
502       "m=audio 49170 RTP/AVP 0 8 97\r\n"
503       "a=rtpmap:0 PCMU/8000\r\n"
504       "a=rtpmap:8 PCMA/8000\r\n"
505       "a=rtpmap:97 iLBC/8000\r\n"
506           "a=sendrecv\r\n"
507       "m=video 51372 RTP/AVP 31 32\r\n"
508       "a=rtpmap:31 H261/90000\r\n"
509       "a=rtpmap:32 MPV/90000\r\n\r\n";
510         pj_pool_t *pool;
511         pjmedia_sdp_session *pjmedia_sdp_orig;
512         const pjmedia_sdp_session *pjmedia_sdp_dup;
513         struct ast_sdp *sdp = NULL;
514         pj_status_t status;
515         enum ast_test_result_state res = AST_TEST_PASS;
516         char buf[2048];
517         char errbuf[256];
518
519         switch (cmd) {
520         case TEST_INIT:
521                 info->name = "sdp_to_pjmedia";
522                 info->category = "/main/sdp/";
523                 info->summary = "SDP to PJMEDIA unit test";
524                 info->description =
525                         "Ensures PJMEDIA SDPs are translated correctly";
526                 return AST_TEST_NOT_RUN;
527         case TEST_EXECUTE:
528                 break;
529         }
530
531         pool = pj_pool_create(&sdp_caching_pool.factory, "pjmedia to sdp test", 1024, 1024, NULL);
532
533         translator = ast_sdp_translator_new(AST_SDP_IMPL_PJMEDIA);
534         if (!translator) {
535                 ast_test_status_update(test, "Failed to create SDP translator\n");
536                 res = AST_TEST_FAIL;
537                 goto cleanup;
538         }
539
540         status = pjmedia_sdp_parse(pool, sdp_str, strlen(sdp_str), &pjmedia_sdp_orig);
541         if (status != PJ_SUCCESS) {
542                 ast_test_status_update(test, "Error parsing SDP\n");
543                 res = AST_TEST_FAIL;
544                 goto cleanup;
545         }
546
547         sdp = ast_sdp_translator_to_sdp(translator, pjmedia_sdp_orig);
548         pjmedia_sdp_dup = ast_sdp_translator_from_sdp(translator, sdp);
549
550         if ((status = pjmedia_sdp_session_cmp(pjmedia_sdp_orig, pjmedia_sdp_dup, 0)) != PJ_SUCCESS) {
551                 ast_test_status_update(test, "SDPs aren't equal\n");
552                 pjmedia_sdp_print(pjmedia_sdp_orig, buf, sizeof(buf));
553                 ast_test_status_update(test, "Original SDP is %s\n", buf);
554                 pjmedia_sdp_print(pjmedia_sdp_dup, buf, sizeof(buf));
555                 ast_test_status_update(test, "New SDP is %s\n", buf);
556                 pjmedia_strerror(status, errbuf, sizeof(errbuf));
557                 ast_test_status_update(test, "PJMEDIA says %d: '%s'\n", status, errbuf);
558                 res = AST_TEST_FAIL;
559                 goto cleanup;
560         }
561
562 cleanup:
563         ast_sdp_free(sdp);
564         ast_sdp_translator_free(translator);
565         pj_pool_release(pool);
566         return res;
567 }
568
569 #endif /* TEST_FRAMEWORK */
570
571 static int load_module(void)
572 {
573         if (ast_sdp_register_translator(&pjmedia_translator)) {
574                 return AST_MODULE_LOAD_DECLINE;
575         }
576         pj_caching_pool_init(&sdp_caching_pool, NULL, 1024 * 1024);
577         AST_TEST_REGISTER(pjmedia_to_sdp_test);
578         AST_TEST_REGISTER(sdp_to_pjmedia_test);
579
580         return AST_MODULE_LOAD_SUCCESS;
581 }
582
583 static int unload_module(void)
584 {
585         ast_sdp_unregister_translator(&pjmedia_translator);
586         pj_caching_pool_destroy(&sdp_caching_pool);
587         AST_TEST_UNREGISTER(pjmedia_to_sdp_test);
588         AST_TEST_REGISTER(sdp_to_pjmedia_test);
589         return 0;
590 }
591
592 static int reload_module(void)
593 {
594         return 0;
595 }
596
597 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJMEDIA SDP Translator",
598         .support_level = AST_MODULE_SUPPORT_CORE,
599         .load = load_module,
600         .unload = unload_module,
601         .reload = reload_module,
602         .load_pri = AST_MODPRI_CHANNEL_DEPEND,
603 );