channels/chan_motif.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2012, Digium, Inc.
   5  *
   6  * Joshua Colp <jcolp@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 /*! \file
  20  *
  21  * \author Joshua Colp <jcolp@digium.com>
  22  *
  23  * \brief Motif Jingle Channel Driver
  24  *
  25  * \extref Iksemel http://iksemel.jabberstudio.org/
  26  *
  27  * \ingroup channel_drivers
  28  */
  29
  30 /*** MODULEINFO
  31         <depend>iksemel</depend>
  32         <depend>res_xmpp</depend>
  33         <use type="external">openssl</use>
  34         <support_level>core</support_level>
  35  ***/
  36
  37 #include "asterisk.h"
  38
  39 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  40
  41 #include <sys/socket.h>
  42 #include <fcntl.h>
  43 #include <netdb.h>
  44 #include <netinet/in.h>
  45 #include <arpa/inet.h>
  46 #include <sys/signal.h>
  47 #include <iksemel.h>
  48 #include <pthread.h>
  49
  50 #include "asterisk/lock.h"
  51 #include "asterisk/channel.h"
  52 #include "asterisk/config_options.h"
  53 #include "asterisk/module.h"
  54 #include "asterisk/pbx.h"
  55 #include "asterisk/sched.h"
  56 #include "asterisk/io.h"
  57 #include "asterisk/rtp_engine.h"
  58 #include "asterisk/acl.h"
  59 #include "asterisk/callerid.h"
  60 #include "asterisk/file.h"
  61 #include "asterisk/cli.h"
  62 #include "asterisk/app.h"
  63 #include "asterisk/musiconhold.h"
  64 #include "asterisk/manager.h"
  65 #include "asterisk/stringfields.h"
  66 #include "asterisk/utils.h"
  67 #include "asterisk/causes.h"
  68 #include "asterisk/astobj.h"
  69 #include "asterisk/abstract_jb.h"
  70 #include "asterisk/xmpp.h"
  71
  72 /*! \brief Default maximum number of ICE candidates we will offer */
  73 #define DEFAULT_MAX_ICE_CANDIDATES "10"
  74
  75 /*! \brief Default maximum number of payloads we will offer */
  76 #define DEFAULT_MAX_PAYLOADS "30"
  77
  78 /*! \brief Number of buckets for endpoints */
  79 #define ENDPOINT_BUCKETS 37
  80
  81 /*! \brief Number of buckets for sessions, on a per-endpoint basis */
  82 #define SESSION_BUCKETS 37
  83
  84 /*! \brief Namespace for Jingle itself */
  85 #define JINGLE_NS "urn:xmpp:jingle:1"
  86
  87 /*! \brief Namespace for Jingle RTP sessions */
  88 #define JINGLE_RTP_NS "urn:xmpp:jingle:apps:rtp:1"
  89
  90 /*! \brief Namespace for Jingle RTP info */
  91 #define JINGLE_RTP_INFO_NS "urn:xmpp:jingle:apps:rtp:info:1"
  92
  93 /*! \brief Namespace for Jingle ICE-UDP */
  94 #define JINGLE_ICE_UDP_NS "urn:xmpp:jingle:transports:ice-udp:1"
  95
  96 /*! \brief Namespace for Google Talk ICE-UDP */
  97 #define GOOGLE_TRANSPORT_NS "http://www.google.com/transport/p2p"
  98
  99 /*! \brief Namespace for Google Talk Raw UDP */
 100 #define GOOGLE_TRANSPORT_RAW_NS "http://www.google.com/transport/raw-udp"
 101
 102 /*! \brief Namespace for Google Session */
 103 #define GOOGLE_SESSION_NS "http://www.google.com/session"
 104
 105 /*! \brief Namespace for Google Phone description */
 106 #define GOOGLE_PHONE_NS "http://www.google.com/session/phone"
 107
 108 /*! \brief Namespace for Google Video description */
 109 #define GOOGLE_VIDEO_NS "http://www.google.com/session/video"
 110
 111 /*! \brief Namespace for XMPP stanzas */
 112 #define XMPP_STANZAS_NS "urn:ietf:params:xml:ns:xmpp-stanzas"
 113
 114 /*! \brief The various transport methods supported, from highest priority to lowest priority when doing fallback */
 115 enum jingle_transport {
 116         JINGLE_TRANSPORT_ICE_UDP = 3,   /*!< XEP-0176 */
 117         JINGLE_TRANSPORT_GOOGLE_V2 = 2, /*!< https://developers.google.com/talk/call_signaling */
 118         JINGLE_TRANSPORT_GOOGLE_V1 = 1, /*!< Undocumented initial Google specification */
 119         JINGLE_TRANSPORT_NONE = 0,      /*!< No transport specified */
 120 };
 121
 122 /*! \brief Endpoint state information */
 123 struct jingle_endpoint_state {
 124         struct ao2_container *sessions; /*!< Active sessions to or from the endpoint */
 125 };
 126
 127 /*! \brief Endpoint which contains configuration information and active sessions */
 128 struct jingle_endpoint {
 129         AST_DECLARE_STRING_FIELDS(
 130                 AST_STRING_FIELD(name);              /*!< Name of the endpoint */
 131                 AST_STRING_FIELD(context);           /*!< Context to place incoming calls into */
 132                 AST_STRING_FIELD(accountcode);       /*!< Account code */
 133                 AST_STRING_FIELD(language);          /*!< Default language for prompts */
 134                 AST_STRING_FIELD(musicclass);        /*!< Configured music on hold class */
 135                 AST_STRING_FIELD(parkinglot);        /*!< Configured parking lot */
 136                 );
 137         struct ast_xmpp_client *connection;     /*!< Connection to use for traffic */
 138         iksrule *rule;                          /*!< Active matching rule */
 139         unsigned int maxicecandidates;          /*!< Maximum number of ICE candidates we will offer */
 140         unsigned int maxpayloads;               /*!< Maximum number of payloads we will offer */
 141         struct ast_codec_pref prefs;            /*!< Codec preferences */
 142         struct ast_format_cap *cap;             /*!< Formats to use */
 143         ast_group_t callgroup;                  /*!< Call group */
 144         ast_group_t pickupgroup;                /*!< Pickup group */
 145         enum jingle_transport transport;        /*!< Default transport to use on outgoing sessions */
 146         struct jingle_endpoint_state *state;    /*!< Endpoint state information */
 147 };
 148
 149 /*! \brief Session which contains information about an active session */
 150 struct jingle_session {
 151         AST_DECLARE_STRING_FIELDS(
 152                 AST_STRING_FIELD(sid);        /*!< Session identifier */
 153                 AST_STRING_FIELD(audio_name); /*!< Name of the audio content */
 154                 AST_STRING_FIELD(video_name); /*!< Name of the video content */
 155                 );
 156         struct jingle_endpoint_state *state;  /*!< Endpoint we are associated with */
 157         struct ast_xmpp_client *connection;   /*!< Connection to use for traffic */
 158         enum jingle_transport transport;      /*!< Transport type to use for this session */
 159         unsigned int maxicecandidates;        /*!< Maximum number of ICE candidates we will offer */
 160         unsigned int maxpayloads;             /*!< Maximum number of payloads we will offer */
 161         char remote_original[XMPP_MAX_JIDLEN];/*!< Identifier of the original remote party (remote may have changed due to redirect) */
 162         char remote[XMPP_MAX_JIDLEN];         /*!< Identifier of the remote party */
 163         iksrule *rule;                        /*!< Session matching rule */
 164         struct ast_codec_pref prefs;          /*!< Codec preferences */
 165         struct ast_channel *owner;            /*!< Master Channel */
 166         struct ast_rtp_instance *rtp;         /*!< RTP audio session */
 167         struct ast_rtp_instance *vrtp;        /*!< RTP video session */
 168         struct ast_format_cap *cap;           /*!< Local codec capabilities */
 169         struct ast_format_cap *jointcap;      /*!< Joint codec capabilities */
 170         struct ast_format_cap *peercap;       /*!< Peer codec capabilities */
 171         unsigned int outgoing:1;              /*!< Whether this is an outgoing leg or not */
 172         unsigned int gone:1;                  /*!< In the eyes of Jingle this session is already gone */
 173 };
 174
 175 static const char desc[] = "Motif Jingle Channel";
 176 static const char channel_type[] = "Motif";
 177
 178 struct jingle_config {
 179         struct ao2_container *endpoints; /*!< Configured endpoints */
 180 };
 181
 182 static AO2_GLOBAL_OBJ_STATIC(globals);
 183
 184 static struct ast_sched_context *sched; /*!< Scheduling context for RTCP */
 185
 186 /* \brief Asterisk core interaction functions */
 187 static struct ast_channel *jingle_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause);
 188 static int jingle_sendtext(struct ast_channel *ast, const char *text);
 189 static int jingle_digit_begin(struct ast_channel *ast, char digit);
 190 static int jingle_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
 191 static int jingle_call(struct ast_channel *ast, const char *dest, int timeout);
 192 static int jingle_hangup(struct ast_channel *ast);
 193 static int jingle_answer(struct ast_channel *ast);
 194 static struct ast_frame *jingle_read(struct ast_channel *ast);
 195 static int jingle_write(struct ast_channel *ast, struct ast_frame *f);
 196 static int jingle_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
 197 static int jingle_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
 198 static struct jingle_session *jingle_alloc(struct jingle_endpoint *endpoint, const char *from, const char *sid);
 199
 200 /*! \brief Action handlers */
 201 static void jingle_action_session_initiate(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak);
 202 static void jingle_action_transport_info(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak);
 203 static void jingle_action_session_accept(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak);
 204 static void jingle_action_session_info(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak);
 205 static void jingle_action_session_terminate(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak);
 206
 207 /*! \brief PBX interface structure for channel registration */
 208 static struct ast_channel_tech jingle_tech = {
 209         .type = "Motif",
 210         .description = "Motif Jingle Channel Driver",
 211         .requester = jingle_request,
 212         .send_text = jingle_sendtext,
 213         .send_digit_begin = jingle_digit_begin,
 214         .send_digit_end = jingle_digit_end,
 215         .bridge = ast_rtp_instance_bridge,
 216         .call = jingle_call,
 217         .hangup = jingle_hangup,
 218         .answer = jingle_answer,
 219         .read = jingle_read,
 220         .write = jingle_write,
 221         .write_video = jingle_write,
 222         .exception = jingle_read,
 223         .indicate = jingle_indicate,
 224         .fixup = jingle_fixup,
 225         .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER
 226 };
 227
 228 /*! \brief Defined handlers for different Jingle actions */
 229 static const struct jingle_action_handler {
 230         const char *action;
 231         void (*handler)(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak);
 232 } jingle_action_handlers[] = {
 233         /* Jingle actions */
 234         { "session-initiate", jingle_action_session_initiate, },
 235         { "transport-info", jingle_action_transport_info, },
 236         { "session-accept", jingle_action_session_accept, },
 237         { "session-info", jingle_action_session_info, },
 238         { "session-terminate", jingle_action_session_terminate, },
 239         /* Google-V1 actions */
 240         { "initiate", jingle_action_session_initiate, },
 241         { "candidates", jingle_action_transport_info, },
 242         { "accept", jingle_action_session_accept, },
 243         { "terminate", jingle_action_session_terminate, },
 244         { "reject", jingle_action_session_terminate, },
 245 };
 246
 247 /*! \brief Reason text <-> cause code mapping */
 248 static const struct jingle_reason_mapping {
 249         const char *reason;
 250         int cause;
 251 } jingle_reason_mappings[] = {
 252         { "busy", AST_CAUSE_BUSY, },
 253         { "cancel", AST_CAUSE_CALL_REJECTED, },
 254         { "connectivity-error", AST_CAUSE_INTERWORKING, },
 255         { "decline", AST_CAUSE_CALL_REJECTED, },
 256         { "expired", AST_CAUSE_NO_USER_RESPONSE, },
 257         { "failed-transport", AST_CAUSE_PROTOCOL_ERROR, },
 258         { "failed-application", AST_CAUSE_SWITCH_CONGESTION, },
 259         { "general-error", AST_CAUSE_CONGESTION, },
 260         { "gone", AST_CAUSE_NORMAL_CLEARING, },
 261         { "incompatible-parameters", AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, },
 262         { "media-error", AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, },
 263         { "security-error", AST_CAUSE_PROTOCOL_ERROR, },
 264         { "success", AST_CAUSE_NORMAL_CLEARING, },
 265         { "timeout", AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE, },
 266         { "unsupported-applications", AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, },
 267         { "unsupported-transports", AST_CAUSE_FACILITY_NOT_IMPLEMENTED, },
 268 };
 269
 270 /*! \brief Hashing function for Jingle sessions */
 271 static int jingle_session_hash(const void *obj, const int flags)
 272 {
 273         const struct jingle_session *session = obj;
 274         const char *sid = obj;
 275
 276         return ast_str_hash(flags & OBJ_KEY ? sid : session->sid);
 277 }
 278
 279 /*! \brief Comparator function for Jingle sessions */
 280 static int jingle_session_cmp(void *obj, void *arg, int flags)
 281 {
 282         struct jingle_session *session1 = obj, *session2 = arg;
 283         const char *sid = arg;
 284
 285         return !strcmp(session1->sid, flags & OBJ_KEY ? sid : session2->sid) ? CMP_MATCH | CMP_STOP : 0;
 286 }
 287
 288 /*! \brief Destructor for Jingle endpoint state */
 289 static void jingle_endpoint_state_destructor(void *obj)
 290 {
 291         struct jingle_endpoint_state *state = obj;
 292
 293         ao2_ref(state->sessions, -1);
 294 }
 295
 296 /*! \brief Destructor for Jingle endpoints */
 297 static void jingle_endpoint_destructor(void *obj)
 298 {
 299         struct jingle_endpoint *endpoint = obj;
 300
 301         if (endpoint->rule) {
 302                 iks_filter_remove_rule(endpoint->connection->filter, endpoint->rule);
 303         }
 304
 305         if (endpoint->connection) {
 306                 ast_xmpp_client_unref(endpoint->connection);
 307         }
 308
 309         ast_format_cap_destroy(endpoint->cap);
 310
 311         ao2_ref(endpoint->state, -1);
 312
 313         ast_string_field_free_memory(endpoint);
 314 }
 315
 316 /*! \brief Find function for Jingle endpoints */
 317 static void *jingle_endpoint_find(struct ao2_container *tmp_container, const char *category)
 318 {
 319         return ao2_find(tmp_container, category, OBJ_KEY);
 320 }
 321
 322 /*! \brief Allocator function for Jingle endpoint state */
 323 static struct jingle_endpoint_state *jingle_endpoint_state_create(void)
 324 {
 325         struct jingle_endpoint_state *state;
 326
 327         if (!(state = ao2_alloc(sizeof(*state), jingle_endpoint_state_destructor))) {
 328                 return NULL;
 329         }
 330
 331         if (!(state->sessions = ao2_container_alloc(SESSION_BUCKETS, jingle_session_hash, jingle_session_cmp))) {
 332                 ao2_ref(state, -1);
 333                 return NULL;
 334         }
 335
 336         return state;
 337 }
 338
 339 /*! \brief State find/create function */
 340 static struct jingle_endpoint_state *jingle_endpoint_state_find_or_create(const char *category)
 341 {
 342         RAII_VAR(struct jingle_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
 343         RAII_VAR(struct jingle_endpoint *, endpoint, NULL, ao2_cleanup);
 344
 345         if (!cfg || !cfg->endpoints || !(endpoint = jingle_endpoint_find(cfg->endpoints, category))) {
 346                 return jingle_endpoint_state_create();
 347         }
 348
 349         ao2_ref(endpoint->state, +1);
 350         return endpoint->state;
 351 }
 352
 353 /*! \brief Allocator function for Jingle endpoints */
 354 static void *jingle_endpoint_alloc(const char *cat)
 355 {
 356         struct jingle_endpoint *endpoint;
 357
 358         if (!(endpoint = ao2_alloc(sizeof(*endpoint), jingle_endpoint_destructor))) {
 359                 return NULL;
 360         }
 361
 362         if (ast_string_field_init(endpoint, 512)) {
 363                 ao2_ref(endpoint, -1);
 364                 return NULL;
 365         }
 366
 367         if (!(endpoint->state = jingle_endpoint_state_find_or_create(cat))) {
 368                 ao2_ref(endpoint, -1);
 369                 return NULL;
 370         }
 371
 372         ast_string_field_set(endpoint, name, cat);
 373
 374         endpoint->cap = ast_format_cap_alloc_nolock();
 375         endpoint->transport = JINGLE_TRANSPORT_ICE_UDP;
 376
 377         return endpoint;
 378 }
 379
 380 /*! \brief Hashing function for Jingle endpoints */
 381 static int jingle_endpoint_hash(const void *obj, const int flags)
 382 {
 383         const struct jingle_endpoint *endpoint = obj;
 384         const char *name = obj;
 385
 386         return ast_str_hash(flags & OBJ_KEY ? name : endpoint->name);
 387 }
 388
 389 /*! \brief Comparator function for Jingle endpoints */
 390 static int jingle_endpoint_cmp(void *obj, void *arg, int flags)
 391 {
 392         struct jingle_endpoint *endpoint1 = obj, *endpoint2 = arg;
 393         const char *name = arg;
 394
 395         return !strcmp(endpoint1->name, flags & OBJ_KEY ? name : endpoint2->name) ? CMP_MATCH | CMP_STOP : 0;
 396 }
 397
 398 static struct aco_type endpoint_option = {
 399         .type = ACO_ITEM,
 400         .category_match = ACO_BLACKLIST,
 401         .category = "^general$",
 402         .item_alloc = jingle_endpoint_alloc,
 403         .item_find = jingle_endpoint_find,
 404         .item_offset = offsetof(struct jingle_config, endpoints),
 405 };
 406
 407 struct aco_type *endpoint_options[] = ACO_TYPES(&endpoint_option);
 408
 409 struct aco_file jingle_conf = {
 410         .filename = "motif.conf",
 411         .types = ACO_TYPES(&endpoint_option),
 412 };
 413
 414 /*! \brief Destructor for Jingle sessions */
 415 static void jingle_session_destructor(void *obj)
 416 {
 417         struct jingle_session *session = obj;
 418
 419         if (session->rule) {
 420                 iks_filter_remove_rule(session->connection->filter, session->rule);
 421         }
 422
 423         if (session->connection) {
 424                 ast_xmpp_client_unref(session->connection);
 425         }
 426
 427         if (session->rtp) {
 428                 ast_rtp_instance_destroy(session->rtp);
 429         }
 430
 431         if (session->vrtp) {
 432                 ast_rtp_instance_destroy(session->vrtp);
 433         }
 434
 435         ast_format_cap_destroy(session->cap);
 436         ast_format_cap_destroy(session->jointcap);
 437         ast_format_cap_destroy(session->peercap);
 438
 439         ast_string_field_free_memory(session);
 440 }
 441
 442 /*! \brief Destructor called when module configuration goes away */
 443 static void jingle_config_destructor(void *obj)
 444 {
 445         struct jingle_config *cfg = obj;
 446         ao2_cleanup(cfg->endpoints);
 447 }
 448
 449 /*! \brief Allocator called when module configuration should appear */
 450 static void *jingle_config_alloc(void)
 451 {
 452         struct jingle_config *cfg;
 453
 454         if (!(cfg = ao2_alloc(sizeof(*cfg), jingle_config_destructor))) {
 455                 return NULL;
 456         }
 457
 458         if (!(cfg->endpoints = ao2_container_alloc(ENDPOINT_BUCKETS, jingle_endpoint_hash, jingle_endpoint_cmp))) {
 459                 ao2_ref(cfg, -1);
 460                 return NULL;
 461         }
 462
 463         return cfg;
 464 }
 465
 466 CONFIG_INFO_STANDARD(cfg_info, globals, jingle_config_alloc,
 467                      .files = ACO_FILES(&jingle_conf),
 468         );
 469
 470 /*! \brief Function called by RTP engine to get local RTP peer */
 471 static enum ast_rtp_glue_result jingle_get_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
 472 {
 473         struct jingle_session *session = ast_channel_tech_pvt(chan);
 474         enum ast_rtp_glue_result res = AST_RTP_GLUE_RESULT_LOCAL;
 475
 476         if (!session->rtp) {
 477                 return AST_RTP_GLUE_RESULT_FORBID;
 478         }
 479
 480         ao2_ref(session->rtp, +1);
 481         *instance = session->rtp;
 482
 483         return res;
 484 }
 485
 486 /*! \brief Function called by RTP engine to get peer capabilities */
 487 static void jingle_get_codec(struct ast_channel *chan, struct ast_format_cap *result)
 488 {
 489 }
 490
 491 /*! \brief Function called by RTP engine to change where the remote party should send media */
 492 static int jingle_set_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance *rtp, struct ast_rtp_instance *vrtp, struct ast_rtp_instance *tpeer, const struct ast_format_cap *cap, int nat_active)
 493 {
 494         return -1;
 495 }
 496
 497 /*! \brief Local glue for interacting with the RTP engine core */
 498 static struct ast_rtp_glue jingle_rtp_glue = {
 499         .type = "Motif",
 500         .get_rtp_info = jingle_get_rtp_peer,
 501         .get_codec = jingle_get_codec,
 502         .update_peer = jingle_set_rtp_peer,
 503 };
 504
 505 /*! \brief Internal helper function which enables video support on a sesson if possible */
 506 static void jingle_enable_video(struct jingle_session *session)
 507 {
 508         struct ast_sockaddr tmp;
 509         struct ast_rtp_engine_ice *ice;
 510
 511         /* If video is already present don't do anything */
 512         if (session->vrtp) {
 513                 return;
 514         }
 515
 516         /* If there are no configured video codecs do not turn video support on, it just won't work */
 517         if (!ast_format_cap_has_type(session->cap, AST_FORMAT_TYPE_VIDEO)) {
 518                 return;
 519         }
 520
 521         ast_sockaddr_parse(&tmp, "0.0.0.0", 0);
 522
 523         if (!(session->vrtp = ast_rtp_instance_new("asterisk", sched, &tmp, NULL))) {
 524                 return;
 525         }
 526
 527         ast_rtp_instance_set_prop(session->vrtp, AST_RTP_PROPERTY_RTCP, 1);
 528
 529         ast_channel_set_fd(session->owner, 2, ast_rtp_instance_fd(session->vrtp, 0));
 530         ast_channel_set_fd(session->owner, 3, ast_rtp_instance_fd(session->vrtp, 1));
 531         ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(session->vrtp), session->vrtp, &session->prefs);
 532
 533         if (session->transport == JINGLE_TRANSPORT_GOOGLE_V2 && (ice = ast_rtp_instance_get_ice(session->vrtp))) {
 534                 ice->stop(session->vrtp);
 535         }
 536 }
 537
 538 /*! \brief Internal helper function used to allocate Jingle session on an endpoint */
 539 static struct jingle_session *jingle_alloc(struct jingle_endpoint *endpoint, const char *from, const char *sid)
 540 {
 541         struct jingle_session *session;
 542         struct ast_sockaddr tmp;
 543
 544         if (!(session = ao2_alloc(sizeof(*session), jingle_session_destructor))) {
 545                 return NULL;
 546         }
 547
 548         if (ast_string_field_init(session, 512)) {
 549                 ao2_ref(session, -1);
 550                 return NULL;
 551         }
 552
 553         if (!ast_strlen_zero(from)) {
 554                 ast_copy_string(session->remote_original, from, sizeof(session->remote_original));
 555                 ast_copy_string(session->remote, from, sizeof(session->remote));
 556         }
 557
 558         if (ast_strlen_zero(sid)) {
 559                 ast_string_field_build(session, sid, "%08lx%08lx", ast_random(), ast_random());
 560                 session->outgoing = 1;
 561                 ast_string_field_set(session, audio_name, "audio");
 562                 ast_string_field_set(session, video_name, "video");
 563         } else {
 564                 ast_string_field_set(session, sid, sid);
 565         }
 566
 567         ao2_ref(endpoint->state, +1);
 568         session->state = endpoint->state;
 569         ao2_ref(endpoint->connection, +1);
 570         session->connection = endpoint->connection;
 571         session->transport = endpoint->transport;
 572
 573         if (!(session->cap = ast_format_cap_alloc_nolock()) ||
 574             !(session->jointcap = ast_format_cap_alloc_nolock()) ||
 575             !(session->peercap = ast_format_cap_alloc_nolock())) {
 576                 ao2_ref(session, -1);
 577                 return NULL;
 578         }
 579
 580         ast_format_cap_copy(session->cap, endpoint->cap);
 581
 582         /* While we rely on res_xmpp for communication we still need a temporary ast_sockaddr to tell the RTP engine
 583          * that we want IPv4 */
 584         ast_sockaddr_parse(&tmp, "0.0.0.0", 0);
 585
 586         /* Sessions always carry audio, but video is optional so don't enable it here */
 587         if (!(session->rtp = ast_rtp_instance_new("asterisk", sched, &tmp, NULL))) {
 588                 ao2_ref(session, -1);
 589                 return NULL;
 590         }
 591         ast_rtp_instance_set_prop(session->rtp, AST_RTP_PROPERTY_RTCP, 1);
 592         ast_rtp_instance_set_prop(session->rtp, AST_RTP_PROPERTY_DTMF, 1);
 593
 594         memcpy(&session->prefs, &endpoint->prefs, sizeof(session->prefs));
 595
 596         session->maxicecandidates = endpoint->maxicecandidates;
 597         session->maxpayloads = endpoint->maxpayloads;
 598
 599         return session;
 600 }
 601
 602 /*! \brief Function called to create a new Jingle Asterisk channel */
 603 static struct ast_channel *jingle_new(struct jingle_endpoint *endpoint, struct jingle_session *session, int state, const char *title, const char *linkedid, const char *cid_name)
 604 {
 605         struct ast_channel *chan;
 606         const char *str = S_OR(title, session->remote);
 607         struct ast_format tmpfmt;
 608
 609         if (ast_format_cap_is_empty(session->cap)) {
 610                 return NULL;
 611         }
 612
 613         if (!(chan = ast_channel_alloc(1, state, S_OR(title, ""), S_OR(cid_name, ""), "", "", "", linkedid, 0, "Motif/%s-%04lx", str, ast_random() & 0xffff))) {
 614                 return NULL;
 615         }
 616
 617         ast_channel_tech_set(chan, &jingle_tech);
 618         ast_channel_tech_pvt_set(chan, session);
 619         session->owner = chan;
 620
 621         ast_format_cap_copy(ast_channel_nativeformats(chan), session->cap);
 622         ast_codec_choose(&session->prefs, session->cap, 1, &tmpfmt);
 623
 624         if (session->rtp) {
 625                 struct ast_rtp_engine_ice *ice;
 626
 627                 ast_channel_set_fd(chan, 0, ast_rtp_instance_fd(session->rtp, 0));
 628                 ast_channel_set_fd(chan, 1, ast_rtp_instance_fd(session->rtp, 1));
 629                 ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(session->rtp), session->rtp, &session->prefs);
 630
 631                 if (((session->transport == JINGLE_TRANSPORT_GOOGLE_V2) ||
 632                      (session->transport == JINGLE_TRANSPORT_GOOGLE_V1)) &&
 633                     (ice = ast_rtp_instance_get_ice(session->rtp))) {
 634                         /* We stop built in ICE support because we need to fall back to old old old STUN support */
 635                         ice->stop(session->rtp);
 636                 }
 637         }
 638
 639         if (state == AST_STATE_RING) {
 640                 ast_channel_rings_set(chan, 1);
 641         }
 642
 643         ast_channel_adsicpe_set(chan, AST_ADSI_UNAVAILABLE);
 644
 645         ast_best_codec(ast_channel_nativeformats(chan), &tmpfmt);
 646         ast_format_copy(ast_channel_writeformat(chan), &tmpfmt);
 647         ast_format_copy(ast_channel_rawwriteformat(chan), &tmpfmt);
 648         ast_format_copy(ast_channel_readformat(chan), &tmpfmt);
 649         ast_format_copy(ast_channel_rawreadformat(chan), &tmpfmt);
 650
 651         ao2_lock(endpoint);
 652
 653         ast_channel_callgroup_set(chan, endpoint->callgroup);
 654         ast_channel_pickupgroup_set(chan, endpoint->pickupgroup);
 655
 656         if (!ast_strlen_zero(endpoint->accountcode)) {
 657                 ast_channel_accountcode_set(chan, endpoint->accountcode);
 658         }
 659
 660         if (!ast_strlen_zero(endpoint->language)) {
 661                 ast_channel_language_set(chan, endpoint->language);
 662         }
 663
 664         if (!ast_strlen_zero(endpoint->musicclass)) {
 665                 ast_channel_musicclass_set(chan, endpoint->musicclass);
 666         }
 667
 668         ast_channel_context_set(chan, endpoint->context);
 669         ast_channel_exten_set(chan, "s");
 670         ast_channel_priority_set(chan, 1);
 671
 672         ao2_unlock(endpoint);
 673
 674         return chan;
 675 }
 676
 677 /*! \brief Internal helper function which sends a response */
 678 static void jingle_send_response(struct ast_xmpp_client *connection, ikspak *pak)
 679 {
 680         iks *response;
 681
 682         if (!(response = iks_new("iq"))) {
 683                 ast_log(LOG_ERROR, "Unable to allocate an IKS response stanza\n");
 684                 return;
 685         }
 686
 687         iks_insert_attrib(response, "type", "result");
 688         iks_insert_attrib(response, "from", connection->jid->full);
 689         iks_insert_attrib(response, "to", iks_find_attrib(pak->x, "from"));
 690         iks_insert_attrib(response, "id", iks_find_attrib(pak->x, "id"));
 691
 692         ast_xmpp_client_send(connection, response);
 693
 694         iks_delete(response);
 695 }
 696
 697 /*! \brief Internal helper function which sends an error response */
 698 static void jingle_send_error_response(struct ast_xmpp_client *connection, ikspak *pak, const char *type, const char *reasonstr, const char *reasonstr2)
 699 {
 700         iks *response, *error = NULL, *reason = NULL, *reason2 = NULL;
 701
 702         if (!(response = iks_new("iq")) ||
 703             !(error = iks_new("error")) ||
 704             !(reason = iks_new(reasonstr))) {
 705                 ast_log(LOG_ERROR, "Unable to allocate IKS error response stanzas\n");
 706                 goto end;
 707         }
 708
 709         iks_insert_attrib(response, "type", "error");
 710         iks_insert_attrib(response, "from", connection->jid->full);
 711         iks_insert_attrib(response, "to", iks_find_attrib(pak->x, "from"));
 712         iks_insert_attrib(response, "id", iks_find_attrib(pak->x, "id"));
 713
 714         iks_insert_attrib(error, "type", type);
 715         iks_insert_node(error, reason);
 716
 717         if (!ast_strlen_zero(reasonstr2) && (reason2 = iks_new(reasonstr2))) {
 718                 iks_insert_node(error, reason2);
 719         }
 720
 721         iks_insert_node(response, error);
 722
 723         ast_xmpp_client_send(connection, response);
 724 end:
 725         iks_delete(reason2);
 726         iks_delete(reason);
 727         iks_delete(error);
 728         iks_delete(response);
 729 }
 730
 731 /*! \brief Internal helper function which adds ICE-UDP candidates to a transport node */
 732 static int jingle_add_ice_udp_candidates_to_transport(struct ast_rtp_instance *rtp, iks *transport, iks **candidates, unsigned int maximum)
 733 {
 734         struct ast_rtp_engine_ice *ice;
 735         struct ao2_container *local_candidates;
 736         struct ao2_iterator it;
 737         struct ast_rtp_engine_ice_candidate *candidate;
 738         int i = 0, res = 0;
 739
 740         if (!(ice = ast_rtp_instance_get_ice(rtp)) || !(local_candidates = ice->get_local_candidates(rtp))) {
 741                 ast_log(LOG_ERROR, "Unable to add ICE-UDP candidates as ICE support not available or no candidates available\n");
 742                 return -1;
 743         }
 744
 745         iks_insert_attrib(transport, "xmlns", JINGLE_ICE_UDP_NS);
 746         iks_insert_attrib(transport, "pwd", ice->get_password(rtp));
 747         iks_insert_attrib(transport, "ufrag", ice->get_ufrag(rtp));
 748
 749         it = ao2_iterator_init(local_candidates, 0);
 750
 751         while ((candidate = ao2_iterator_next(&it)) && (i < maximum)) {
 752                 iks *local_candidate;
 753                 char tmp[30];
 754
 755                 if (!(local_candidate = iks_new("candidate"))) {
 756                         res = -1;
 757                         ast_log(LOG_ERROR, "Unable to allocate IKS candidate stanza for ICE-UDP transport\n");
 758                         break;
 759                 }
 760
 761                 snprintf(tmp, sizeof(tmp), "%d", candidate->id);
 762                 iks_insert_attrib(local_candidate, "component", tmp);
 763                 snprintf(tmp, sizeof(tmp), "%d", ast_str_hash(candidate->foundation));
 764                 iks_insert_attrib(local_candidate, "foundation", tmp);
 765                 iks_insert_attrib(local_candidate, "generation", "0");
 766                 snprintf(tmp, sizeof(tmp), "%04lx", ast_random() & 0xffff);
 767                 iks_insert_attrib(local_candidate, "id", tmp);
 768                 iks_insert_attrib(local_candidate, "ip", ast_sockaddr_stringify_host(&candidate->address));
 769                 iks_insert_attrib(local_candidate, "port", ast_sockaddr_stringify_port(&candidate->address));
 770                 snprintf(tmp, sizeof(tmp), "%d", candidate->priority);
 771                 iks_insert_attrib(local_candidate, "priority", tmp);
 772                 iks_insert_attrib(local_candidate, "protocol", "udp");
 773
 774                 if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_HOST) {
 775                         iks_insert_attrib(local_candidate, "type", "host");
 776                 } else if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_SRFLX) {
 777                         iks_insert_attrib(local_candidate, "type", "srflx");
 778                 } else if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_RELAYED) {
 779                         iks_insert_attrib(local_candidate, "type", "relay");
 780                 }
 781
 782                 iks_insert_node(transport, local_candidate);
 783                 candidates[i++] = local_candidate;
 784         }
 785
 786         ao2_iterator_destroy(&it);
 787         ao2_ref(local_candidates, -1);
 788
 789         return res;
 790 }
 791
 792 /*! \brief Internal helper function which adds Google candidates to a transport node */
 793 static int jingle_add_google_candidates_to_transport(struct ast_rtp_instance *rtp, iks *transport, iks **candidates, unsigned int video, enum jingle_transport transport_type, unsigned int maximum)
 794 {
 795         struct ast_rtp_engine_ice *ice;
 796         struct ao2_container *local_candidates;
 797         struct ao2_iterator it;
 798         struct ast_rtp_engine_ice_candidate *candidate;
 799         int i = 0, res = 0;
 800
 801         if (!(ice = ast_rtp_instance_get_ice(rtp)) || !(local_candidates = ice->get_local_candidates(rtp))) {
 802                 ast_log(LOG_ERROR, "Unable to add Google ICE candidates as ICE support not available or no candidates available\n");
 803                 return -1;
 804         }
 805
 806         if (transport_type != JINGLE_TRANSPORT_GOOGLE_V1) {
 807                 iks_insert_attrib(transport, "xmlns", GOOGLE_TRANSPORT_NS);
 808         }
 809
 810         it = ao2_iterator_init(local_candidates, 0);
 811
 812         while ((candidate = ao2_iterator_next(&it)) && (i < maximum)) {
 813                 iks *local_candidate;
 814                 /* In Google land a username is 16 bytes, explicitly */
 815                 char ufrag[17] = "";
 816
 817                 if (!(local_candidate = iks_new("candidate"))) {
 818                         res = -1;
 819                         ast_log(LOG_ERROR, "Unable to allocate IKS candidate stanza for Google ICE transport\n");
 820                         break;
 821                 }
 822
 823                 /* We only support RTP candidates */
 824                 if (candidate->id != 1) {
 825                         continue;
 826                 }
 827
 828                 iks_insert_attrib(local_candidate, "name", !video ? "rtp" : "video_rtp");
 829                 iks_insert_attrib(local_candidate, "address", ast_sockaddr_stringify_host(&candidate->address));
 830                 iks_insert_attrib(local_candidate, "port", ast_sockaddr_stringify_port(&candidate->address));
 831
 832                 if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_HOST) {
 833                         iks_insert_attrib(local_candidate, "preference", "0.95");
 834                         iks_insert_attrib(local_candidate, "type", "local");
 835                 } else if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_SRFLX) {
 836                         iks_insert_attrib(local_candidate, "preference", "0.9");
 837                         iks_insert_attrib(local_candidate, "type", "stun");
 838                 }
 839
 840                 iks_insert_attrib(local_candidate, "protocol", "udp");
 841                 iks_insert_attrib(local_candidate, "network", "0");
 842                 snprintf(ufrag, sizeof(ufrag), "%s", ice->get_ufrag(rtp));
 843                 iks_insert_attrib(local_candidate, "username", ufrag);
 844                 iks_insert_attrib(local_candidate, "generation", "0");
 845
 846                 if (transport_type == JINGLE_TRANSPORT_GOOGLE_V1) {
 847                         iks_insert_attrib(local_candidate, "password", "");
 848                         iks_insert_attrib(local_candidate, "foundation", "0");
 849                         iks_insert_attrib(local_candidate, "component", "1");
 850                 } else {
 851                         iks_insert_attrib(local_candidate, "password", ice->get_password(rtp));
 852                 }
 853
 854                 /* You may notice a lack of relay support up above - this is because we don't support it for use with
 855                  * the Google talk transport due to their arcane support. */
 856
 857                 iks_insert_node(transport, local_candidate);
 858                 candidates[i++] = local_candidate;
 859         }
 860
 861         ao2_iterator_destroy(&it);
 862         ao2_ref(local_candidates, -1);
 863
 864         return res;
 865 }
 866
 867 /*! \brief Internal function which sends a session-terminate message */
 868 static void jingle_send_session_terminate(struct jingle_session *session, const char *reasontext)
 869 {
 870         iks *iq = NULL, *jingle = NULL, *reason = NULL, *text = NULL;
 871
 872         if (!(iq = iks_new("iq")) || !(jingle = iks_new(session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "session" : "jingle")) ||
 873             !(reason = iks_new("reason")) || !(text = iks_new(reasontext))) {
 874                 ast_log(LOG_ERROR, "Failed to allocate stanzas for session-terminate message on session '%s'\n", session->sid);
 875                 goto end;
 876         }
 877
 878         iks_insert_attrib(iq, "to", session->remote);
 879         iks_insert_attrib(iq, "type", "set");
 880         iks_insert_attrib(iq, "id", session->connection->mid);
 881         ast_xmpp_increment_mid(session->connection->mid);
 882
 883         if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
 884                 iks_insert_attrib(jingle, "type", "terminate");
 885                 iks_insert_attrib(jingle, "id", session->sid);
 886                 iks_insert_attrib(jingle, "xmlns", GOOGLE_SESSION_NS);
 887                 iks_insert_attrib(jingle, "initiator", session->outgoing ? session->connection->jid->full : session->remote);
 888         } else {
 889                 iks_insert_attrib(jingle, "action", "session-terminate");
 890                 iks_insert_attrib(jingle, "sid", session->sid);
 891                 iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
 892         }
 893
 894         iks_insert_node(iq, jingle);
 895         iks_insert_node(jingle, reason);
 896         iks_insert_node(reason, text);
 897
 898         ast_xmpp_client_send(session->connection, iq);
 899
 900 end:
 901         iks_delete(text);
 902         iks_delete(reason);
 903         iks_delete(jingle);
 904         iks_delete(iq);
 905 }
 906
 907 /*! \brief Internal function which sends a session-info message */
 908 static void jingle_send_session_info(struct jingle_session *session, const char *info)
 909 {
 910         iks *iq = NULL, *jingle = NULL, *text = NULL;
 911
 912         /* Google-V1 has no way to send informational messages so don't even bother trying */
 913         if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
 914                 return;
 915         }
 916
 917         if (!(iq = iks_new("iq")) || !(jingle = iks_new("jingle")) || !(text = iks_new(info))) {
 918                 ast_log(LOG_ERROR, "Failed to allocate stanzas for session-info message on session '%s'\n", session->sid);
 919                 goto end;
 920         }
 921
 922         iks_insert_attrib(iq, "to", session->remote);
 923         iks_insert_attrib(iq, "type", "set");
 924         iks_insert_attrib(iq, "id", session->connection->mid);
 925         ast_xmpp_increment_mid(session->connection->mid);
 926
 927         iks_insert_attrib(jingle, "action", "session-info");
 928         iks_insert_attrib(jingle, "sid", session->sid);
 929         iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
 930         iks_insert_node(iq, jingle);
 931         iks_insert_node(jingle, text);
 932
 933         ast_xmpp_client_send(session->connection, iq);
 934
 935 end:
 936         iks_delete(text);
 937         iks_delete(jingle);
 938         iks_delete(iq);
 939 }
 940
 941 /*! \internal
 942  *
 943  * \brief Locks both pvt and pvt owner if owner is present.
 944  *
 945  * \note This function gives a ref to pvt->owner if it is present and locked.
 946  *       This reference must be decremented after pvt->owner is unlocked.
 947  *
 948  * \note This function will never give you up,
 949  * \note This function will never let you down.
 950  * \note This function will run around and desert you.
 951  *
 952  * \pre pvt is not locked
 953  * \post pvt is locked
 954  * \post pvt->owner is locked and its reference count is increased (if pvt->owner is not NULL)
 955  *
 956  * \returns a pointer to the locked and reffed pvt->owner channel if it exists.
 957  */
 958 static struct ast_channel *jingle_session_lock_full(struct jingle_session *pvt)
 959 {
 960         struct ast_channel *chan;
 961
 962         /* Locking is simple when it is done right.  If you see a deadlock resulting
 963          * in this function, it is not this function's fault, Your problem exists elsewhere.
 964          * This function is perfect... seriously. */
 965         for (;;) {
 966                 /* First, get the channel and grab a reference to it */
 967                 ao2_lock(pvt);
 968                 chan = pvt->owner;
 969                 if (chan) {
 970                         /* The channel can not go away while we hold the pvt lock.
 971                          * Give the channel a ref so it will not go away after we let
 972                          * the pvt lock go. */
 973                         ast_channel_ref(chan);
 974                 } else {
 975                         /* no channel, return pvt locked */
 976                         return NULL;
 977                 }
 978
 979                 /* We had to hold the pvt lock while getting a ref to the owner channel
 980                  * but now we have to let this lock go in order to preserve proper
 981                  * locking order when grabbing the channel lock */
 982                 ao2_unlock(pvt);
 983
 984                 /* Look, no deadlock avoidance, hooray! */
 985                 ast_channel_lock(chan);
 986                 ao2_lock(pvt);
 987                 if (pvt->owner == chan) {
 988                         /* done */
 989                         break;
 990                 }
 991
 992                 /* If the owner changed while everything was unlocked, no problem,
 993                  * just start over and everthing will work.  This is rare, do not be
 994                  * confused by this loop and think this it is an expensive operation.
 995                  * The majority of the calls to this function will never involve multiple
 996                  * executions of this loop. */
 997                 ast_channel_unlock(chan);
 998                 ast_channel_unref(chan);
 999                 ao2_unlock(pvt);
1000         }
1001
1002         /* If owner exists, it is locked and reffed */
1003         return pvt->owner;
1004 }
1005
1006 /*! \brief Helper function which queues a hangup frame with cause code */
1007 static void jingle_queue_hangup_with_cause(struct jingle_session *session, int cause)
1008 {
1009         struct ast_channel *chan;
1010
1011         if ((chan = jingle_session_lock_full(session))) {
1012                 ast_debug(3, "Hanging up channel '%s' with cause '%d'\n", ast_channel_name(chan), cause);
1013                 ast_queue_hangup_with_cause(chan, cause);
1014                 ast_channel_unlock(chan);
1015                 ast_channel_unref(chan);
1016         }
1017         ao2_unlock(session);
1018 }
1019
1020 /*! \brief Internal function which sends a transport-info message */
1021 static void jingle_send_transport_info(struct jingle_session *session, const char *from)
1022 {
1023         iks *iq, *jingle = NULL, *audio = NULL, *audio_transport = NULL, *video = NULL, *video_transport = NULL;
1024         iks *audio_candidates[session->maxicecandidates], *video_candidates[session->maxicecandidates];
1025         int i, res = 0;
1026
1027         if (!(iq = iks_new("iq")) ||
1028             !(jingle = iks_new(session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "session" : "jingle"))) {
1029                 iks_delete(iq);
1030                 jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
1031                 ast_log(LOG_ERROR, "Failed to allocate stanzas for transport-info message, hanging up session '%s'\n", session->sid);
1032                 return;
1033         }
1034
1035         memset(audio_candidates, 0, sizeof(audio_candidates));
1036         memset(video_candidates, 0, sizeof(video_candidates));
1037
1038         iks_insert_attrib(iq, "from", session->connection->jid->full);
1039         iks_insert_attrib(iq, "to", from);
1040         iks_insert_attrib(iq, "type", "set");
1041         iks_insert_attrib(iq, "id", session->connection->mid);
1042         ast_xmpp_increment_mid(session->connection->mid);
1043
1044         if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
1045                 iks_insert_attrib(jingle, "type", "candidates");
1046                 iks_insert_attrib(jingle, "id", session->sid);
1047                 iks_insert_attrib(jingle, "xmlns", GOOGLE_SESSION_NS);
1048                 iks_insert_attrib(jingle, "initiator", session->outgoing ? session->connection->jid->full : from);
1049         } else {
1050                 iks_insert_attrib(jingle, "action", "transport-info");
1051                 iks_insert_attrib(jingle, "sid", session->sid);
1052                 iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
1053         }
1054         iks_insert_node(iq, jingle);
1055
1056         if (session->rtp) {
1057                 if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
1058                         /* V1 protocol has the candidates directly in the session */
1059                         res = jingle_add_google_candidates_to_transport(session->rtp, jingle, audio_candidates, 0, session->transport, session->maxicecandidates);
1060                 } else if ((audio = iks_new("content")) && (audio_transport = iks_new("transport"))) {
1061                         iks_insert_attrib(audio, "creator", session->outgoing ? "initiator" : "responder");
1062                         iks_insert_attrib(audio, "name", session->audio_name);
1063                         iks_insert_node(jingle, audio);
1064                         iks_insert_node(audio, audio_transport);
1065
1066                         if (session->transport == JINGLE_TRANSPORT_ICE_UDP) {
1067                                 res = jingle_add_ice_udp_candidates_to_transport(session->rtp, audio_transport, audio_candidates, session->maxicecandidates);
1068                         } else if (session->transport == JINGLE_TRANSPORT_GOOGLE_V2) {
1069                                 res = jingle_add_google_candidates_to_transport(session->rtp, audio_transport, audio_candidates, 0, session->transport,
1070                                                                                 session->maxicecandidates);
1071                         }
1072                 } else {
1073                         res = -1;
1074                 }
1075         }
1076
1077         if ((session->transport != JINGLE_TRANSPORT_GOOGLE_V1) && !res && session->vrtp) {
1078                 if ((video = iks_new("content")) && (video_transport = iks_new("transport"))) {
1079                         iks_insert_attrib(video, "creator", session->outgoing ? "initiator" : "responder");
1080                         iks_insert_attrib(video, "name", session->video_name);
1081                         iks_insert_node(jingle, video);
1082                         iks_insert_node(video, video_transport);
1083
1084                         if (session->transport == JINGLE_TRANSPORT_ICE_UDP) {
1085                                 res = jingle_add_ice_udp_candidates_to_transport(session->vrtp, video_transport, video_candidates, session->maxicecandidates);
1086                         } else if (session->transport == JINGLE_TRANSPORT_GOOGLE_V2) {
1087                                 res = jingle_add_google_candidates_to_transport(session->vrtp, video_transport, video_candidates, 1, session->transport,
1088                                                                                 session->maxicecandidates);
1089                         }
1090                 } else {
1091                         res = -1;
1092                 }
1093         }
1094
1095         if (!res) {
1096                 ast_xmpp_client_send(session->connection, iq);
1097         } else {
1098                 jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
1099         }
1100
1101         /* Clean up after ourselves */
1102         for (i = 0; i < session->maxicecandidates; i++) {
1103                 iks_delete(video_candidates[i]);
1104                 iks_delete(audio_candidates[i]);
1105         }
1106
1107         iks_delete(video_transport);
1108         iks_delete(video);
1109         iks_delete(audio_transport);
1110         iks_delete(audio);
1111         iks_delete(jingle);
1112         iks_delete(iq);
1113 }
1114
1115 /*! \brief Internal helper function which adds payloads to a description */
1116 static int jingle_add_payloads_to_description(struct jingle_session *session, struct ast_rtp_instance *rtp, iks *description, iks **payloads, enum ast_format_type type)
1117 {
1118         struct ast_format format;
1119         int i = 0, res = 0;
1120
1121         ast_format_cap_iter_start(session->jointcap);
1122         while (!(ast_format_cap_iter_next(session->jointcap, &format)) && (i < (session->maxpayloads - 2))) {
1123                 int rtp_code;
1124                 iks *payload;
1125                 char tmp[32];
1126
1127                 if (AST_FORMAT_GET_TYPE(format.id) != type) {
1128                         continue;
1129                 }
1130
1131                 if (((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(rtp), 1, &format, 0)) == -1) ||
1132                     (!(payload = iks_new("payload-type")))) {
1133                         res = -1;
1134                         goto end;
1135                 }
1136
1137                 if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
1138                         iks_insert_attrib(payload, "xmlns", GOOGLE_PHONE_NS);
1139                 }
1140
1141                 snprintf(tmp, sizeof(tmp), "%d", rtp_code);
1142                 iks_insert_attrib(payload, "id", tmp);
1143                 iks_insert_attrib(payload, "name", ast_rtp_lookup_mime_subtype2(1, &format, 0, 0));
1144                 iks_insert_attrib(payload, "channels", "1");
1145
1146                 if ((format.id == AST_FORMAT_G722) && ((session->transport == JINGLE_TRANSPORT_GOOGLE_V1) || (session->transport == JINGLE_TRANSPORT_GOOGLE_V2))) {
1147                         iks_insert_attrib(payload, "clockrate", "16000");
1148                 } else {
1149                         snprintf(tmp, sizeof(tmp), "%d", ast_rtp_lookup_sample_rate2(1, &format, 0));
1150                         iks_insert_attrib(payload, "clockrate", tmp);
1151                 }
1152
1153                 iks_insert_node(description, payload);
1154                 payloads[i++] = payload;
1155         }
1156         /* If this is for audio and there is room for RFC2833 add it in */
1157         if ((type == AST_FORMAT_TYPE_AUDIO) && (i < session->maxpayloads)) {
1158                 iks *payload;
1159
1160                 if ((payload = iks_new("payload-type"))) {
1161                         if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
1162                                 iks_insert_attrib(payload, "xmlns", GOOGLE_PHONE_NS);
1163                         }
1164
1165                         iks_insert_attrib(payload, "id", "101");
1166                         iks_insert_attrib(payload, "name", "telephone-event");
1167                         iks_insert_attrib(payload, "channels", "1");
1168                         iks_insert_attrib(payload, "clockrate", "8000");
1169                         iks_insert_node(description, payload);
1170                         payloads[i++] = payload;
1171                 }
1172         }
1173
1174 end:
1175         ast_format_cap_iter_end(session->jointcap);
1176
1177         return res;
1178 }
1179
1180 /*! \brief Helper function which adds content to a description */
1181 static int jingle_add_content(struct jingle_session *session, iks *jingle, iks *content, iks *description, iks *transport,
1182                               const char *name, enum ast_format_type type, struct ast_rtp_instance *rtp, iks **payloads)
1183 {
1184         int res = 0;
1185
1186         if (session->transport != JINGLE_TRANSPORT_GOOGLE_V1) {
1187                 iks_insert_attrib(content, "creator", session->outgoing ? "initiator" : "responder");
1188                 iks_insert_attrib(content, "name", name);
1189                 iks_insert_node(jingle, content);
1190
1191                 iks_insert_attrib(description, "xmlns", JINGLE_RTP_NS);
1192                 if (type == AST_FORMAT_TYPE_AUDIO) {
1193                         iks_insert_attrib(description, "media", "audio");
1194                 } else if (type == AST_FORMAT_TYPE_VIDEO) {
1195                         iks_insert_attrib(description, "media", "video");
1196                 } else {
1197                         return -1;
1198                 }
1199                 iks_insert_node(content, description);
1200         } else {
1201                 iks_insert_attrib(description, "xmlns", GOOGLE_PHONE_NS);
1202                 iks_insert_node(jingle, description);
1203         }
1204
1205         if (!(res = jingle_add_payloads_to_description(session, rtp, description, payloads, type))) {
1206                 if (session->transport == JINGLE_TRANSPORT_ICE_UDP) {
1207                         iks_insert_attrib(transport, "xmlns", JINGLE_ICE_UDP_NS);
1208                         iks_insert_node(content, transport);
1209                 } else if (session->transport == JINGLE_TRANSPORT_GOOGLE_V2) {
1210                         iks_insert_attrib(transport, "xmlns", GOOGLE_TRANSPORT_NS);
1211                         iks_insert_node(content, transport);
1212                 }
1213         }
1214
1215         return res;
1216 }
1217
1218 /*! \brief Internal function which sends a complete session message */
1219 static void jingle_send_session_action(struct jingle_session *session, const char *action)
1220 {
1221         iks *iq, *jingle, *audio = NULL, *audio_description = NULL, *video = NULL, *video_description = NULL;
1222         iks *audio_payloads[session->maxpayloads], *video_payloads[session->maxpayloads];
1223         iks *audio_transport = NULL, *video_transport = NULL;
1224         int i, res = 0;
1225
1226         if (!(iq = iks_new("iq")) ||
1227             !(jingle = iks_new(session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "session" : "jingle"))) {
1228                 jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
1229                 iks_delete(iq);
1230                 return;
1231         }
1232
1233         memset(audio_payloads, 0, sizeof(audio_payloads));
1234         memset(video_payloads, 0, sizeof(video_payloads));
1235
1236         iks_insert_attrib(iq, "from", session->connection->jid->full);
1237         iks_insert_attrib(iq, "to", session->remote);
1238         iks_insert_attrib(iq, "type", "set");
1239         iks_insert_attrib(iq, "id", session->connection->mid);
1240         ast_xmpp_increment_mid(session->connection->mid);
1241
1242         if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
1243                 iks_insert_attrib(jingle, "type", action);
1244                 iks_insert_attrib(jingle, "id", session->sid);
1245                 iks_insert_attrib(jingle, "xmlns", GOOGLE_SESSION_NS);
1246         } else {
1247                 iks_insert_attrib(jingle, "action", action);
1248                 iks_insert_attrib(jingle, "sid", session->sid);
1249                 iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
1250         }
1251
1252         if (!strcasecmp(action, "session-initiate") || !strcasecmp(action, "initiate") || !strcasecmp(action, "accept")) {
1253                 iks_insert_attrib(jingle, "initiator", session->outgoing ? session->connection->jid->full : session->remote);
1254         }
1255
1256         iks_insert_node(iq, jingle);
1257
1258         if (session->rtp && (audio = iks_new("content")) && (audio_description = iks_new("description")) &&
1259             (audio_transport = iks_new("transport"))) {
1260                 res = jingle_add_content(session, jingle, audio, audio_description, audio_transport, session->audio_name,
1261                                          AST_FORMAT_TYPE_AUDIO, session->rtp, audio_payloads);
1262         } else {
1263                 ast_log(LOG_ERROR, "Failed to allocate audio content stanzas for session '%s', hanging up\n", session->sid);
1264                 res = -1;
1265         }
1266
1267         if ((session->transport != JINGLE_TRANSPORT_GOOGLE_V1) && !res && session->vrtp) {
1268                 if ((video = iks_new("content")) && (video_description = iks_new("description")) &&
1269                     (video_transport = iks_new("transport"))) {
1270                         res = jingle_add_content(session, jingle, video, video_description, video_transport, session->video_name,
1271                                                  AST_FORMAT_TYPE_VIDEO, session->vrtp, video_payloads);
1272                 } else {
1273                         ast_log(LOG_ERROR, "Failed to allocate video content stanzas for session '%s', hanging up\n", session->sid);
1274                         res = -1;
1275                 }
1276         }
1277
1278         if (!res) {
1279                 ast_xmpp_client_send(session->connection, iq);
1280         } else {
1281                 jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
1282         }
1283
1284         iks_delete(video_transport);
1285         iks_delete(audio_transport);
1286
1287         for (i = 0; i < session->maxpayloads; i++) {
1288                 iks_delete(video_payloads[i]);
1289                 iks_delete(audio_payloads[i]);
1290         }
1291
1292         iks_delete(video_description);
1293         iks_delete(video);
1294         iks_delete(audio_description);
1295         iks_delete(audio);
1296         iks_delete(jingle);
1297         iks_delete(iq);
1298 }
1299
1300 /*! \brief Internal function which sends a session-inititate message */
1301 static void jingle_send_session_initiate(struct jingle_session *session)
1302 {
1303         jingle_send_session_action(session, session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "initiate" : "session-initiate");
1304 }
1305
1306 /*! \brief Internal function which sends a session-accept message */
1307 static void jingle_send_session_accept(struct jingle_session *session)
1308 {
1309         jingle_send_session_action(session, session->transport == JINGLE_TRANSPORT_GOOGLE_V1 ? "accept" : "session-accept");
1310 }
1311
1312 /*! \brief Callback for when a response is received for an outgoing session-initiate message */
1313 static int jingle_outgoing_hook(void *data, ikspak *pak)
1314 {
1315         struct jingle_session *session = data;
1316         iks *error = iks_find(pak->x, "error"), *redirect;
1317
1318         /* In all cases this hook is done with */
1319         iks_filter_remove_rule(session->connection->filter, session->rule);
1320         session->rule = NULL;
1321
1322         /* If no error occurred they accepted our session-initiate message happily */
1323         if (!error) {
1324                 struct ast_channel *chan;
1325
1326                 if ((chan = jingle_session_lock_full(session))) {
1327                         ast_queue_control(chan, AST_CONTROL_PROCEEDING);
1328                         ast_channel_unlock(chan);
1329                         ast_channel_unref(chan);
1330                 }
1331                 ao2_unlock(session);
1332
1333                 jingle_send_transport_info(session, iks_find_attrib(pak->x, "from"));
1334                 return IKS_FILTER_EAT;
1335         }
1336
1337         /* Assume that because this is an error the session is gone, there is only one case where this is incorrect - a redirect */
1338         session->gone = 1;
1339
1340         /* Map the error we received to an appropriate cause code and hang up the channel */
1341         if ((redirect = iks_find_with_attrib(error, "redirect", "xmlns", XMPP_STANZAS_NS))) {
1342                 iks *to = iks_child(redirect);
1343                 char *target;
1344
1345                 if (to && (target = iks_name(to)) && !ast_strlen_zero(target)) {
1346                         /* Make the xmpp: go away if it is present */
1347                         if (!strncmp(target, "xmpp:", 5)) {
1348                                 target += 5;
1349                         }
1350
1351                         /* This is actually a fairly simple operation - we update the remote and send another session-initiate */
1352                         ast_copy_string(session->remote, target, sizeof(session->remote));
1353
1354                         /* Add a new hook so we can get the status of redirected session */
1355                         session->rule = iks_filter_add_rule(session->connection->filter, jingle_outgoing_hook, session,
1356                                                             IKS_RULE_ID, session->connection->mid, IKS_RULE_DONE);
1357
1358                         jingle_send_session_initiate(session);
1359
1360                         session->gone = 0;
1361                 } else {
1362                         jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
1363                 }
1364         } else if (iks_find_with_attrib(error, "service-unavailable", "xmlns", XMPP_STANZAS_NS)) {
1365                 jingle_queue_hangup_with_cause(session, AST_CAUSE_CONGESTION);
1366         } else if (iks_find_with_attrib(error, "resource-constraint", "xmlns", XMPP_STANZAS_NS)) {
1367                 jingle_queue_hangup_with_cause(session, AST_CAUSE_REQUESTED_CHAN_UNAVAIL);
1368         } else if (iks_find_with_attrib(error, "bad-request", "xmlns", XMPP_STANZAS_NS)) {
1369                 jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
1370         } else if (iks_find_with_attrib(error, "remote-server-not-found", "xmlns", XMPP_STANZAS_NS)) {
1371                 jingle_queue_hangup_with_cause(session, AST_CAUSE_NO_ROUTE_DESTINATION);
1372         } else if (iks_find_with_attrib(error, "feature-not-implemented", "xmlns", XMPP_STANZAS_NS)) {
1373                 /* Assume that this occurred because the remote side does not support our transport, so drop it down one and try again */
1374                 session->transport--;
1375
1376                 /* If we still have a viable transport mechanism re-send the session-initiate */
1377                 if (session->transport != JINGLE_TRANSPORT_NONE) {
1378                         struct ast_rtp_engine_ice *ice;
1379
1380                         if (((session->transport == JINGLE_TRANSPORT_GOOGLE_V2) ||
1381                              (session->transport == JINGLE_TRANSPORT_GOOGLE_V1)) &&
1382                             (ice = ast_rtp_instance_get_ice(session->rtp))) {
1383                                 /* We stop built in ICE support because we need to fall back to old old old STUN support */
1384                                 ice->stop(session->rtp);
1385                         }
1386
1387                         /* Re-send the message to the *original* target and not a redirected one */
1388                         ast_copy_string(session->remote, session->remote_original, sizeof(session->remote));
1389
1390                         session->rule = iks_filter_add_rule(session->connection->filter, jingle_outgoing_hook, session,
1391                                                             IKS_RULE_ID, session->connection->mid, IKS_RULE_DONE);
1392
1393                         jingle_send_session_initiate(session);
1394
1395                         session->gone = 0;
1396                 } else {
1397                         /* Otherwise we have exhausted all transports */
1398                         jingle_queue_hangup_with_cause(session, AST_CAUSE_FACILITY_NOT_IMPLEMENTED);
1399                 }
1400         } else {
1401                 jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
1402         }
1403
1404         return IKS_FILTER_EAT;
1405 }
1406
1407 /*! \brief Function called by core when we should answer a Jingle session */
1408 static int jingle_answer(struct ast_channel *ast)
1409 {
1410         struct jingle_session *session = ast_channel_tech_pvt(ast);
1411
1412         /* The channel has already been answered so we don't need to do anything */
1413         if (ast_channel_state(ast) == AST_STATE_UP) {
1414                 return 0;
1415         }
1416
1417         jingle_send_session_accept(session);
1418
1419         return 0;
1420 }
1421
1422 /*! \brief Function called by core to read any waiting frames */
1423 static struct ast_frame *jingle_read(struct ast_channel *ast)
1424 {
1425         struct jingle_session *session = ast_channel_tech_pvt(ast);
1426         struct ast_frame *frame = &ast_null_frame;
1427
1428         switch (ast_channel_fdno(ast)) {
1429         case 0:
1430                 if (session->rtp) {
1431                         frame = ast_rtp_instance_read(session->rtp, 0);
1432                 }
1433                 break;
1434         case 1:
1435                 if (session->rtp) {
1436                         frame = ast_rtp_instance_read(session->rtp, 1);
1437                 }
1438                 break;
1439         case 2:
1440                 if (session->vrtp) {
1441                         frame = ast_rtp_instance_read(session->vrtp, 0);
1442                 }
1443                 break;
1444         case 3:
1445                 if (session->vrtp) {
1446                         frame = ast_rtp_instance_read(session->vrtp, 1);
1447                 }
1448                 break;
1449         default:
1450                 break;
1451         }
1452
1453         if (frame && frame->frametype == AST_FRAME_VOICE &&
1454             !ast_format_cap_iscompatible(ast_channel_nativeformats(ast), &frame->subclass.format)) {
1455                 if (!ast_format_cap_iscompatible(session->jointcap, &frame->subclass.format)) {
1456                         ast_debug(1, "Bogus frame of format '%s' received from '%s'!\n",
1457                                   ast_getformatname(&frame->subclass.format), ast_channel_name(ast));
1458                         ast_frfree(frame);
1459                         frame = &ast_null_frame;
1460                 } else {
1461                         ast_debug(1, "Oooh, format changed to %s\n",
1462                                   ast_getformatname(&frame->subclass.format));
1463                         ast_format_cap_remove_bytype(ast_channel_nativeformats(ast), AST_FORMAT_TYPE_AUDIO);
1464                         ast_format_cap_add(ast_channel_nativeformats(ast), &frame->subclass.format);
1465                         ast_set_read_format(ast, ast_channel_readformat(ast));
1466                         ast_set_write_format(ast, ast_channel_writeformat(ast));
1467                 }
1468         }
1469
1470         return frame;
1471 }
1472
1473 /*! \brief Function called by core to write frames */
1474 static int jingle_write(struct ast_channel *ast, struct ast_frame *frame)
1475 {
1476         struct jingle_session *session = ast_channel_tech_pvt(ast);
1477         int res = 0;
1478         char buf[256];
1479
1480         switch (frame->frametype) {
1481         case AST_FRAME_VOICE:
1482                 if (!(ast_format_cap_iscompatible(ast_channel_nativeformats(ast), &frame->subclass.format))) {
1483                         ast_log(LOG_WARNING,
1484                                 "Asked to transmit frame type %s, while native formats is %s (read/write = %s/%s)\n",
1485                                 ast_getformatname(&frame->subclass.format),
1486                                 ast_getformatname_multiple(buf, sizeof(buf), ast_channel_nativeformats(ast)),
1487                                 ast_getformatname(ast_channel_readformat(ast)),
1488                                 ast_getformatname(ast_channel_writeformat(ast)));
1489                         return 0;
1490                 }
1491                 if (session && session->rtp) {
1492                         res = ast_rtp_instance_write(session->rtp, frame);
1493                 }
1494                 break;
1495         case AST_FRAME_VIDEO:
1496                 if (session && session->vrtp) {
1497                         res = ast_rtp_instance_write(session->vrtp, frame);
1498                 }
1499                 break;
1500         default:
1501                 ast_log(LOG_WARNING, "Can't send %d type frames with Jingle write\n",
1502                         frame->frametype);
1503                 return 0;
1504         }
1505
1506         return res;
1507 }
1508
1509 /*! \brief Function called by core to change the underlying owner channel */
1510 static int jingle_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1511 {
1512         struct jingle_session *session = ast_channel_tech_pvt(newchan);
1513
1514         ao2_lock(session);
1515
1516         session->owner = newchan;
1517
1518         ao2_unlock(session);
1519
1520         return 0;
1521 }
1522
1523 /*! \brief Function called by core to ask the channel to indicate some sort of condition */
1524 static int jingle_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
1525 {
1526         struct jingle_session *session = ast_channel_tech_pvt(ast);
1527         int res = 0;
1528
1529         switch (condition) {
1530         case AST_CONTROL_RINGING:
1531                 if (ast_channel_state(ast) == AST_STATE_RING) {
1532                         jingle_send_session_info(session, "ringing xmlns='urn:xmpp:jingle:apps:rtp:info:1'");
1533                 } else {
1534                         res = -1;
1535                 }
1536                 break;
1537         case AST_CONTROL_BUSY:
1538                 if (ast_channel_state(ast) != AST_STATE_UP) {
1539                         ast_channel_hangupcause_set(ast, AST_CAUSE_BUSY);
1540                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1541                 } else {
1542                         res = -1;
1543                 }
1544                 break;
1545         case AST_CONTROL_CONGESTION:
1546                 if (ast_channel_state(ast) != AST_STATE_UP) {
1547                         ast_channel_hangupcause_set(ast, AST_CAUSE_CONGESTION);
1548                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1549                 } else {
1550                         res = -1;
1551                 }
1552                 break;
1553         case AST_CONTROL_INCOMPLETE:
1554                 if (ast_channel_state(ast) != AST_STATE_UP) {
1555                         ast_channel_hangupcause_set(ast, AST_CAUSE_CONGESTION);
1556                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1557                 }
1558                 break;
1559         case AST_CONTROL_HOLD:
1560                 ast_moh_start(ast, data, NULL);
1561                 break;
1562         case AST_CONTROL_UNHOLD:
1563                 ast_moh_stop(ast);
1564                 break;
1565         case AST_CONTROL_SRCUPDATE:
1566                 if (session->rtp) {
1567                         ast_rtp_instance_update_source(session->rtp);
1568                 }
1569                 break;
1570         case AST_CONTROL_SRCCHANGE:
1571                 if (session->rtp) {
1572                         ast_rtp_instance_change_source(session->rtp);
1573                 }
1574                 break;
1575         case AST_CONTROL_VIDUPDATE:
1576         case AST_CONTROL_UPDATE_RTP_PEER:
1577         case AST_CONTROL_CONNECTED_LINE:
1578                 break;
1579         case AST_CONTROL_PVT_CAUSE_CODE:
1580         case -1:
1581                 res = -1;
1582                 break;
1583         default:
1584                 ast_log(LOG_NOTICE, "Don't know how to indicate condition '%d'\n", condition);
1585                 res = -1;
1586         }
1587
1588         return res;
1589 }
1590
1591 /*! \brief Function called by core to send text to the remote party of the Jingle session */
1592 static int jingle_sendtext(struct ast_channel *chan, const char *text)
1593 {
1594         struct jingle_session *session = ast_channel_tech_pvt(chan);
1595
1596         return ast_xmpp_client_send_message(session->connection, session->remote, text);
1597 }
1598
1599 /*! \brief Function called by core to start a DTMF digit */
1600 static int jingle_digit_begin(struct ast_channel *chan, char digit)
1601 {
1602         struct jingle_session *session = ast_channel_tech_pvt(chan);
1603
1604         if (session->rtp) {
1605                 ast_rtp_instance_dtmf_begin(session->rtp, digit);
1606         }
1607
1608         return 0;
1609 }
1610
1611 /*! \brief Function called by core to stop a DTMF digit */
1612 static int jingle_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
1613 {
1614         struct jingle_session *session = ast_channel_tech_pvt(ast);
1615
1616         if (session->rtp) {
1617                 ast_rtp_instance_dtmf_end_with_duration(session->rtp, digit, duration);
1618         }
1619
1620         return 0;
1621 }
1622
1623 /*! \brief Function called by core to actually start calling a remote party */
1624 static int jingle_call(struct ast_channel *ast, const char *dest, int timeout)
1625 {
1626         struct jingle_session *session = ast_channel_tech_pvt(ast);
1627
1628         ast_setstate(ast, AST_STATE_RING);
1629
1630         /* Since we have no idea of the remote capabilities use ours for now */
1631         ast_format_cap_copy(session->jointcap, session->cap);
1632
1633         /* We set up a hook so we can know when our session-initiate message was accepted or rejected */
1634         session->rule = iks_filter_add_rule(session->connection->filter, jingle_outgoing_hook, session,
1635                                             IKS_RULE_ID, session->connection->mid, IKS_RULE_DONE);
1636
1637         jingle_send_session_initiate(session);
1638
1639         return 0;
1640 }
1641
1642 /*! \brief Function called by core to hang up a Jingle session */
1643 static int jingle_hangup(struct ast_channel *ast)
1644 {
1645         struct jingle_session *session = ast_channel_tech_pvt(ast);
1646
1647         ao2_lock(session);
1648
1649         if ((ast_channel_state(ast) != AST_STATE_DOWN) && !session->gone) {
1650                 int cause = (session->owner ? ast_channel_hangupcause(session->owner) : AST_CAUSE_CONGESTION);
1651                 const char *reason = "success";
1652                 int i;
1653
1654                 /* Get the appropriate reason and send a session-terminate */
1655                 for (i = 0; i < ARRAY_LEN(jingle_reason_mappings); i++) {
1656                         if (jingle_reason_mappings[i].cause == cause) {
1657                                 reason = jingle_reason_mappings[i].reason;
1658                                 break;
1659                         }
1660                 }
1661
1662                 jingle_send_session_terminate(session, reason);
1663         }
1664
1665         ast_channel_tech_pvt_set(ast, NULL);
1666         session->owner = NULL;
1667
1668         ao2_unlink(session->state->sessions, session);
1669         ao2_ref(session->state, -1);
1670
1671         ao2_unlock(session);
1672         ao2_ref(session, -1);
1673
1674         return 0;
1675 }
1676
1677 /*! \brief Function called by core to create a new outgoing Jingle session */
1678 static struct ast_channel *jingle_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause)
1679 {
1680         RAII_VAR(struct jingle_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
1681         RAII_VAR(struct jingle_endpoint *, endpoint, NULL, ao2_cleanup);
1682         char *dialed, target[200] = "";
1683         struct ast_xmpp_buddy *buddy;
1684         struct jingle_session *session;
1685         struct ast_channel *chan;
1686         enum jingle_transport transport = JINGLE_TRANSPORT_NONE;
1687         AST_DECLARE_APP_ARGS(args,
1688                              AST_APP_ARG(name);
1689                              AST_APP_ARG(target);
1690                 );
1691
1692         /* We require at a minimum one audio format to be requested */
1693         if (!ast_format_cap_has_type(cap, AST_FORMAT_TYPE_AUDIO)) {
1694                 ast_log(LOG_ERROR, "Motif channel driver requires an audio format when dialing a destination\n");
1695                 *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
1696                 return NULL;
1697         }
1698
1699         if (ast_strlen_zero(data) || !(dialed = ast_strdupa(data))) {
1700                 ast_log(LOG_ERROR, "Unable to create channel with empty destination.\n");
1701                 *cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
1702                 return NULL;
1703         }
1704
1705         /* Parse the given dial string and validate the results */
1706         AST_NONSTANDARD_APP_ARGS(args, dialed, '/');
1707
1708         if (ast_strlen_zero(args.name) || ast_strlen_zero(args.target)) {
1709                 ast_log(LOG_ERROR, "Unable to determine endpoint name and target.\n");
1710                 *cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
1711                 return NULL;
1712         }
1713
1714         if (!(endpoint = jingle_endpoint_find(cfg->endpoints, args.name))) {
1715                 ast_log(LOG_ERROR, "Endpoint '%s' does not exist.\n", args.name);
1716                 *cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
1717                 return NULL;
1718         }
1719
1720         ao2_lock(endpoint->state);
1721
1722         /* If we don't have a connection for the endpoint we can't exactly start a session on it */
1723         if (!endpoint->connection) {
1724                 ast_log(LOG_ERROR, "Unable to create Jingle session on endpoint '%s' as no valid connection exists\n", args.name);
1725                 *cause = AST_CAUSE_SWITCH_CONGESTION;
1726                 ao2_unlock(endpoint->state);
1727                 return NULL;
1728         }
1729
1730         /* Find the target in the roster so we can choose a resource */
1731         if ((buddy = ao2_find(endpoint->connection->buddies, args.target, OBJ_KEY))) {
1732                 struct ao2_iterator res;
1733                 struct ast_xmpp_resource *resource;
1734
1735                 /* Iterate through finding the first viable Jingle capable resource */
1736                 res = ao2_iterator_init(buddy->resources, 0);
1737                 while ((resource = ao2_iterator_next(&res))) {
1738                         if (resource->caps.jingle) {
1739                                 snprintf(target, sizeof(target), "%s/%s", args.target, resource->resource);
1740                                 transport = JINGLE_TRANSPORT_ICE_UDP;
1741                                 break;
1742                         } else if (resource->caps.google) {
1743                                 snprintf(target, sizeof(target), "%s/%s", args.target, resource->resource);
1744                                 transport = JINGLE_TRANSPORT_GOOGLE_V2;
1745                                 break;
1746                         }
1747                         ao2_ref(resource, -1);
1748                 }
1749                 ao2_iterator_destroy(&res);
1750
1751                 ao2_ref(buddy, -1);
1752         } else {
1753                 /* If the target is NOT in the roster use the provided target as-is */
1754                 ast_copy_string(target, args.target, sizeof(target));
1755         }
1756
1757         ao2_unlock(endpoint->state);
1758
1759         /* If no target was found we can't set up a session */
1760         if (ast_strlen_zero(target)) {
1761                 ast_log(LOG_ERROR, "Unable to create Jingle session on endpoint '%s' as no capable resource for target '%s' was found\n", args.name, args.target);
1762                 *cause = AST_CAUSE_SWITCH_CONGESTION;
1763                 return NULL;
1764         }
1765
1766         if (!(session = jingle_alloc(endpoint, target, NULL))) {
1767                 ast_log(LOG_ERROR, "Unable to create Jingle session on endpoint '%s'\n", args.name);
1768                 *cause = AST_CAUSE_SWITCH_CONGESTION;
1769                 return NULL;
1770         }
1771
1772         /* Update the transport if we learned what we should actually use */
1773         if (transport != JINGLE_TRANSPORT_NONE) {
1774                 session->transport = transport;
1775                 /* Note that for Google-V1 and Google-V2 we don't stop built-in ICE support, this will happen in jingle_new */
1776         }
1777
1778         if (!(chan = jingle_new(endpoint, session, AST_STATE_DOWN, target, requestor ? ast_channel_linkedid(requestor) : NULL, NULL))) {
1779                 ast_log(LOG_ERROR, "Unable to create Jingle channel on endpoint '%s'\n", args.name);
1780                 *cause = AST_CAUSE_SWITCH_CONGESTION;
1781                 ao2_ref(session, -1);
1782                 return NULL;
1783         }
1784
1785         /* If video was requested try to enable it on the session */
1786         if (ast_format_cap_has_type(cap, AST_FORMAT_TYPE_VIDEO)) {
1787                 jingle_enable_video(session);
1788         }
1789
1790         /* We purposely don't decrement the session here as there is a reference on the channel */
1791         ao2_link(endpoint->state->sessions, session);
1792
1793         return chan;
1794 }
1795
1796 /*! \brief Helper function which handles content descriptions */
1797 static int jingle_interpret_description(struct jingle_session *session, iks *description, const char *name, struct ast_rtp_instance **rtp)
1798 {
1799         char *media = iks_find_attrib(description, "media");
1800         struct ast_rtp_codecs codecs;
1801         iks *codec;
1802         int othercapability = 0;
1803
1804         /* Google-V1 is always carrying audio, but just doesn't tell us so */
1805         if (session->transport == JINGLE_TRANSPORT_GOOGLE_V1) {
1806                 media = "audio";
1807         } else if (ast_strlen_zero(media)) {
1808                 jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
1809                 ast_log(LOG_ERROR, "Received a content description on session '%s' without a name\n", session->sid);
1810                 return -1;
1811         }
1812
1813         /* Determine the type of media that is being carried and update the RTP instance, as well as the name */
1814         if (!strcasecmp(media, "audio")) {
1815                 if (!ast_strlen_zero(name)) {
1816                         ast_string_field_set(session, audio_name, name);
1817                 }
1818                 *rtp = session->rtp;
1819                 ast_format_cap_remove_bytype(session->peercap, AST_FORMAT_TYPE_AUDIO);
1820                 ast_format_cap_remove_bytype(session->jointcap, AST_FORMAT_TYPE_AUDIO);
1821         } else if (!strcasecmp(media, "video")) {
1822                 if (!ast_strlen_zero(name)) {
1823                         ast_string_field_set(session, video_name, name);
1824                 }
1825
1826                 jingle_enable_video(session);
1827                 *rtp = session->vrtp;
1828
1829                 /* If video is not present cancel this session */
1830                 if (!session->vrtp) {
1831                         jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
1832                         ast_log(LOG_ERROR, "Received a video content description on session '%s' but could not enable video\n", session->sid);
1833                         return -1;
1834                 }
1835
1836                 ast_format_cap_remove_bytype(session->peercap, AST_FORMAT_TYPE_VIDEO);
1837                 ast_format_cap_remove_bytype(session->jointcap, AST_FORMAT_TYPE_VIDEO);
1838         } else {
1839                 /* Unknown media type */
1840                 jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
1841                 ast_log(LOG_ERROR, "Unsupported media type '%s' received in content description on session '%s'\n", media, session->sid);
1842                 return -1;
1843         }
1844
1845         ast_rtp_codecs_payloads_clear(&codecs, NULL);
1846
1847         /* Iterate the codecs updating the relevant RTP instance as we go */
1848         for (codec = iks_child(description); codec; codec = iks_next(codec)) {
1849                 char *id = iks_find_attrib(codec, "id"), *name = iks_find_attrib(codec, "name");
1850                 char *clockrate = iks_find_attrib(codec, "clockrate");
1851                 int rtp_id, rtp_clockrate;
1852
1853                 if (!ast_strlen_zero(id) && !ast_strlen_zero(name) && (sscanf(id, "%30d", &rtp_id) == 1)) {
1854                         ast_rtp_codecs_payloads_set_m_type(&codecs, NULL, rtp_id);
1855
1856                         if (!ast_strlen_zero(clockrate) && (sscanf(clockrate, "%30d", &rtp_clockrate) == 1)) {
1857                                 ast_rtp_codecs_payloads_set_rtpmap_type_rate(&codecs, NULL, rtp_id, media, name, 0, rtp_clockrate);
1858                         } else {
1859                                 ast_rtp_codecs_payloads_set_rtpmap_type(&codecs, NULL, rtp_id, media, name, 0);
1860                         }
1861                 }
1862         }
1863
1864         ast_rtp_codecs_payload_formats(&codecs, session->peercap, &othercapability);
1865         ast_format_cap_joint_append(session->cap, session->peercap, session->jointcap);
1866
1867         if (ast_format_cap_is_empty(session->jointcap)) {
1868                 /* We have no compatible codecs, so terminate the session appropriately */
1869                 jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
1870                 return -1;
1871         }
1872
1873         ast_rtp_codecs_payloads_copy(&codecs, ast_rtp_instance_get_codecs(*rtp), *rtp);
1874
1875         return 0;
1876 }
1877
1878 /*! \brief Helper function which handles ICE-UDP transport information */
1879 static int jingle_interpret_ice_udp_transport(struct jingle_session *session, iks *transport, struct ast_rtp_instance *rtp)
1880 {
1881         struct ast_rtp_engine_ice *ice = ast_rtp_instance_get_ice(rtp);
1882         char *ufrag = iks_find_attrib(transport, "ufrag"), *pwd = iks_find_attrib(transport, "pwd");
1883         iks *candidate;
1884
1885         if (!ice) {
1886                 jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
1887                 ast_log(LOG_ERROR, "Received ICE-UDP transport information on session '%s' but ICE support not available\n", session->sid);
1888                 return -1;
1889         }
1890
1891         if (ast_strlen_zero(ufrag) || ast_strlen_zero(pwd)) {
1892                 jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
1893                 ast_log(LOG_ERROR, "Invalid ICE-UDP transport information received on session '%s', ufrag or pwd not present\n", session->sid);
1894                 return -1;
1895         }
1896
1897         ice->set_authentication(rtp, ufrag, pwd);
1898
1899         for (candidate = iks_child(transport); candidate; candidate = iks_next(candidate)) {
1900                 char *component = iks_find_attrib(candidate, "component"), *foundation = iks_find_attrib(candidate, "foundation");
1901                 char *generation = iks_find_attrib(candidate, "generation"), *id = iks_find_attrib(candidate, "id");
1902                 char *ip = iks_find_attrib(candidate, "ip"), *network = iks_find_attrib(candidate, "network");
1903                 char *port = iks_find_attrib(candidate, "port"), *priority = iks_find_attrib(candidate, "priority");
1904                 char *protocol = iks_find_attrib(candidate, "protocol"), *type = iks_find_attrib(candidate, "type");
1905                 struct ast_rtp_engine_ice_candidate local_candidate = { 0, };
1906                 int real_port;
1907                 struct ast_sockaddr remote_address = { { 0, } };
1908
1909                 /* If this candidate is incomplete skip it */
1910                 if (ast_strlen_zero(component) || ast_strlen_zero(foundation) || ast_strlen_zero(generation) || ast_strlen_zero(id) ||
1911                     ast_strlen_zero(ip) || ast_strlen_zero(network) || ast_strlen_zero(port) || ast_strlen_zero(priority) ||
1912                     ast_strlen_zero(protocol) || ast_strlen_zero(type)) {
1913                         jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
1914                         ast_log(LOG_ERROR, "Incomplete ICE-UDP candidate received on session '%s'\n", session->sid);
1915                         return -1;
1916                 }
1917
1918                 if ((sscanf(component, "%30u", &local_candidate.id) != 1) ||
1919                     (sscanf(priority, "%30u", &local_candidate.priority) != 1) ||
1920                     (sscanf(port, "%30d", &real_port) != 1)) {
1921                         jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
1922                         ast_log(LOG_ERROR, "Invalid ICE-UDP candidate information received on session '%s'\n", session->sid);
1923                         return -1;
1924                 }
1925
1926                 local_candidate.foundation = foundation;
1927                 local_candidate.transport = protocol;
1928
1929                 ast_sockaddr_parse(&local_candidate.address, ip, PARSE_PORT_FORBID);
1930
1931                 /* We only support IPv4 right now */
1932                 if (!ast_sockaddr_is_ipv4(&local_candidate.address)) {
1933                         continue;
1934                 }
1935
1936                 ast_sockaddr_set_port(&local_candidate.address, real_port);
1937
1938                 if (!strcasecmp(type, "host")) {
1939                         local_candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_HOST;
1940                 } else if (!strcasecmp(type, "srflx")) {
1941                         local_candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_SRFLX;
1942                 } else if (!strcasecmp(type, "relay")) {
1943                         local_candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_RELAYED;
1944                 } else {
1945                         continue;
1946                 }
1947
1948                 /* Worst case use the first viable address */
1949                 ast_rtp_instance_get_remote_address(rtp, &remote_address);
1950
1951                 if (ast_sockaddr_is_ipv4(&local_candidate.address) && ast_sockaddr_isnull(&remote_address)) {
1952                         ast_rtp_instance_set_remote_address(rtp, &local_candidate.address);
1953                 }
1954
1955                 ice->add_remote_candidate(rtp, &local_candidate);
1956         }
1957
1958         ice->start(rtp);
1959
1960         return 0;
1961 }
1962
1963 /*! \brief Helper function which handles Google transport information */
1964 static int jingle_interpret_google_transport(struct jingle_session *session, iks *transport, struct ast_rtp_instance *rtp)
1965 {
1966         struct ast_rtp_engine_ice *ice = ast_rtp_instance_get_ice(rtp);
1967         iks *candidate;
1968
1969         if (!ice) {
1970                 jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
1971                 ast_log(LOG_ERROR, "Received Google transport information on session '%s' but ICE support not available\n", session->sid);
1972                 return -1;
1973         }
1974
1975         /* If this session has not transitioned to the Google transport do so now */
1976         if ((session->transport != JINGLE_TRANSPORT_GOOGLE_V2) &&
1977             (session->transport != JINGLE_TRANSPORT_GOOGLE_V1)) {
1978                 /* Stop built-in ICE support... we need to fall back to the old old old STUN */
1979                 ice->stop(rtp);
1980
1981                 session->transport = JINGLE_TRANSPORT_GOOGLE_V2;
1982         }
1983
1984         for (candidate = iks_child(transport); candidate; candidate = iks_next(candidate)) {
1985                 char *address = iks_find_attrib(candidate, "address"), *port = iks_find_attrib(candidate, "port");
1986                 char *username = iks_find_attrib(candidate, "username"), *name = iks_find_attrib(candidate, "name");
1987                 char *protocol = iks_find_attrib(candidate, "protocol");
1988                 int real_port;
1989                 struct ast_sockaddr target = { { 0, } };
1990                 /* In Google land the combined value is 32 bytes */
1991                 char combined[33] = "";
1992
1993                 /* If this is NOT actually a candidate just skip it */
1994                 if (strcasecmp(iks_name(candidate), "candidate") &&
1995                     strcasecmp(iks_name(candidate), "p:candidate") &&
1996                     strcasecmp(iks_name(candidate), "ses:candidate")) {
1997                         continue;
1998                 }
1999
2000                 /* If this candidate is incomplete skip it */
2001                 if (ast_strlen_zero(address) || ast_strlen_zero(port) || ast_strlen_zero(username) ||
2002                     ast_strlen_zero(name)) {
2003                         jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
2004                         ast_log(LOG_ERROR, "Incomplete Google candidate received on session '%s'\n", session->sid);
2005                         return -1;
2006                 }
2007
2008                 /* We only support UDP so skip any other protocols */
2009                 if (!ast_strlen_zero(protocol) && strcasecmp(protocol, "udp")) {
2010                         continue;
2011                 }
2012
2013                 /* Parse the target information so we can send a STUN request to the candidate */
2014                 if (sscanf(port, "%30d", &real_port) != 1) {
2015                         jingle_queue_hangup_with_cause(session, AST_CAUSE_PROTOCOL_ERROR);
2016                         ast_log(LOG_ERROR, "Invalid Google candidate port '%s' received on session '%s'\n", port, session->sid);
2017                         return -1;
2018                 }
2019                 ast_sockaddr_parse(&target, address, PARSE_PORT_FORBID);
2020                 ast_sockaddr_set_port(&target, real_port);
2021
2022                 /* Per the STUN support Google talk uses combine the two usernames */
2023                 snprintf(combined, sizeof(combined), "%s%s", username, ice->get_ufrag(rtp));
2024
2025                 /* This should appease the masses... we will actually change the remote address when we get their STUN packet */
2026                 ast_rtp_instance_stun_request(rtp, &target, combined);
2027         }
2028
2029         return 0;
2030 }
2031
2032 /*!
2033  * \brief Helper function which locates content stanzas and interprets them
2034  *
2035  * \note The session *must not* be locked before calling this
2036  */
2037 static int jingle_interpret_content(struct jingle_session *session, ikspak *pak)
2038 {
2039         iks *content;
2040         unsigned int changed = 0;
2041         struct ast_channel *chan;
2042
2043         /* Look at the content in the session initiation */
2044         for (content = iks_child(iks_child(pak->x)); content; content = iks_next(content)) {
2045                 char *name = iks_find_attrib(content, "name");
2046                 struct ast_rtp_instance *rtp = NULL;
2047                 iks *description, *transport;
2048
2049                 if (session->transport != JINGLE_TRANSPORT_GOOGLE_V1) {
2050                         /* If this content stanza has no name consider it invalid and move on */
2051                         if (ast_strlen_zero(name) && !(name = iks_find_attrib(content, "jin:name"))) {
2052                                 jingle_queue_hangup_with_cause(session, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
2053                                 ast_log(LOG_ERROR, "Received content without a name on session '%s'\n", session->sid);
2054                                 return -1;
2055                         }
2056
2057                         /* Try to pre-populate which RTP instance this content is relevant to */
2058                         if (!strcmp(session->audio_name, name)) {
2059                                 rtp = session->rtp;
2060                         } else if (!strcmp(session->video_name, name)) {
2061                                 rtp = session->vrtp;
2062                         }
2063                 } else {
2064                         /* Google-V1 has no concept of assocating things like the above does, so since we only support audio over it assume they want audio */
2065                         rtp = session->rtp;
2066                 }
2067
2068                 /* If description information is available use it */
2069                 if ((description = iks_find_with_attrib(content, "description", "xmlns", JINGLE_RTP_NS)) ||
2070                     (description = iks_find_with_attrib(content, "rtp:description", "xmlns:rtp", JINGLE_RTP_NS)) ||
2071                     (description = iks_find_with_attrib(pak->query, "description", "xmlns", GOOGLE_PHONE_NS)) ||
2072                     (description = iks_find_with_attrib(pak->query, "vid:description", "xmlns", GOOGLE_VIDEO_NS))) {
2073                         /* If we failed to do something with the content description abort immediately */
2074                         if (jingle_interpret_description(session, description, name, &rtp)) {
2075                                 return -1;
2076                         }
2077
2078                         /* If we successfully interpret the description then the codecs need updating */
2079                         changed = 1;
2080                 }
2081
2082                 /* If we get past the description handling and we still don't know what RTP instance this is for... it is unknown content */
2083                 if (!rtp) {
2084                         ast_log(LOG_ERROR, "Received a content stanza but have no RTP instance for it on session '%s'\n", session->sid);
2085                         jingle_queue_hangup_with_cause(session, AST_CAUSE_SWITCH_CONGESTION);
2086                         return -1;
2087                 }
2088
2089                 /* If ICE UDP transport information is available use it */
2090                 if ((transport = iks_find_with_attrib(content, "transport", "xmlns", JINGLE_ICE_UDP_NS))) {
2091                         if (jingle_interpret_ice_udp_transport(session, transport, rtp)) {
2092                                 return -1;
2093                         }
2094                 } else if ((transport = iks_find_with_attrib(content, "transport", "xmlns", GOOGLE_TRANSPORT_NS)) ||
2095                            (transport = iks_find_with_attrib(content, "p:transport", "xmlns:p", GOOGLE_TRANSPORT_NS)) ||
2096                            (transport = iks_find_with_attrib(pak->x, "session", "xmlns", GOOGLE_SESSION_NS)) ||
2097                            (transport = iks_find_with_attrib(pak->x, "ses:session", "xmlns:ses", GOOGLE_SESSION_NS))) {
2098                         /* If Google transport support is available use it */
2099                         if (jingle_interpret_google_transport(session, transport, rtp)) {
2100                                 return -1;
2101                         }
2102                 } else if (iks_find(content, "transport")) {
2103                         /* If this is a transport we do not support terminate the session as it probably won't work out in the end */
2104                         jingle_queue_hangup_with_cause(session, AST_CAUSE_FACILITY_NOT_IMPLEMENTED);
2105                         ast_log(LOG_ERROR, "Unsupported transport type received on session '%s'\n", session->sid);
2106                         return -1;
2107                 }
2108         }
2109
2110         if (!changed) {
2111                 return 0;
2112         }
2113
2114         if ((chan = jingle_session_lock_full(session))) {
2115                 struct ast_format fmt;
2116
2117                 ast_format_cap_copy(ast_channel_nativeformats(chan), session->jointcap);
2118                 ast_codec_choose(&session->prefs, session->jointcap, 1, &fmt);
2119                 ast_set_read_format(chan, &fmt);
2120                 ast_set_write_format(chan, &fmt);
2121
2122                 ast_channel_unlock(chan);
2123                 ast_channel_unref(chan);
2124         }
2125         ao2_unlock(session);
2126
2127         return 0;
2128 }
2129
2130 /*! \brief Handler function for the 'session-initiate' action */
2131 static void jingle_action_session_initiate(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak)
2132 {
2133         char *sid;
2134         enum jingle_transport transport = JINGLE_TRANSPORT_NONE;
2135         struct ast_channel *chan;
2136         int res;
2137
2138         if (session) {
2139                 /* This is a duplicate session setup, so respond accordingly */
2140                 jingle_send_error_response(endpoint->connection, pak, "result", "out-of-order", NULL);
2141                 return;
2142         }
2143
2144         /* Retrieve the session identifier from the message, note that this may alter the transport */
2145         if ((sid = iks_find_attrib(pak->query, "id"))) {
2146                 /* The presence of the session identifier in the 'id' attribute tells us that this is Google-V1 as everything else uses 'sid' */
2147                 transport = JINGLE_TRANSPORT_GOOGLE_V1;
2148         } else if (!(sid = iks_find_attrib(pak->query, "sid"))) {
2149                 jingle_send_error_response(endpoint->connection, pak, "bad-request", NULL, NULL);
2150                 return;
2151         }
2152
2153         /* Create a new local session */
2154         if (!(session = jingle_alloc(endpoint, pak->from->full, sid))) {
2155                 jingle_send_error_response(endpoint->connection, pak, "cancel", "service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'", NULL);
2156                 return;
2157         }
2158
2159         /* If we determined that the transport should change as a result of how we got the SID change it */
2160         if (transport != JINGLE_TRANSPORT_NONE) {
2161                 session->transport = transport;
2162         }
2163
2164         /* Create a new Asterisk channel using the above local session */
2165         if (!(chan = jingle_new(endpoint, session, AST_STATE_DOWN, pak->from->user, NULL, pak->from->full))) {
2166                 ao2_ref(session, -1);
2167                 jingle_send_error_response(endpoint->connection, pak, "cancel", "service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'", NULL);
2168                 return;
2169         }
2170
2171         ao2_link(endpoint->state->sessions, session);
2172
2173         ast_setstate(chan, AST_STATE_RING);
2174         res = ast_pbx_start(chan);
2175
2176         switch (res) {
2177         case AST_PBX_FAILED:
2178                 ast_log(LOG_WARNING, "Failed to start PBX :(\n");
2179                 jingle_send_error_response(endpoint->connection, pak, "cancel", "service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'", NULL);
2180                 session->gone = 1;
2181                 ast_hangup(chan);
2182                 break;
2183         case AST_PBX_CALL_LIMIT:
2184                 ast_log(LOG_WARNING, "Failed to start PBX (call limit reached) \n");
2185                 jingle_send_error_response(endpoint->connection, pak, "wait", "resource-constraint xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'", NULL);
2186                 ast_hangup(chan);
2187                 break;
2188         case AST_PBX_SUCCESS:
2189                 jingle_send_response(endpoint->connection, pak);
2190
2191                 /* Only send a transport-info message if we successfully interpreted the available content */
2192                 if (!jingle_interpret_content(session, pak)) {
2193                         jingle_send_transport_info(session, iks_find_attrib(pak->x, "from"));
2194                 }
2195                 break;
2196         }
2197 }
2198
2199 /*! \brief Handler function for the 'transport-info' action */
2200 static void jingle_action_transport_info(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak)
2201 {
2202         if (!session) {
2203                 jingle_send_error_response(endpoint->connection, pak, "cancel", "item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'",
2204                                            "unknown-session xmlns='urn:xmpp:jingle:errors:1'");
2205                 return;
2206         }
2207
2208         jingle_interpret_content(session, pak);
2209         jingle_send_response(endpoint->connection, pak);
2210 }
2211
2212 /*! \brief Handler function for the 'session-accept' action */
2213 static void jingle_action_session_accept(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak)
2214 {
2215         struct ast_channel *chan;
2216
2217         if (!session) {
2218                 jingle_send_error_response(endpoint->connection, pak, "cancel", "item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'",
2219                                            "unknown-session xmlns='urn:xmpp:jingle:errors:1'");
2220                 return;
2221         }
2222
2223
2224         jingle_interpret_content(session, pak);
2225
2226         if ((chan = jingle_session_lock_full(session))) {
2227                 ast_queue_control(chan, AST_CONTROL_ANSWER);
2228                 ast_channel_unlock(chan);
2229                 ast_channel_unref(chan);
2230         }
2231         ao2_unlock(session);
2232
2233         jingle_send_response(endpoint->connection, pak);
2234 }
2235
2236 /*! \brief Handler function for the 'session-info' action */
2237 static void jingle_action_session_info(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak)
2238 {
2239         struct ast_channel *chan;
2240
2241         if (!session) {
2242                 jingle_send_error_response(endpoint->connection, pak, "cancel", "item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'",
2243                                            "unknown-session xmlns='urn:xmpp:jingle:errors:1'");
2244                 return;
2245         }
2246
2247         if (!(chan = jingle_session_lock_full(session))) {
2248                 ao2_unlock(session);
2249                 jingle_send_response(endpoint->connection, pak);
2250                 return;
2251         }
2252
2253         if (iks_find_with_attrib(pak->query, "ringing", "xmlns", JINGLE_RTP_INFO_NS)) {
2254                 ast_queue_control(chan, AST_CONTROL_RINGING);
2255                 if (ast_channel_state(chan) != AST_STATE_UP) {
2256                         ast_setstate(chan, AST_STATE_RINGING);
2257                 }
2258         } else if (iks_find_with_attrib(pak->query, "hold", "xmlns", JINGLE_RTP_INFO_NS)) {
2259                 ast_queue_control(chan, AST_CONTROL_HOLD);
2260         } else if (iks_find_with_attrib(pak->query, "unhold", "xmlns", JINGLE_RTP_INFO_NS)) {
2261                 ast_queue_control(chan, AST_CONTROL_UNHOLD);
2262         }
2263
2264         ast_channel_unlock(chan);
2265         ast_channel_unref(chan);
2266         ao2_unlock(session);
2267
2268         jingle_send_response(endpoint->connection, pak);
2269 }
2270
2271 /*! \brief Handler function for the 'session-terminate' action */
2272 static void jingle_action_session_terminate(struct jingle_endpoint *endpoint, struct jingle_session *session, ikspak *pak)
2273 {
2274         struct ast_channel *chan;
2275         iks *reason, *text;
2276         int cause = AST_CAUSE_NORMAL;
2277
2278         if (!session) {
2279                 jingle_send_error_response(endpoint->connection, pak, "cancel", "item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'",
2280                                            "unknown-session xmlns='urn:xmpp:jingle:errors:1'");
2281                 return;
2282         }
2283
2284         if (!(chan = jingle_session_lock_full(session))) {
2285                 ao2_unlock(session);
2286                 jingle_send_response(endpoint->connection, pak);
2287                 return;
2288         }
2289
2290         /* Pull the reason text from the session-terminate message and translate it into a cause code */
2291         if ((reason = iks_find(pak->query, "reason")) && (text = iks_child(reason))) {
2292                 int i;
2293
2294                 /* Get the appropriate cause code mapping for this reason */
2295                 for (i = 0; i < ARRAY_LEN(jingle_reason_mappings); i++) {
2296                         if (!strcasecmp(jingle_reason_mappings[i].reason, iks_name(text))) {
2297                                 cause = jingle_reason_mappings[i].cause;
2298                                 break;
2299                         }
2300                 }
2301         }
2302
2303         ast_debug(3, "Hanging up channel '%s' due to session terminate message with cause '%d'\n", ast_channel_name(chan), cause);
2304         ast_queue_hangup_with_cause(chan, cause);
2305         session->gone = 1;
2306
2307         ast_channel_unlock(chan);
2308         ast_channel_unref(chan);
2309         ao2_unlock(session);
2310
2311         jingle_send_response(endpoint->connection, pak);
2312 }
2313
2314 /*! \brief Callback for when a Jingle action is received from an endpoint */
2315 static int jingle_action_hook(void *data, ikspak *pak)
2316 {
2317         char *action;
2318         const char *sid = NULL;
2319         struct jingle_session *session = NULL;
2320         struct jingle_endpoint *endpoint = data;
2321         int i, handled = 0;
2322
2323         /* We accept both Jingle and Google-V1 */
2324         if (!(action = iks_find_attrib(pak->query, "action")) &&
2325             !(action = iks_find_attrib(pak->query, "type"))) {
2326                 /* This occurs if either receive a packet masquerading as Jingle or Google-V1 that is actually not OR we receive a response
2327                  * to a message that has no response hook. */
2328                 return IKS_FILTER_EAT;
2329         }
2330
2331         /* Bump the endpoint reference count up in case a reload occurs. Unfortunately the available synchronization between iksemel and us
2332          * does not permit us to make this completely safe. */
2333         ao2_ref(endpoint, +1);
2334
2335         /* If a Jingle session identifier is present use it */
2336         if (!(sid = iks_find_attrib(pak->query, "sid"))) {
2337                 /* If a Google-V1 session identifier is present use it */
2338                 sid = iks_find_attrib(pak->query, "id");
2339         }
2340
2341         /* If a session identifier was present in the message attempt to find the session, it is up to the action handler whether
2342          * this is required or not */
2343         if (!ast_strlen_zero(sid)) {
2344                 session = ao2_find(endpoint->state->sessions, sid, OBJ_KEY);
2345         }
2346
2347         /* Iterate through supported action handlers looking for one that is able to handle this */
2348         for (i = 0; i < ARRAY_LEN(jingle_action_handlers); i++) {
2349                 if (!strcasecmp(jingle_action_handlers[i].action, action)) {
2350                         jingle_action_handlers[i].handler(endpoint, session, pak);
2351                         handled = 1;
2352                         break;
2353                 }
2354         }
2355
2356         /* If no action handler is present for the action they sent us make it evident */
2357         if (!handled) {
2358                 ast_log(LOG_NOTICE, "Received action '%s' for session '%s' that has no handler\n", action, sid);
2359         }
2360
2361         /* If a session was successfully found for this message deref it now since the handler is done */
2362         if (session) {
2363                 ao2_ref(session, -1);
2364         }
2365
2366         ao2_ref(endpoint, -1);
2367
2368         return IKS_FILTER_EAT;
2369 }
2370
2371 /*! \brief Custom handler for groups */
2372 static int custom_group_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
2373 {
2374         struct jingle_endpoint *endpoint = obj;
2375
2376         if (!strcasecmp(var->name, "callgroup")) {
2377                 endpoint->callgroup = ast_get_group(var->value);
2378         } else if (!strcasecmp(var->name, "pickupgroup")) {
2379                 endpoint->pickupgroup = ast_get_group(var->value);
2380         } else {
2381                 return -1;
2382         }
2383
2384         return 0;
2385 }
2386
2387 /*! \brief Custom handler for connection */
2388 static int custom_connection_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
2389 {
2390         struct jingle_endpoint *endpoint = obj;
2391
2392         /* You might think... but Josh, shouldn't you do this in a prelink callback? Well I *could* but until the original is destroyed
2393          * this will not actually get called, so even if the config turns out to be bogus this is harmless.
2394          */
2395         if (!(endpoint->connection = ast_xmpp_client_find(var->value))) {
2396                 ast_log(LOG_ERROR, "Connection '%s' configured on endpoint '%s' could not be found\n", var->value, endpoint->name);
2397                 return -1;
2398         }
2399
2400         if (!(endpoint->rule = iks_filter_add_rule(endpoint->connection->filter, jingle_action_hook, endpoint,
2401                                                    IKS_RULE_TYPE, IKS_PAK_IQ,
2402                                                    IKS_RULE_NS, JINGLE_NS,
2403                                                    IKS_RULE_NS, GOOGLE_SESSION_NS,
2404                                                    IKS_RULE_DONE))) {
2405                 ast_log(LOG_ERROR, "Action hook could not be added to connection '%s' on endpoint '%s'\n", var->value, endpoint->name);
2406                 return -1;
2407         }
2408
2409         return 0;
2410 }
2411
2412 /*! \brief Custom handler for transport */
2413 static int custom_transport_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
2414 {
2415         struct jingle_endpoint *endpoint = obj;
2416
2417         if (!strcasecmp(var->value, "ice-udp")) {
2418                 endpoint->transport = JINGLE_TRANSPORT_ICE_UDP;
2419         } else if (!strcasecmp(var->value, "google")) {
2420                 endpoint->transport = JINGLE_TRANSPORT_GOOGLE_V2;
2421         } else if (!strcasecmp(var->value, "google-v1")) {
2422                 endpoint->transport = JINGLE_TRANSPORT_GOOGLE_V1;
2423         } else {
2424                 ast_log(LOG_WARNING, "Unknown transport type '%s' on endpoint '%s', defaulting to 'ice-udp'\n", var->value, endpoint->name);
2425                 endpoint->transport = JINGLE_TRANSPORT_ICE_UDP;
2426         }
2427
2428         return 0;
2429 }
2430
2431 /*! \brief Load module into PBX, register channel */
2432 static int load_module(void)
2433 {
2434         if (!(jingle_tech.capabilities = ast_format_cap_alloc())) {
2435                 return AST_MODULE_LOAD_DECLINE;
2436         }
2437
2438         if (aco_info_init(&cfg_info)) {
2439                 ast_log(LOG_ERROR, "Unable to intialize configuration for chan_motif.\n");
2440                 goto end;
2441         }
2442
2443         aco_option_register(&cfg_info, "context", ACO_EXACT, endpoint_options, "default", OPT_STRINGFIELD_T, 0, STRFLDSET(struct jingle_endpoint, context));
2444         aco_option_register_custom(&cfg_info, "callgroup", ACO_EXACT, endpoint_options, NULL, custom_group_handler, 0);
2445         aco_option_register_custom(&cfg_info, "pickupgroup", ACO_EXACT, endpoint_options, NULL, custom_group_handler, 0);
2446         aco_option_register(&cfg_info, "language", ACO_EXACT, endpoint_options, NULL, OPT_STRINGFIELD_T, 0, STRFLDSET(struct jingle_endpoint, language));
2447         aco_option_register(&cfg_info, "musicclass", ACO_EXACT, endpoint_options, NULL, OPT_STRINGFIELD_T, 0, STRFLDSET(struct jingle_endpoint, musicclass));
2448         aco_option_register(&cfg_info, "parkinglot", ACO_EXACT, endpoint_options, NULL, OPT_STRINGFIELD_T, 0, STRFLDSET(struct jingle_endpoint, parkinglot));
2449         aco_option_register(&cfg_info, "accountcode", ACO_EXACT, endpoint_options, NULL, OPT_STRINGFIELD_T, 0, STRFLDSET(struct jingle_endpoint, accountcode));
2450         aco_option_register(&cfg_info, "allow", ACO_EXACT, endpoint_options, "ulaw,alaw", OPT_CODEC_T, 1, FLDSET(struct jingle_endpoint, prefs, cap));
2451         aco_option_register(&cfg_info, "disallow", ACO_EXACT, endpoint_options, "all", OPT_CODEC_T, 0, FLDSET(struct jingle_endpoint, prefs, cap));
2452         aco_option_register_custom(&cfg_info, "connection", ACO_EXACT, endpoint_options, NULL, custom_connection_handler, 0);
2453         aco_option_register_custom(&cfg_info, "transport", ACO_EXACT, endpoint_options, NULL, custom_transport_handler, 0);
2454         aco_option_register(&cfg_info, "maxicecandidates", ACO_EXACT, endpoint_options, DEFAULT_MAX_ICE_CANDIDATES, OPT_UINT_T, PARSE_DEFAULT,
2455                             FLDSET(struct jingle_endpoint, maxicecandidates));
2456         aco_option_register(&cfg_info, "maxpayloads", ACO_EXACT, endpoint_options, DEFAULT_MAX_PAYLOADS, OPT_UINT_T, PARSE_DEFAULT,
2457                             FLDSET(struct jingle_endpoint, maxpayloads));
2458
2459         ast_format_cap_add_all_by_type(jingle_tech.capabilities, AST_FORMAT_TYPE_AUDIO);
2460
2461         if (aco_process_config(&cfg_info, 0)) {
2462                 ast_log(LOG_ERROR, "Unable to read config file motif.conf. Not loading module.\n");
2463                 goto end;
2464         }
2465
2466         if (!(sched = ast_sched_context_create())) {
2467                 ast_log(LOG_ERROR, "Unable to create scheduler context.\n");
2468                 goto end;
2469         }
2470
2471         if (ast_sched_start_thread(sched)) {
2472                 ast_log(LOG_ERROR, "Unable to create scheduler context thread.\n");
2473                 goto end;
2474         }
2475
2476         ast_rtp_glue_register(&jingle_rtp_glue);
2477
2478         if (ast_channel_register(&jingle_tech)) {
2479                 ast_log(LOG_ERROR, "Unable to register channel class %s\n", channel_type);
2480                 goto end;
2481         }
2482
2483         return 0;
2484
2485 end:
2486         ast_rtp_glue_unregister(&jingle_rtp_glue);
2487
2488         if (sched) {
2489                 ast_sched_context_destroy(sched);
2490         }
2491
2492         aco_info_destroy(&cfg_info);
2493
2494         return AST_MODULE_LOAD_FAILURE;
2495 }
2496
2497 /*! \brief Reload module */
2498 static int reload(void)
2499 {
2500         return aco_process_config(&cfg_info, 1);
2501 }
2502
2503 /*! \brief Unload the jingle channel from Asterisk */
2504 static int unload_module(void)
2505 {
2506         ast_channel_unregister(&jingle_tech);
2507         ast_rtp_glue_unregister(&jingle_rtp_glue);
2508         ast_sched_context_destroy(sched);
2509         aco_info_destroy(&cfg_info);
2510         ao2_global_obj_release(globals);
2511
2512         return 0;
2513 }
2514
2515 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Motif Jingle Channel Driver",
2516                 .load = load_module,
2517                 .unload = unload_module,
2518                 .reload = reload,
2519                 .load_pri = AST_MODPRI_CHANNEL_DRIVER,
2520                );