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         ao2_cleanup(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         ao2_cleanup(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 );