Wed Jan 8 2020 09:50:03

Asterisk developer's documentation


chan_jingle.c File Reference

Jingle Channel Driver. More...

#include "asterisk.h"
#include <sys/socket.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/signal.h>
#include <iksemel.h>
#include <pthread.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/rtp_engine.h"
#include "asterisk/acl.h"
#include "asterisk/callerid.h"
#include "asterisk/file.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/musiconhold.h"
#include "asterisk/manager.h"
#include "asterisk/stringfields.h"
#include "asterisk/utils.h"
#include "asterisk/causes.h"
#include "asterisk/astobj.h"
#include "asterisk/abstract_jb.h"
#include "asterisk/jabber.h"
#include "asterisk/jingle.h"

Go to the source code of this file.

Data Structures

struct  jingle
 
struct  jingle_candidate
 
struct  jingle_container
 
struct  jingle_pvt
 

Macros

#define FORMAT   "%-30.30s %-30.30s %-15.15s %-5.5s %-5.5s \n"
 
#define JINGLE_CONFIG   "jingle.conf"
 

Enumerations

enum  jingle_connect_type { AJI_CONNECT_HOST, AJI_CONNECT_PRFLX, AJI_CONNECT_RELAY, AJI_CONNECT_SRFLX }
 
enum  jingle_protocol { AJI_PROTOCOL_UDP, AJI_PROTOCOL_SSLTCP }
 

Functions

static void __reg_module (void)
 
static void __unreg_module (void)
 
static void add_codec_to_answer (const struct jingle_pvt *p, int codec, iks *dcodecs)
 
static struct jinglefind_jingle (char *name, char *connection)
 
static int jingle_accept_call (struct jingle *client, struct jingle_pvt *p)
 
static int jingle_action (struct jingle *client, struct jingle_pvt *p, const char *action)
 
static int jingle_add_candidate (struct jingle *client, ikspak *pak)
 
static struct jingle_pvtjingle_alloc (struct jingle *client, const char *from, const char *sid)
 
static int jingle_answer (struct ast_channel *ast)
 
static int jingle_call (struct ast_channel *ast, char *dest, int timeout)
 Initiate new call, part of PBX interface dest is the dial string. More...
 
static int jingle_create_candidates (struct jingle *client, struct jingle_pvt *p, char *sid, char *from)
 
static int jingle_create_member (char *label, struct ast_variable *var, int allowguest, struct ast_codec_pref prefs, char *context, struct jingle *member)
 
static int jingle_digit (struct ast_channel *ast, char digit, unsigned int duration)
 
static int jingle_digit_begin (struct ast_channel *ast, char digit)
 
static int jingle_digit_end (struct ast_channel *ast, char digit, unsigned int duration)
 
static char * jingle_do_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 CLI command "jingle reload". More...
 
static int jingle_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
 
static void jingle_free_candidates (struct jingle_candidate *candidate)
 
static void jingle_free_pvt (struct jingle *client, struct jingle_pvt *p)
 
static format_t jingle_get_codec (struct ast_channel *chan)
 
static enum ast_rtp_glue_result jingle_get_rtp_peer (struct ast_channel *chan, struct ast_rtp_instance **instance)
 
static int jingle_handle_dtmf (struct jingle *client, ikspak *pak)
 
static int jingle_hangup (struct ast_channel *ast)
 Hangup a call through the jingle proxy channel. More...
 
static int jingle_hangup_farend (struct jingle *client, ikspak *pak)
 
static int jingle_indicate (struct ast_channel *ast, int condition, const void *data, size_t datalen)
 
static int jingle_is_answered (struct jingle *client, ikspak *pak)
 
static int jingle_load_config (void)
 
static void jingle_member_destroy (struct jingle *obj)
 
static struct ast_channeljingle_new (struct jingle *client, struct jingle_pvt *i, int state, const char *title, const char *linkedid)
 Start new jingle channel. More...
 
static int jingle_newcall (struct jingle *client, ikspak *pak)
 
static int jingle_parser (void *data, ikspak *pak)
 
static struct ast_framejingle_read (struct ast_channel *ast)
 
static struct ast_channeljingle_request (const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause)
 Part of PBX interface. More...
 
static int jingle_response (struct jingle *client, ikspak *pak, const char *reasonstr, const char *reasonstr2)
 
static int jingle_ringing_ack (void *data, ikspak *pak)
 
static struct ast_framejingle_rtp_read (struct ast_channel *ast, struct jingle_pvt *p)
 
static int jingle_sendhtml (struct ast_channel *ast, int subclass, const char *data, int datalen)
 
static int jingle_sendtext (struct ast_channel *ast, const char *text)
 
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, format_t codecs, int nat_active)
 
static char * jingle_show_channels (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 CLI command "jingle show channels". More...
 
static int jingle_transmit_invite (struct jingle_pvt *p)
 
static int jingle_update_stun (struct jingle *client, struct jingle_pvt *p)
 
static int jingle_write (struct ast_channel *ast, struct ast_frame *frame)
 Send frame to media channel (rtp) More...
 
static int load_module (void)
 Load module into PBX, register channel. More...
 
static int reload (void)
 Reload module. More...
 
static int unload_module (void)
 Unload the jingle channel from Asterisk. More...
 

Variables

static struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Jingle Channel Driver" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "ac1f6a56484a8820659555499174e588" , .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DRIVER, }
 
static struct in_addr __ourip
 
static struct ast_module_infoast_module_info = &__mod_info
 
static struct sockaddr_in bindaddr = { 0, }
 
static const char channel_type [] = "Jingle"
 
static struct ast_jb_conf default_jbconf
 
static const char desc [] = "Jingle Channel"
 
static char externip [16]
 
static format_t global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263
 
static struct ast_jb_conf global_jbconf
 
static struct io_contextio
 
static struct ast_cli_entry jingle_cli []
 
static struct jingle_container jingle_list
 
static struct ast_rtp_glue jingle_rtp_glue
 
static struct ast_channel_tech jingle_tech
 PBX interface structure for channel registration. More...
 
static ast_mutex_t jinglelock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 }
 
static struct sched_contextsched
 

Detailed Description

Jingle Channel Driver.

Author
Matt O'Gorman mogor.nosp@m.man@.nosp@m.digiu.nosp@m.m.co.nosp@m.m
ExtRef:
Iksemel http://iksemel.jabberstudio.org/

Definition in file chan_jingle.c.

Macro Definition Documentation

#define FORMAT   "%-30.30s %-30.30s %-15.15s %-5.5s %-5.5s \n"

Referenced by jingle_show_channels().

#define JINGLE_CONFIG   "jingle.conf"

Definition at line 73 of file chan_jingle.c.

Referenced by jingle_load_config(), and load_module().

Enumeration Type Documentation

Enumerator
AJI_CONNECT_HOST 
AJI_CONNECT_PRFLX 
AJI_CONNECT_RELAY 
AJI_CONNECT_SRFLX 

Definition at line 91 of file chan_jingle.c.

Enumerator
AJI_PROTOCOL_UDP 
AJI_PROTOCOL_SSLTCP 

Definition at line 86 of file chan_jingle.c.

Function Documentation

static void __reg_module ( void  )
static

Definition at line 1990 of file chan_jingle.c.

static void __unreg_module ( void  )
static

Definition at line 1990 of file chan_jingle.c.

static void add_codec_to_answer ( const struct jingle_pvt p,
int  codec,
iks *  dcodecs 
)
static

Definition at line 259 of file chan_jingle.c.

References ast_getformatname(), and format.

Referenced by jingle_accept_call().

260 {
261  char *format = ast_getformatname(codec);
262 
263  if (!strcasecmp("ulaw", format)) {
264  iks *payload_eg711u, *payload_pcmu;
265  payload_pcmu = iks_new("payload-type");
266  iks_insert_attrib(payload_pcmu, "id", "0");
267  iks_insert_attrib(payload_pcmu, "name", "PCMU");
268  payload_eg711u = iks_new("payload-type");
269  iks_insert_attrib(payload_eg711u, "id", "100");
270  iks_insert_attrib(payload_eg711u, "name", "EG711U");
271  iks_insert_node(dcodecs, payload_pcmu);
272  iks_insert_node(dcodecs, payload_eg711u);
273  }
274  if (!strcasecmp("alaw", format)) {
275  iks *payload_eg711a;
276  iks *payload_pcma = iks_new("payload-type");
277  iks_insert_attrib(payload_pcma, "id", "8");
278  iks_insert_attrib(payload_pcma, "name", "PCMA");
279  payload_eg711a = iks_new("payload-type");
280  iks_insert_attrib(payload_eg711a, "id", "101");
281  iks_insert_attrib(payload_eg711a, "name", "EG711A");
282  iks_insert_node(dcodecs, payload_pcma);
283  iks_insert_node(dcodecs, payload_eg711a);
284  }
285  if (!strcasecmp("ilbc", format)) {
286  iks *payload_ilbc = iks_new("payload-type");
287  iks_insert_attrib(payload_ilbc, "id", "97");
288  iks_insert_attrib(payload_ilbc, "name", "iLBC");
289  iks_insert_node(dcodecs, payload_ilbc);
290  }
291  if (!strcasecmp("g723", format)) {
292  iks *payload_g723 = iks_new("payload-type");
293  iks_insert_attrib(payload_g723, "id", "4");
294  iks_insert_attrib(payload_g723, "name", "G723");
295  iks_insert_node(dcodecs, payload_g723);
296  }
297 }
char * ast_getformatname(format_t format)
Get the name of a format.
Definition: frame.c:578
static snd_pcm_format_t format
Definition: chan_alsa.c:93
static struct jingle* find_jingle ( char *  name,
char *  connection 
)
static

Definition at line 233 of file chan_jingle.c.

References ASTOBJ_CONTAINER_FIND, ASTOBJ_CONTAINER_FIND_FULL, ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, and jingle_list.

Referenced by jingle_request().

234 {
235  struct jingle *jingle = NULL;
236 
238  if (!jingle && strchr(name, '@'))
239  jingle = ASTOBJ_CONTAINER_FIND_FULL(&jingle_list, name, user,,, strcasecmp);
240 
241  if (!jingle) {
242  /* guest call */
244  ASTOBJ_RDLOCK(iterator);
245  if (!strcasecmp(iterator->name, "guest")) {
246  jingle = iterator;
247  }
248  ASTOBJ_UNLOCK(iterator);
249 
250  if (jingle)
251  break;
252  });
253 
254  }
255  return jingle;
256 }
static struct jingle_container jingle_list
Definition: chan_jingle.c:226
#define ASTOBJ_CONTAINER_TRAVERSE(container, continue, eval)
Iterate through the objects in a container.
Definition: astobj.h:376
static const char name[]
#define ASTOBJ_UNLOCK(object)
Unlock a locked object.
Definition: astobj.h:109
#define ASTOBJ_CONTAINER_FIND(container, namestr)
Find an object in a container.
Definition: astobj.h:401
structure to hold users read from users.conf
#define ASTOBJ_RDLOCK(object)
Lock an ASTOBJ for reading.
Definition: astobj.h:100
#define ASTOBJ_CONTAINER_FIND_FULL(container, data, field, hashfunc, hashoffset, comparefunc)
Find an object in a container.
Definition: astobj.h:428
static int jingle_accept_call ( struct jingle client,
struct jingle_pvt p 
)
static

Definition at line 299 of file chan_jingle.c.

References add_codec_to_answer(), ast_aji_increment_mid(), ast_aji_send(), ast_codec_pref_index(), jingle::capability, jingle::connection, jingle_pvt::initiator, aji_client::jid, aji_client::jingle, JINGLE_ACCEPT, JINGLE_AUDIO_RTP_NS, JINGLE_NODE, JINGLE_NS, JINGLE_SID, aji_client::mid, jingle::p, jingle::prefs, jingle_pvt::sid, jingle_pvt::them, and jingle::user.

Referenced by jingle_answer().

300 {
301  struct jingle_pvt *tmp = client->p;
302  struct aji_client *c = client->connection;
303  iks *iq, *jingle, *dcodecs, *payload_red, *payload_audio, *payload_cn;
304  int x;
305  format_t pref_codec = 0;
306  int alreadysent = 0;
307 
308  if (p->initiator)
309  return 1;
310 
311  iq = iks_new("iq");
312  jingle = iks_new(JINGLE_NODE);
313  dcodecs = iks_new("description");
314  if (iq && jingle && dcodecs) {
315  iks_insert_attrib(dcodecs, "xmlns", JINGLE_AUDIO_RTP_NS);
316 
317  for (x = 0; x < 64; x++) {
318  if (!(pref_codec = ast_codec_pref_index(&client->prefs, x)))
319  break;
320  if (!(client->capability & pref_codec))
321  continue;
322  if (alreadysent & pref_codec)
323  continue;
324  add_codec_to_answer(p, pref_codec, dcodecs);
325  alreadysent |= pref_codec;
326  }
327  payload_red = iks_new("payload-type");
328  iks_insert_attrib(payload_red, "id", "117");
329  iks_insert_attrib(payload_red, "name", "red");
330  payload_audio = iks_new("payload-type");
331  iks_insert_attrib(payload_audio, "id", "106");
332  iks_insert_attrib(payload_audio, "name", "audio/telephone-event");
333  payload_cn = iks_new("payload-type");
334  iks_insert_attrib(payload_cn, "id", "13");
335  iks_insert_attrib(payload_cn, "name", "CN");
336 
337 
338  iks_insert_attrib(iq, "type", "set");
339  iks_insert_attrib(iq, "to", (p->them) ? p->them : client->user);
340  iks_insert_attrib(iq, "id", client->connection->mid);
342 
343  iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
344  iks_insert_attrib(jingle, "action", JINGLE_ACCEPT);
345  iks_insert_attrib(jingle, "initiator", p->initiator ? client->connection->jid->full : p->them);
346  iks_insert_attrib(jingle, JINGLE_SID, tmp->sid);
347  iks_insert_node(iq, jingle);
348  iks_insert_node(jingle, dcodecs);
349  iks_insert_node(dcodecs, payload_red);
350  iks_insert_node(dcodecs, payload_audio);
351  iks_insert_node(dcodecs, payload_cn);
352 
353  ast_aji_send(c, iq);
354 
355  iks_delete(payload_red);
356  iks_delete(payload_audio);
357  iks_delete(payload_cn);
358  iks_delete(dcodecs);
359  iks_delete(jingle);
360  iks_delete(iq);
361  }
362  return 1;
363 }
struct jingle_pvt * p
Definition: chan_jingle.c:145
int ast_aji_send(struct aji_client *client, iks *x)
Wraps raw sending.
Definition: res_jabber.c:1439
format_t ast_codec_pref_index(struct ast_codec_pref *pref, int index)
Codec located at a particular place in the preference index.
Definition: frame.c:1061
#define JINGLE_NODE
Definition: jingle.h:37
format_t capability
Definition: chan_jingle.c:151
char sid[100]
Definition: chan_jingle.c:102
struct ast_codec_pref prefs
Definition: chan_jingle.c:146
#define JINGLE_AUDIO_RTP_NS
Definition: jingle.h:41
#define JINGLE_NS
Definition: jingle.h:40
char them[AJI_MAX_JIDLEN]
Definition: chan_jingle.c:103
static void add_codec_to_answer(const struct jingle_pvt *p, int codec, iks *dcodecs)
Definition: chan_jingle.c:259
int64_t format_t
Definition: frame_defs.h:32
#define JINGLE_SID
Definition: jingle.h:52
iksid * jid
Definition: jabber.h:160
#define JINGLE_ACCEPT
Definition: jingle.h:57
void * jingle
Definition: jabber.h:186
struct aji_client * connection
Definition: chan_jingle.c:143
char mid[6]
Definition: jabber.h:159
char user[100]
Definition: chan_jingle.c:148
void ast_aji_increment_mid(char *mid)
increments the mid field for messages and other events.
Definition: res_jabber.c:2790
static int jingle_action ( struct jingle client,
struct jingle_pvt p,
const char *  action 
)
static

Definition at line 895 of file chan_jingle.c.

References ast_aji_increment_mid(), ast_aji_send(), jingle::connection, jingle_pvt::initiator, aji_client::jid, JINGLE_NS, JINGLE_SID, aji_client::mid, jingle_pvt::sid, and jingle_pvt::them.

Referenced by jingle_hangup().

896 {
897  iks *iq, *jingle = NULL;
898  int res = -1;
899 
900  iq = iks_new("iq");
901  jingle = iks_new("jingle");
902 
903  if (iq) {
904  iks_insert_attrib(iq, "type", "set");
905  iks_insert_attrib(iq, "from", client->connection->jid->full);
906  iks_insert_attrib(iq, "to", p->them);
907  iks_insert_attrib(iq, "id", client->connection->mid);
909  if (jingle) {
910  iks_insert_attrib(jingle, "action", action);
911  iks_insert_attrib(jingle, JINGLE_SID, p->sid);
912  iks_insert_attrib(jingle, "initiator", p->initiator ? client->connection->jid->full : p->them);
913  iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
914 
915  iks_insert_node(iq, jingle);
916 
917  ast_aji_send(client->connection, iq);
918  res = 0;
919  }
920  }
921 
922  iks_delete(jingle);
923  iks_delete(iq);
924 
925  return res;
926 }
int ast_aji_send(struct aji_client *client, iks *x)
Wraps raw sending.
Definition: res_jabber.c:1439
char sid[100]
Definition: chan_jingle.c:102
#define JINGLE_NS
Definition: jingle.h:40
char them[AJI_MAX_JIDLEN]
Definition: chan_jingle.c:103
#define JINGLE_SID
Definition: jingle.h:52
iksid * jid
Definition: jabber.h:160
struct aji_client * connection
Definition: chan_jingle.c:143
char mid[6]
Definition: jabber.h:159
void ast_aji_increment_mid(char *mid)
increments the mid field for messages and other events.
Definition: res_jabber.c:2790
static int jingle_add_candidate ( struct jingle client,
ikspak *  pak 
)
static

Definition at line 1106 of file chan_jingle.c.

References AJI_CONNECT_HOST, AJI_CONNECT_PRFLX, AJI_CONNECT_RELAY, AJI_CONNECT_SRFLX, AJI_PROTOCOL_SSLTCP, AJI_PROTOCOL_UDP, ast_aji_send(), ast_calloc, ast_copy_string(), jingle::connection, jingle_candidate::generation, jingle_candidate::ip, aji_client::jid, JINGLE_NODE, JINGLE_SID, jingle_update_stun(), jingle_pvt::laststun, jingle_candidate::network, jingle_pvt::next, jingle_candidate::next, jingle::p, jingle_pvt::parent, jingle_candidate::password, jingle_candidate::port, jingle_candidate::protocol, jingle_pvt::theircandidates, and jingle_candidate::type.

Referenced by jingle_parser().

1107 {
1108  struct jingle_pvt *p = NULL, *tmp = NULL;
1109  struct aji_client *c = client->connection;
1110  struct jingle_candidate *newcandidate = NULL;
1111  iks *traversenodes = NULL, *receipt = NULL;
1112 
1113  for (tmp = client->p; tmp; tmp = tmp->next) {
1114  if (iks_find_with_attrib(pak->x, JINGLE_NODE, JINGLE_SID, tmp->sid)) {
1115  p = tmp;
1116  break;
1117  }
1118  }
1119 
1120  if (!p)
1121  return -1;
1122 
1123  traversenodes = pak->query;
1124  while(traversenodes) {
1125  if(!strcasecmp(iks_name(traversenodes), "jingle")) {
1126  traversenodes = iks_child(traversenodes);
1127  continue;
1128  }
1129  if(!strcasecmp(iks_name(traversenodes), "content")) {
1130  traversenodes = iks_child(traversenodes);
1131  continue;
1132  }
1133  if(!strcasecmp(iks_name(traversenodes), "transport")) {
1134  traversenodes = iks_child(traversenodes);
1135  continue;
1136  }
1137 
1138  if(!strcasecmp(iks_name(traversenodes), "candidate")) {
1139  newcandidate = ast_calloc(1, sizeof(*newcandidate));
1140  if (!newcandidate)
1141  return 0;
1142  ast_copy_string(newcandidate->ip, iks_find_attrib(traversenodes, "ip"), sizeof(newcandidate->ip));
1143  newcandidate->port = atoi(iks_find_attrib(traversenodes, "port"));
1144  ast_copy_string(newcandidate->password, iks_find_attrib(traversenodes, "pwd"), sizeof(newcandidate->password));
1145  if (!strcasecmp(iks_find_attrib(traversenodes, "protocol"), "udp"))
1146  newcandidate->protocol = AJI_PROTOCOL_UDP;
1147  else if (!strcasecmp(iks_find_attrib(traversenodes, "protocol"), "ssltcp"))
1148  newcandidate->protocol = AJI_PROTOCOL_SSLTCP;
1149 
1150  if (!strcasecmp(iks_find_attrib(traversenodes, "type"), "host"))
1151  newcandidate->type = AJI_CONNECT_HOST;
1152  else if (!strcasecmp(iks_find_attrib(traversenodes, "type"), "prflx"))
1153  newcandidate->type = AJI_CONNECT_PRFLX;
1154  else if (!strcasecmp(iks_find_attrib(traversenodes, "type"), "relay"))
1155  newcandidate->type = AJI_CONNECT_RELAY;
1156  else if (!strcasecmp(iks_find_attrib(traversenodes, "type"), "srflx"))
1157  newcandidate->type = AJI_CONNECT_SRFLX;
1158 
1159  newcandidate->network = atoi(iks_find_attrib(traversenodes, "network"));
1160  newcandidate->generation = atoi(iks_find_attrib(traversenodes, "generation"));
1161  newcandidate->next = NULL;
1162 
1163  newcandidate->next = p->theircandidates;
1164  p->theircandidates = newcandidate;
1165  p->laststun = 0;
1166  jingle_update_stun(p->parent, p);
1167  newcandidate = NULL;
1168  }
1169  traversenodes = iks_next(traversenodes);
1170  }
1171 
1172  receipt = iks_new("iq");
1173  iks_insert_attrib(receipt, "type", "result");
1174  iks_insert_attrib(receipt, "from", c->jid->full);
1175  iks_insert_attrib(receipt, "to", iks_find_attrib(pak->x, "from"));
1176  iks_insert_attrib(receipt, "id", iks_find_attrib(pak->x, "id"));
1177  ast_aji_send(c, receipt);
1178 
1179  iks_delete(receipt);
1180 
1181  return 1;
1182 }
struct jingle_pvt * p
Definition: chan_jingle.c:145
enum jingle_connect_type type
Definition: chan_jingle.c:135
struct jingle_candidate * next
Definition: chan_jingle.c:138
unsigned int generation
Definition: chan_jingle.c:128
int ast_aji_send(struct aji_client *client, iks *x)
Wraps raw sending.
Definition: res_jabber.c:1439
struct jingle_candidate * theircandidates
Definition: chan_jingle.c:110
static int jingle_update_stun(struct jingle *client, struct jingle_pvt *p)
Definition: chan_jingle.c:1078
struct jingle_pvt * next
Definition: chan_jingle.c:122
unsigned int network
Definition: chan_jingle.c:130
struct jingle * parent
Definition: chan_jingle.c:101
#define JINGLE_NODE
Definition: jingle.h:37
char password[100]
Definition: chan_jingle.c:134
enum jingle_protocol protocol
Definition: chan_jingle.c:133
#define JINGLE_SID
Definition: jingle.h:52
iksid * jid
Definition: jabber.h:160
#define ast_calloc(a, b)
Definition: astmm.h:82
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:223
struct aji_client * connection
Definition: chan_jingle.c:143
time_t laststun
Definition: chan_jingle.c:100
unsigned int port
Definition: chan_jingle.c:131
static struct jingle_pvt * jingle_alloc ( struct jingle client,
const char *  from,
const char *  sid 
)
static

Definition at line 739 of file chan_jingle.c.

References ast_aji_buddy_destroy(), ast_calloc, ast_copy_string(), ast_debug, ast_free, ast_log(), ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_random(), ast_rtp_instance_new(), ast_sockaddr_from_sin, ASTOBJ_CONTAINER_FIND, ASTOBJ_UNREF, aji_client::buddies, jingle::buddy, aji_resource::cap, jingle::connection, jingle_pvt::exten, jingle_pvt::initiator, aji_version::jingle, jinglelock, jingle_pvt::lock, LOG_ERROR, LOG_WARNING, jingle::name, jingle_pvt::next, aji_resource::next, jingle::p, jingle_pvt::parent, jingle_pvt::prefs, jingle::prefs, aji_resource::resource, aji_buddy::resources, jingle_pvt::rtp, jingle_pvt::sid, and jingle_pvt::them.

Referenced by jingle_newcall(), and jingle_request().

740 {
741  struct jingle_pvt *tmp = NULL;
742  struct aji_resource *resources = NULL;
743  struct aji_buddy *buddy = NULL;
744  char idroster[200];
745  struct ast_sockaddr bindaddr_tmp;
746 
747  ast_debug(1, "The client is %s for alloc\n", client->name);
748  if (!sid && !strchr(from, '/')) { /* I started call! */
749  if (!strcasecmp(client->name, "guest")) {
750  buddy = ASTOBJ_CONTAINER_FIND(&client->connection->buddies, from);
751  if (buddy) {
752  resources = buddy->resources;
753  }
754  } else if (client->buddy)
755  resources = client->buddy->resources;
756  while (resources) {
757  if (resources->cap->jingle) {
758  break;
759  }
760  resources = resources->next;
761  }
762  if (resources)
763  snprintf(idroster, sizeof(idroster), "%s/%s", from, resources->resource);
764  else {
765  ast_log(LOG_ERROR, "no jingle capable clients to talk to.\n");
766  if (buddy) {
768  }
769  return NULL;
770  }
771  if (buddy) {
773  }
774  }
775  if (!(tmp = ast_calloc(1, sizeof(*tmp)))) {
776  return NULL;
777  }
778 
779  memcpy(&tmp->prefs, &client->prefs, sizeof(tmp->prefs));
780 
781  if (sid) {
782  ast_copy_string(tmp->sid, sid, sizeof(tmp->sid));
783  ast_copy_string(tmp->them, from, sizeof(tmp->them));
784  } else {
785  snprintf(tmp->sid, sizeof(tmp->sid), "%08lx%08lx", (unsigned long)ast_random(), (unsigned long)ast_random());
786  ast_copy_string(tmp->them, idroster, sizeof(tmp->them));
787  tmp->initiator = 1;
788  }
789  ast_sockaddr_from_sin(&bindaddr_tmp, &bindaddr);
790  tmp->rtp = ast_rtp_instance_new("asterisk", sched, &bindaddr_tmp, NULL);
791  tmp->parent = client;
792  if (!tmp->rtp) {
793  ast_log(LOG_WARNING, "Out of RTP sessions?\n");
794  ast_free(tmp);
795  return NULL;
796  }
797  ast_copy_string(tmp->exten, "s", sizeof(tmp->exten));
798  ast_mutex_init(&tmp->lock);
800  tmp->next = client->p;
801  client->p = tmp;
803  return tmp;
804 }
struct jingle_pvt * p
Definition: chan_jingle.c:145
void ast_aji_buddy_destroy(struct aji_buddy *obj)
Definition: res_jabber.c:432
#define LOG_WARNING
Definition: logger.h:144
struct jingle_pvt * next
Definition: chan_jingle.c:122
Definition: sched.c:57
struct jingle * parent
Definition: chan_jingle.c:101
#define ast_mutex_lock(a)
Definition: lock.h:155
char sid[100]
Definition: chan_jingle.c:102
Socket address structure.
Definition: netsock2.h:63
struct ast_codec_pref prefs
Definition: chan_jingle.c:146
char resource[AJI_MAX_RESJIDLEN]
Definition: jabber.h:119
ast_mutex_t lock
Definition: chan_jingle.c:99
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
char name[80]
Definition: chan_jingle.c:142
struct aji_buddy_container buddies
Definition: jabber.h:184
#define ast_sockaddr_from_sin(addr, sin)
Converts a struct sockaddr_in to a struct ast_sockaddr.
Definition: netsock2.h:642
long int ast_random(void)
Definition: utils.c:1640
char them[AJI_MAX_JIDLEN]
Definition: chan_jingle.c:103
struct aji_resource * next
Definition: jabber.h:123
#define ASTOBJ_UNREF(object, destructor)
Decrement the reference count on an object.
Definition: astobj.h:218
struct aji_buddy * buddy
Definition: chan_jingle.c:144
#define LOG_ERROR
Definition: logger.h:155
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
char exten[80]
Definition: chan_jingle.c:114
struct ast_codec_pref prefs
Definition: chan_jingle.c:109
#define ast_free(a)
Definition: astmm.h:97
#define ASTOBJ_CONTAINER_FIND(container, namestr)
Find an object in a container.
Definition: astobj.h:401
struct ast_rtp_instance * ast_rtp_instance_new(const char *engine_name, struct sched_context *sched, const struct ast_sockaddr *sa, void *data)
Create a new RTP instance.
Definition: rtp_engine.c:308
struct ast_rtp_instance * rtp
Definition: chan_jingle.c:117
static struct sockaddr_in bindaddr
Definition: chan_gtalk.c:225
struct aji_version * cap
Definition: jabber.h:121
#define ast_calloc(a, b)
Definition: astmm.h:82
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:223
static ast_mutex_t jinglelock
Definition: chan_jingle.c:170
struct aji_client * connection
Definition: chan_jingle.c:143
#define ast_mutex_init(pmutex)
Definition: lock.h:152
struct aji_resource * resources
Definition: jabber.h:137
int jingle
Definition: jabber.h:106
#define ast_mutex_unlock(a)
Definition: lock.h:156
static int jingle_answer ( struct ast_channel ast)
static

Definition at line 377 of file chan_jingle.c.

References ast_debug, ast_mutex_lock, ast_mutex_unlock, jingle_accept_call(), jingle_pvt::lock, jingle_pvt::parent, and ast_channel::tech_pvt.

378 {
379  struct jingle_pvt *p = ast->tech_pvt;
380  struct jingle *client = p->parent;
381  int res = 0;
382 
383  ast_debug(1, "Answer!\n");
384  ast_mutex_lock(&p->lock);
385  jingle_accept_call(client, p);
386  ast_mutex_unlock(&p->lock);
387  return res;
388 }
void * tech_pvt
Definition: channel.h:744
struct jingle * parent
Definition: chan_jingle.c:101
#define ast_mutex_lock(a)
Definition: lock.h:155
ast_mutex_t lock
Definition: chan_jingle.c:99
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
static int jingle_accept_call(struct jingle *client, struct jingle_pvt *p)
Definition: chan_jingle.c:299
#define ast_mutex_unlock(a)
Definition: lock.h:156
static int jingle_call ( struct ast_channel ast,
char *  dest,
int  timeout 
)
static

Initiate new call, part of PBX interface dest is the dial string.

Definition at line 1464 of file chan_jingle.c.

References ast_channel::_state, ast_copy_string(), ast_log(), ast_setstate(), AST_STATE_DOWN, AST_STATE_RESERVED, AST_STATE_RING, jingle_pvt::capability, jingle::connection, aji_client::f, jingle_create_candidates(), jingle_ringing_ack(), jingle_transmit_invite(), jingle_pvt::jointcapability, LOG_WARNING, aji_client::mid, ast_channel::name, jingle_pvt::parent, jingle_pvt::ring, jingle_pvt::ringrule, jingle_pvt::sid, ast_channel::tech_pvt, and jingle_pvt::them.

1465 {
1466  struct jingle_pvt *p = ast->tech_pvt;
1467 
1468  if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1469  ast_log(LOG_WARNING, "jingle_call called on %s, neither down nor reserved\n", ast->name);
1470  return -1;
1471  }
1472 
1474  p->jointcapability = p->capability;
1475  if (!p->ringrule) {
1476  ast_copy_string(p->ring, p->parent->connection->mid, sizeof(p->ring));
1477  p->ringrule = iks_filter_add_rule(p->parent->connection->f, jingle_ringing_ack, p,
1478  IKS_RULE_ID, p->ring, IKS_RULE_DONE);
1479  } else
1480  ast_log(LOG_WARNING, "Whoa, already have a ring rule!\n");
1481 
1483  jingle_create_candidates(p->parent, p, p->sid, p->them);
1484 
1485  return 0;
1486 }
static int jingle_ringing_ack(void *data, ikspak *pak)
Definition: chan_jingle.c:365
static int jingle_transmit_invite(struct jingle_pvt *p)
Definition: chan_jingle.c:1386
void * tech_pvt
Definition: channel.h:744
#define LOG_WARNING
Definition: logger.h:144
format_t capability
Definition: chan_jingle.c:108
format_t jointcapability
Definition: chan_jingle.c:120
char ring[10]
Definition: chan_jingle.c:104
struct jingle * parent
Definition: chan_jingle.c:101
static int jingle_create_candidates(struct jingle *client, struct jingle_pvt *p, char *sid, char *from)
Definition: chan_jingle.c:579
char sid[100]
Definition: chan_jingle.c:102
iksrule * ringrule
Definition: chan_jingle.c:105
char them[AJI_MAX_JIDLEN]
Definition: chan_jingle.c:103
enum ast_channel_state _state
Definition: channel.h:839
const ast_string_field name
Definition: channel.h:787
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:223
int ast_setstate(struct ast_channel *chan, enum ast_channel_state)
Change the state of a channel.
Definition: channel.c:7119
struct aji_client * connection
Definition: chan_jingle.c:143
char mid[6]
Definition: jabber.h:159
iksfilter * f
Definition: jabber.h:162
static int jingle_create_candidates ( struct jingle client,
struct jingle_pvt p,
char *  sid,
char *  from 
)
static

Definition at line 579 of file chan_jingle.c.

References AJI_CONNECT_HOST, AJI_CONNECT_PRFLX, AJI_CONNECT_RELAY, AJI_CONNECT_SRFLX, AJI_PROTOCOL_SSLTCP, AJI_PROTOCOL_UDP, ast_aji_increment_mid(), ast_aji_send(), ast_calloc, ast_copy_string(), ast_find_ourip(), ast_free, ast_inet_ntoa(), ast_log(), ast_random(), ast_rtp_instance_get_local_address(), ast_sockaddr_from_sin, ast_sockaddr_ipv4(), ast_sockaddr_to_sin, ast_strlen_zero(), jingle_candidate::component, jingle::connection, jingle_candidate::foundation, jingle_candidate::generation, inet_aton(), jingle_pvt::initiator, jingle_candidate::ip, aji_client::jid, JINGLE_ICE_UDP_NS, JINGLE_NEGOTIATE, JINGLE_NODE, JINGLE_NS, JINGLE_SID, jingle_pvt::laststun, LOG_ERROR, LOG_NOTICE, LOG_WARNING, aji_client::mid, jingle_candidate::network, jingle_pvt::next, jingle_candidate::next, jingle_pvt::ourcandidates, pass, jingle_candidate::password, jingle_candidate::port, jingle_candidate::priority, jingle_candidate::protocol, jingle_pvt::rtp, jingle_pvt::sid, jingle_candidate::type, and jingle_candidate::ufrag.

Referenced by jingle_call(), and jingle_newcall().

580 {
581  struct jingle_candidate *tmp;
582  struct aji_client *c = client->connection;
583  struct jingle_candidate *ours1 = NULL, *ours2 = NULL;
584  struct sockaddr_in sin = { 0, };
585  struct ast_sockaddr sin_tmp;
586  struct ast_sockaddr us_tmp;
587  struct ast_sockaddr bindaddr_tmp;
588  struct in_addr us;
589  struct in_addr externaddr;
590  iks *iq, *jingle, *content, *transport, *candidate;
591  char component[16], foundation[16], generation[16], network[16], pass[16], port[7], priority[16], user[16];
592 
593 
594  iq = iks_new("iq");
595  jingle = iks_new(JINGLE_NODE);
596  content = iks_new("content");
597  transport = iks_new("transport");
598  candidate = iks_new("candidate");
599  if (!iq || !jingle || !content || !transport || !candidate) {
600  ast_log(LOG_ERROR, "Memory allocation error\n");
601  goto safeout;
602  }
603  ours1 = ast_calloc(1, sizeof(*ours1));
604  ours2 = ast_calloc(1, sizeof(*ours2));
605  if (!ours1 || !ours2)
606  goto safeout;
607 
608  iks_insert_node(iq, jingle);
609  iks_insert_node(jingle, content);
610  iks_insert_node(content, transport);
611  iks_insert_node(transport, candidate);
612 
613  for (; p; p = p->next) {
614  if (!strcasecmp(p->sid, sid))
615  break;
616  }
617 
618  if (!p) {
619  ast_log(LOG_NOTICE, "No matching jingle session - SID %s!\n", sid);
620  goto safeout;
621  }
622 
624  ast_sockaddr_to_sin(&sin_tmp, &sin);
625  ast_sockaddr_from_sin(&bindaddr_tmp, &bindaddr);
626  ast_find_ourip(&us_tmp, &bindaddr_tmp, AF_INET);
627  us.s_addr = htonl(ast_sockaddr_ipv4(&us_tmp));
628 
629  /* Setup our first jingle candidate */
630  ours1->component = 1;
631  ours1->foundation = (unsigned int)bindaddr.sin_addr.s_addr | AJI_CONNECT_HOST | AJI_PROTOCOL_UDP;
632  ours1->generation = 0;
633  ast_copy_string(ours1->ip, ast_inet_ntoa(us), sizeof(ours1->ip));
634  ours1->network = 0;
635  ours1->port = ntohs(sin.sin_port);
636  ours1->priority = 1678246398;
637  ours1->protocol = AJI_PROTOCOL_UDP;
638  snprintf(pass, sizeof(pass), "%08lx%08lx", (unsigned long)ast_random(), (unsigned long)ast_random());
639  ast_copy_string(ours1->password, pass, sizeof(ours1->password));
640  ours1->type = AJI_CONNECT_HOST;
641  snprintf(user, sizeof(user), "%08lx%08lx", (unsigned long)ast_random(), (unsigned long)ast_random());
642  ast_copy_string(ours1->ufrag, user, sizeof(ours1->ufrag));
643  p->ourcandidates = ours1;
644 
645  if (!ast_strlen_zero(externip)) {
646  /* XXX We should really stun for this one not just go with externip XXX */
648  ast_log(LOG_WARNING, "Invalid extern IP : %s\n", externip);
649 
650  ours2->component = 1;
651  ours2->foundation = (unsigned int)externaddr.s_addr | AJI_CONNECT_PRFLX | AJI_PROTOCOL_UDP;
652  ours2->generation = 0;
653  ast_copy_string(ours2->ip, externip, sizeof(ours2->ip));
654  ours2->network = 0;
655  ours2->port = ntohs(sin.sin_port);
656  ours2->priority = 1678246397;
657  ours2->protocol = AJI_PROTOCOL_UDP;
658  snprintf(pass, sizeof(pass), "%08lx%08lx", (unsigned long)ast_random(), (unsigned long)ast_random());
659  ast_copy_string(ours2->password, pass, sizeof(ours2->password));
660  ours2->type = AJI_CONNECT_PRFLX;
661 
662  snprintf(user, sizeof(user), "%08lx%08lx", (unsigned long)ast_random(), (unsigned long)ast_random());
663  ast_copy_string(ours2->ufrag, user, sizeof(ours2->ufrag));
664  ours1->next = ours2;
665  ours2 = NULL;
666  }
667  ours1 = NULL;
668 
669  for (tmp = p->ourcandidates; tmp; tmp = tmp->next) {
670  snprintf(component, sizeof(component), "%u", tmp->component);
671  snprintf(foundation, sizeof(foundation), "%u", tmp->foundation);
672  snprintf(generation, sizeof(generation), "%u", tmp->generation);
673  snprintf(network, sizeof(network), "%u", tmp->network);
674  snprintf(port, sizeof(port), "%u", tmp->port);
675  snprintf(priority, sizeof(priority), "%u", tmp->priority);
676 
677  iks_insert_attrib(iq, "from", c->jid->full);
678  iks_insert_attrib(iq, "to", from);
679  iks_insert_attrib(iq, "type", "set");
680  iks_insert_attrib(iq, "id", c->mid);
682  iks_insert_attrib(jingle, "action", JINGLE_NEGOTIATE);
683  iks_insert_attrib(jingle, JINGLE_SID, sid);
684  iks_insert_attrib(jingle, "initiator", (p->initiator) ? c->jid->full : from);
685  iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
686  iks_insert_attrib(content, "creator", p->initiator ? "initiator" : "responder");
687  iks_insert_attrib(content, "name", "asterisk-audio-content");
688  iks_insert_attrib(transport, "xmlns", JINGLE_ICE_UDP_NS);
689  iks_insert_attrib(candidate, "component", component);
690  iks_insert_attrib(candidate, "foundation", foundation);
691  iks_insert_attrib(candidate, "generation", generation);
692  iks_insert_attrib(candidate, "ip", tmp->ip);
693  iks_insert_attrib(candidate, "network", network);
694  iks_insert_attrib(candidate, "port", port);
695  iks_insert_attrib(candidate, "priority", priority);
696  switch (tmp->protocol) {
697  case AJI_PROTOCOL_UDP:
698  iks_insert_attrib(candidate, "protocol", "udp");
699  break;
700  case AJI_PROTOCOL_SSLTCP:
701  iks_insert_attrib(candidate, "protocol", "ssltcp");
702  break;
703  }
704  iks_insert_attrib(candidate, "pwd", tmp->password);
705  switch (tmp->type) {
706  case AJI_CONNECT_HOST:
707  iks_insert_attrib(candidate, "type", "host");
708  break;
709  case AJI_CONNECT_PRFLX:
710  iks_insert_attrib(candidate, "type", "prflx");
711  break;
712  case AJI_CONNECT_RELAY:
713  iks_insert_attrib(candidate, "type", "relay");
714  break;
715  case AJI_CONNECT_SRFLX:
716  iks_insert_attrib(candidate, "type", "srflx");
717  break;
718  }
719  iks_insert_attrib(candidate, "ufrag", tmp->ufrag);
720 
721  ast_aji_send(c, iq);
722  }
723  p->laststun = 0;
724 
725 safeout:
726  if (ours1)
727  ast_free(ours1);
728  if (ours2)
729  ast_free(ours2);
730  iks_delete(iq);
731  iks_delete(jingle);
732  iks_delete(content);
733  iks_delete(transport);
734  iks_delete(candidate);
735 
736  return 1;
737 }
static char pass[512]
enum jingle_connect_type type
Definition: chan_jingle.c:135
static char externip[16]
Definition: chan_jingle.c:224
struct jingle_candidate * next
Definition: chan_jingle.c:138
unsigned int generation
Definition: chan_jingle.c:128
int ast_aji_send(struct aji_client *client, iks *x)
Wraps raw sending.
Definition: res_jabber.c:1439
int ast_find_ourip(struct ast_sockaddr *ourip, const struct ast_sockaddr *bindaddr, int family)
Find our IP address.
Definition: acl.c:744
#define LOG_WARNING
Definition: logger.h:144
struct jingle_pvt * next
Definition: chan_jingle.c:122
unsigned int network
Definition: chan_jingle.c:130
uint32_t ast_sockaddr_ipv4(const struct ast_sockaddr *addr)
Get an IPv4 address of an ast_sockaddr.
Definition: netsock2.c:394
#define JINGLE_NODE
Definition: jingle.h:37
char sid[100]
Definition: chan_jingle.c:102
Socket address structure.
Definition: netsock2.h:63
char password[100]
Definition: chan_jingle.c:134
#define JINGLE_ICE_UDP_NS
Definition: jingle.h:43
#define JINGLE_NS
Definition: jingle.h:40
#define ast_sockaddr_from_sin(addr, sin)
Converts a struct sockaddr_in to a struct ast_sockaddr.
Definition: netsock2.h:642
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:63
long int ast_random(void)
Definition: utils.c:1640
static struct ast_sockaddr externaddr
our external IP address/port for SIP sessions. externaddr.sin_addr is only set when we know we might ...
Definition: chan_sip.c:1171
enum jingle_protocol protocol
Definition: chan_jingle.c:133
#define LOG_ERROR
Definition: logger.h:155
#define JINGLE_SID
Definition: jingle.h:52
iksid * jid
Definition: jabber.h:160
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define LOG_NOTICE
Definition: logger.h:133
const char * ast_inet_ntoa(struct in_addr ia)
thread-safe replacement for inet_ntoa().
Definition: utils.c:564
#define ast_free(a)
Definition: astmm.h:97
unsigned int priority
Definition: chan_jingle.c:132
structure to hold users read from users.conf
void ast_rtp_instance_get_local_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address)
Get the local address that we are expecting RTP on.
Definition: rtp_engine.c:430
struct ast_rtp_instance * rtp
Definition: chan_jingle.c:117
static struct sockaddr_in bindaddr
Definition: chan_gtalk.c:225
#define ast_calloc(a, b)
Definition: astmm.h:82
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:223
struct jingle_candidate * ourcandidates
Definition: chan_jingle.c:111
unsigned int component
Definition: chan_jingle.c:126
struct aji_client * connection
Definition: chan_jingle.c:143
#define ast_sockaddr_to_sin(addr, sin)
Converts a struct ast_sockaddr to a struct sockaddr_in.
Definition: netsock2.h:629
#define JINGLE_NEGOTIATE
Definition: jingle.h:60
time_t laststun
Definition: chan_jingle.c:100
char ufrag[100]
Definition: chan_jingle.c:136
unsigned int foundation
Definition: chan_jingle.c:127
char mid[6]
Definition: jabber.h:159
unsigned int port
Definition: chan_jingle.c:131
int inet_aton(const char *cp, struct in_addr *pin)
void ast_aji_increment_mid(char *mid)
increments the mid field for messages and other events.
Definition: res_jabber.c:2790
static int jingle_create_member ( char *  label,
struct ast_variable var,
int  allowguest,
struct ast_codec_pref  prefs,
char *  context,
struct jingle member 
)
static

Definition at line 1708 of file chan_jingle.c.

References jingle::allowguest, aji_client::allowguest, ast_aji_get_client(), ast_copy_string(), ast_log(), ast_parse_allow_disallow(), ASTOBJ_CONTAINER_FIND, aji_client::buddies, jingle::buddy, jingle::capability, jingle::connection, jingle::context, aji_client::f, JINGLE_NS, jingle_parser(), LOG_ERROR, LOG_WARNING, ast_variable::name, jingle::name, ast_variable::next, jingle_candidate::next, jingle::prefs, prefs, jingle::user, and ast_variable::value.

Referenced by jingle_load_config().

1711 {
1712  struct aji_client *client;
1713 
1714  if (!member)
1715  ast_log(LOG_WARNING, "Out of memory.\n");
1716 
1717  ast_copy_string(member->name, label, sizeof(member->name));
1718  ast_copy_string(member->user, label, sizeof(member->user));
1719  ast_copy_string(member->context, context, sizeof(member->context));
1720  member->allowguest = allowguest;
1721  member->prefs = prefs;
1722  while (var) {
1723 #if 0
1724  struct jingle_candidate *candidate = NULL;
1725 #endif
1726  if (!strcasecmp(var->name, "username"))
1727  ast_copy_string(member->user, var->value, sizeof(member->user));
1728  else if (!strcasecmp(var->name, "disallow"))
1729  ast_parse_allow_disallow(&member->prefs, &member->capability, var->value, 0);
1730  else if (!strcasecmp(var->name, "allow"))
1731  ast_parse_allow_disallow(&member->prefs, &member->capability, var->value, 1);
1732  else if (!strcasecmp(var->name, "context"))
1733  ast_copy_string(member->context, var->value, sizeof(member->context));
1734 #if 0
1735  else if (!strcasecmp(var->name, "candidate")) {
1736  candidate = jingle_create_candidate(var->value);
1737  if (candidate) {
1738  candidate->next = member->ourcandidates;
1739  member->ourcandidates = candidate;
1740  }
1741  }
1742 #endif
1743  else if (!strcasecmp(var->name, "connection")) {
1744  if ((client = ast_aji_get_client(var->value))) {
1745  member->connection = client;
1746  iks_filter_add_rule(client->f, jingle_parser, member,
1747  IKS_RULE_TYPE, IKS_PAK_IQ,
1748  IKS_RULE_FROM_PARTIAL, member->user,
1749  IKS_RULE_NS, JINGLE_NS,
1750  IKS_RULE_DONE);
1751  } else {
1752  ast_log(LOG_ERROR, "connection referenced not found!\n");
1753  return 0;
1754  }
1755  }
1756  var = var->next;
1757  }
1758  if (member->connection && member->user)
1759  member->buddy = ASTOBJ_CONTAINER_FIND(&member->connection->buddies, member->user);
1760  else {
1761  ast_log(LOG_ERROR, "No Connection or Username!\n");
1762  }
1763  return 1;
1764 }
struct jingle_candidate * next
Definition: chan_jingle.c:138
#define LOG_WARNING
Definition: logger.h:144
static int jingle_parser(void *data, ikspak *pak)
Definition: chan_jingle.c:1635
int allowguest
Definition: chan_jingle.c:155
format_t capability
Definition: chan_jingle.c:151
struct ast_codec_pref prefs
Definition: chan_jingle.c:146
#define JINGLE_NS
Definition: jingle.h:40
const char * value
Definition: config.h:79
char name[80]
Definition: chan_jingle.c:142
struct aji_buddy_container buddies
Definition: jabber.h:184
char context[100]
Definition: chan_jingle.c:149
const char * name
Definition: config.h:77
struct aji_buddy * buddy
Definition: chan_jingle.c:144
#define LOG_ERROR
Definition: logger.h:155
static struct ast_codec_pref prefs
Definition: chan_iax2.c:258
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
struct aji_client * ast_aji_get_client(const char *name)
grab a aji_client structure by label name or JID. Bumps the refcount. (without the resource string) ...
Definition: res_jabber.c:4575
#define ASTOBJ_CONTAINER_FIND(container, namestr)
Find an object in a container.
Definition: astobj.h:401
int allowguest
Definition: jabber.h:177
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:223
struct aji_client * connection
Definition: chan_jingle.c:143
struct ast_variable * next
Definition: config.h:82
static char context[AST_MAX_CONTEXT]
Definition: chan_alsa.c:107
char user[100]
Definition: chan_jingle.c:148
iksfilter * f
Definition: jabber.h:162
int ast_parse_allow_disallow(struct ast_codec_pref *pref, format_t *mask, const char *list, int allowing)
Parse an &quot;allow&quot; or &quot;deny&quot; line in a channel or device configuration and update the capabilities mask...
Definition: frame.c:1272
static int jingle_digit ( struct ast_channel ast,
char  digit,
unsigned int  duration 
)
static

Definition at line 1324 of file chan_jingle.c.

References ast_aji_increment_mid(), ast_aji_send(), AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, ast_log(), ast_mutex_lock, ast_mutex_unlock, jingle::connection, ast_channel::dtmff, ast_frame::frametype, jingle_pvt::initiator, aji_client::jid, JINGLE_DTMF_NS, JINGLE_NS, jingle_pvt::lock, LOG_ERROR, aji_client::mid, jingle_pvt::parent, jingle_pvt::sid, ast_channel::tech_pvt, and jingle_pvt::them.

Referenced by jingle_digit_begin(), and jingle_digit_end().

1325 {
1326  struct jingle_pvt *p = ast->tech_pvt;
1327  struct jingle *client = p->parent;
1328  iks *iq, *jingle, *dtmf;
1329  char buffer[2] = {digit, '\0'};
1330  iq = iks_new("iq");
1331  jingle = iks_new("jingle");
1332  dtmf = iks_new("dtmf");
1333  if(!iq || !jingle || !dtmf) {
1334  iks_delete(iq);
1335  iks_delete(jingle);
1336  iks_delete(dtmf);
1337  ast_log(LOG_ERROR, "Did not send dtmf do to memory issue\n");
1338  return -1;
1339  }
1340 
1341  iks_insert_attrib(iq, "type", "set");
1342  iks_insert_attrib(iq, "to", p->them);
1343  iks_insert_attrib(iq, "from", client->connection->jid->full);
1344  iks_insert_attrib(iq, "id", client->connection->mid);
1346  iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
1347  iks_insert_attrib(jingle, "action", "session-info");
1348  iks_insert_attrib(jingle, "initiator", p->initiator ? client->connection->jid->full : p->them);
1349  iks_insert_attrib(jingle, "sid", p->sid);
1350  iks_insert_attrib(dtmf, "xmlns", JINGLE_DTMF_NS);
1351  iks_insert_attrib(dtmf, "code", buffer);
1352  iks_insert_node(iq, jingle);
1353  iks_insert_node(jingle, dtmf);
1354 
1355  ast_mutex_lock(&p->lock);
1356  if (ast->dtmff.frametype == AST_FRAME_DTMF_BEGIN || duration == 0) {
1357  iks_insert_attrib(dtmf, "action", "button-down");
1358  } else if (ast->dtmff.frametype == AST_FRAME_DTMF_END || duration != 0) {
1359  iks_insert_attrib(dtmf, "action", "button-up");
1360  }
1361  ast_aji_send(client->connection, iq);
1362 
1363  iks_delete(iq);
1364  iks_delete(jingle);
1365  iks_delete(dtmf);
1366  ast_mutex_unlock(&p->lock);
1367  return 0;
1368 }
int ast_aji_send(struct aji_client *client, iks *x)
Wraps raw sending.
Definition: res_jabber.c:1439
void * tech_pvt
Definition: channel.h:744
struct jingle * parent
Definition: chan_jingle.c:101
#define ast_mutex_lock(a)
Definition: lock.h:155
char sid[100]
Definition: chan_jingle.c:102
struct ast_frame dtmff
Definition: channel.h:816
#define JINGLE_NS
Definition: jingle.h:40
ast_mutex_t lock
Definition: chan_jingle.c:99
char them[AJI_MAX_JIDLEN]
Definition: chan_jingle.c:103
#define LOG_ERROR
Definition: logger.h:155
iksid * jid
Definition: jabber.h:160
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define JINGLE_DTMF_NS
Definition: jingle.h:44
struct aji_client * connection
Definition: chan_jingle.c:143
enum ast_frame_type frametype
Definition: frame.h:144
char mid[6]
Definition: jabber.h:159
void ast_aji_increment_mid(char *mid)
increments the mid field for messages and other events.
Definition: res_jabber.c:2790
#define ast_mutex_unlock(a)
Definition: lock.h:156
static int jingle_digit_begin ( struct ast_channel ast,
char  digit 
)
static

Definition at line 1370 of file chan_jingle.c.

References jingle_digit().

1371 {
1372  return jingle_digit(chan, digit, 0);
1373 }
static int jingle_digit(struct ast_channel *ast, char digit, unsigned int duration)
Definition: chan_jingle.c:1324
static int jingle_digit_end ( struct ast_channel ast,
char  digit,
unsigned int  duration 
)
static

Definition at line 1375 of file chan_jingle.c.

References jingle_digit().

1376 {
1377  return jingle_digit(ast, digit, duration);
1378 }
static int jingle_digit(struct ast_channel *ast, char digit, unsigned int duration)
Definition: chan_jingle.c:1324
static char * jingle_do_reload ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
)
static

CLI command "jingle reload".

Definition at line 1619 of file chan_jingle.c.

References CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, and ast_cli_entry::usage.

1620 {
1621  switch (cmd) {
1622  case CLI_INIT:
1623  e->command = "jingle reload";
1624  e->usage =
1625  "Usage: jingle reload\n"
1626  " Reload jingle channel driver.\n";
1627  return NULL;
1628  case CLI_GENERATE:
1629  return NULL;
1630  }
1631 
1632  return CLI_SUCCESS;
1633 }
Definition: cli.h:146
char * command
Definition: cli.h:180
const char * usage
Definition: cli.h:171
#define CLI_SUCCESS
Definition: cli.h:43
static int jingle_fixup ( struct ast_channel oldchan,
struct ast_channel newchan 
)
static

Definition at line 1270 of file chan_jingle.c.

References ast_mutex_lock, ast_mutex_unlock, jingle_pvt::lock, jingle_pvt::owner, and ast_channel::tech_pvt.

1271 {
1272  struct jingle_pvt *p = newchan->tech_pvt;
1273  ast_mutex_lock(&p->lock);
1274 
1275  if ((p->owner != oldchan)) {
1276  ast_mutex_unlock(&p->lock);
1277  return -1;
1278  }
1279  if (p->owner == oldchan)
1280  p->owner = newchan;
1281  ast_mutex_unlock(&p->lock);
1282  return 0;
1283 }
void * tech_pvt
Definition: channel.h:744
#define ast_mutex_lock(a)
Definition: lock.h:155
struct ast_channel * owner
Definition: chan_jingle.c:115
ast_mutex_t lock
Definition: chan_jingle.c:99
#define ast_mutex_unlock(a)
Definition: lock.h:156
static void jingle_free_candidates ( struct jingle_candidate candidate)
static

Definition at line 928 of file chan_jingle.c.

References ast_free, last, and jingle_candidate::next.

Referenced by jingle_free_pvt(), and jingle_load_config().

929 {
930  struct jingle_candidate *last;
931  while (candidate) {
932  last = candidate;
933  candidate = candidate->next;
934  ast_free(last);
935  }
936 }
struct jingle_candidate * next
Definition: chan_jingle.c:138
struct sla_ringing_trunk * last
Definition: app_meetme.c:965
#define ast_free(a)
Definition: astmm.h:97
static void jingle_free_pvt ( struct jingle client,
struct jingle_pvt p 
)
static

Definition at line 938 of file chan_jingle.c.

References ast_free, ast_log(), ast_rtp_instance_destroy(), jingle::connection, aji_client::f, jingle_free_candidates(), LOG_WARNING, jingle_pvt::next, jingle_pvt::owner, jingle::p, jingle_pvt::parent, jingle_pvt::ringrule, jingle_pvt::rtp, jingle_pvt::theircandidates, and jingle_pvt::vrtp.

Referenced by jingle_hangup(), and jingle_newcall().

939 {
940  struct jingle_pvt *cur, *prev = NULL;
941  cur = client->p;
942  while (cur) {
943  if (cur == p) {
944  if (prev)
945  prev->next = p->next;
946  else
947  client->p = p->next;
948  break;
949  }
950  prev = cur;
951  cur = cur->next;
952  }
953  if (p->ringrule)
954  iks_filter_remove_rule(p->parent->connection->f, p->ringrule);
955  if (p->owner)
956  ast_log(LOG_WARNING, "Uh oh, there's an owner, this is going to be messy.\n");
957  if (p->rtp)
959  if (p->vrtp)
962  ast_free(p);
963 }
struct jingle_pvt * p
Definition: chan_jingle.c:145
static void jingle_free_candidates(struct jingle_candidate *candidate)
Definition: chan_jingle.c:928
#define LOG_WARNING
Definition: logger.h:144
struct jingle_candidate * theircandidates
Definition: chan_jingle.c:110
struct jingle_pvt * next
Definition: chan_jingle.c:122
struct jingle * parent
Definition: chan_jingle.c:101
struct ast_channel * owner
Definition: chan_jingle.c:115
iksrule * ringrule
Definition: chan_jingle.c:105
struct ast_rtp_instance * vrtp
Definition: chan_jingle.c:119
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define ast_free(a)
Definition: astmm.h:97
int ast_rtp_instance_destroy(struct ast_rtp_instance *instance)
Destroy an RTP instance.
Definition: rtp_engine.c:301
struct ast_rtp_instance * rtp
Definition: chan_jingle.c:117
struct aji_client * connection
Definition: chan_jingle.c:143
iksfilter * f
Definition: jabber.h:162
static format_t jingle_get_codec ( struct ast_channel chan)
static

Definition at line 409 of file chan_jingle.c.

References jingle_pvt::peercapability, and ast_channel::tech_pvt.

410 {
411  struct jingle_pvt *p = chan->tech_pvt;
412  return p->peercapability;
413 }
void * tech_pvt
Definition: channel.h:744
format_t peercapability
Definition: chan_jingle.c:121
static enum ast_rtp_glue_result jingle_get_rtp_peer ( struct ast_channel chan,
struct ast_rtp_instance **  instance 
)
static

Definition at line 390 of file chan_jingle.c.

References ao2_ref, ast_mutex_lock, ast_mutex_unlock, AST_RTP_GLUE_RESULT_FORBID, AST_RTP_GLUE_RESULT_LOCAL, jingle_pvt::lock, jingle_pvt::rtp, and ast_channel::tech_pvt.

391 {
392  struct jingle_pvt *p = chan->tech_pvt;
394 
395  if (!p)
396  return res;
397 
398  ast_mutex_lock(&p->lock);
399  if (p->rtp) {
400  ao2_ref(p->rtp, +1);
401  *instance = p->rtp;
403  }
404  ast_mutex_unlock(&p->lock);
405 
406  return res;
407 }
void * tech_pvt
Definition: channel.h:744
#define ast_mutex_lock(a)
Definition: lock.h:155
ast_mutex_t lock
Definition: chan_jingle.c:99
#define ao2_ref(o, delta)
Definition: astobj2.h:472
ast_rtp_glue_result
Definition: rtp_engine.h:125
struct ast_rtp_instance * rtp
Definition: chan_jingle.c:117
#define ast_mutex_unlock(a)
Definition: lock.h:156
static int jingle_handle_dtmf ( struct jingle client,
ikspak *  pak 
)
static

Definition at line 494 of file chan_jingle.c.

References AST_FRAME_DTMF, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, ast_log(), ast_queue_frame(), ast_verbose(), ast_frame_subclass::integer, JINGLE_NODE, jingle_response(), JINGLE_SID, LOG_NOTICE, jingle_pvt::next, jingle_pvt::owner, jingle::p, jingle_pvt::sid, and ast_frame::subclass.

Referenced by jingle_parser().

495 {
496  struct jingle_pvt *tmp;
497  iks *dtmfnode = NULL, *dtmfchild = NULL;
498  char *dtmf;
499  /* Make sure our new call doesn't exist yet */
500  for (tmp = client->p; tmp; tmp = tmp->next) {
501  if (iks_find_with_attrib(pak->x, JINGLE_NODE, JINGLE_SID, tmp->sid))
502  break;
503  }
504 
505  if (tmp) {
506  if(iks_find_with_attrib(pak->x, "dtmf-method", "method", "rtp")) {
507  jingle_response(client,pak,
508  "feature-not-implemented xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'",
509  "unsupported-dtmf-method xmlns='http://www.xmpp.org/extensions/xep-0181.html#ns-errors'");
510  return -1;
511  }
512  if ((dtmfnode = iks_find(pak->x, "dtmf"))) {
513  if((dtmf = iks_find_attrib(dtmfnode, "code"))) {
514  if(iks_find_with_attrib(pak->x, "dtmf", "action", "button-up")) {
515  struct ast_frame f = {AST_FRAME_DTMF_BEGIN, };
516  f.subclass.integer = dtmf[0];
517  ast_queue_frame(tmp->owner, &f);
518  ast_verbose("JINGLE! DTMF-relay event received: %c\n", f.subclass.integer);
519  } else if(iks_find_with_attrib(pak->x, "dtmf", "action", "button-down")) {
520  struct ast_frame f = {AST_FRAME_DTMF_END, };
521  f.subclass.integer = dtmf[0];
522  ast_queue_frame(tmp->owner, &f);
523  ast_verbose("JINGLE! DTMF-relay event received: %c\n", f.subclass.integer);
524  } else if(iks_find_attrib(pak->x, "dtmf")) { /* 250 millasecond default */
525  struct ast_frame f = {AST_FRAME_DTMF, };
526  f.subclass.integer = dtmf[0];
527  ast_queue_frame(tmp->owner, &f);
528  ast_verbose("JINGLE! DTMF-relay event received: %c\n", f.subclass.integer);
529  }
530  }
531  } else if ((dtmfnode = iks_find_with_attrib(pak->x, JINGLE_NODE, "action", "session-info"))) {
532  if((dtmfchild = iks_find(dtmfnode, "dtmf"))) {
533  if((dtmf = iks_find_attrib(dtmfchild, "code"))) {
534  if(iks_find_with_attrib(dtmfnode, "dtmf", "action", "button-up")) {
535  struct ast_frame f = {AST_FRAME_DTMF_END, };
536  f.subclass.integer = dtmf[0];
537  ast_queue_frame(tmp->owner, &f);
538  ast_verbose("JINGLE! DTMF-relay event received: %c\n", f.subclass.integer);
539  } else if(iks_find_with_attrib(dtmfnode, "dtmf", "action", "button-down")) {
540  struct ast_frame f = {AST_FRAME_DTMF_BEGIN, };
541  f.subclass.integer = dtmf[0];
542  ast_queue_frame(tmp->owner, &f);
543  ast_verbose("JINGLE! DTMF-relay event received: %c\n", f.subclass.integer);
544  }
545  }
546  }
547  }
548  jingle_response(client, pak, NULL, NULL);
549  return 1;
550  } else
551  ast_log(LOG_NOTICE, "Whoa, didn't find call!\n");
552 
553  jingle_response(client, pak, NULL, NULL);
554  return 1;
555 }
struct jingle_pvt * p
Definition: chan_jingle.c:145
union ast_frame_subclass subclass
Definition: frame.h:146
void ast_verbose(const char *fmt,...)
Definition: logger.c:1568
#define AST_FRAME_DTMF
Definition: frame.h:128
struct jingle_pvt * next
Definition: chan_jingle.c:122
#define JINGLE_NODE
Definition: jingle.h:37
char sid[100]
Definition: chan_jingle.c:102
struct ast_channel * owner
Definition: chan_jingle.c:115
static int jingle_response(struct jingle *client, ikspak *pak, const char *reasonstr, const char *reasonstr2)
Definition: chan_jingle.c:442
int ast_queue_frame(struct ast_channel *chan, struct ast_frame *f)
Queue one or more frames to a channel&#39;s frame queue.
Definition: channel.c:1558
#define JINGLE_SID
Definition: jingle.h:52
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define LOG_NOTICE
Definition: logger.h:133
static struct ast_format f[]
Definition: format_g726.c:181
Data structure associated with a single frame of data.
Definition: frame.h:142
static int jingle_hangup ( struct ast_channel ast)
static

Hangup a call through the jingle proxy channel.

Definition at line 1489 of file chan_jingle.c.

References jingle_pvt::alreadygone, ast_mutex_lock, ast_mutex_unlock, jingle_action(), jingle_free_pvt(), JINGLE_TERMINATE, jingle_pvt::lock, jingle_pvt::owner, jingle_pvt::parent, and ast_channel::tech_pvt.

1490 {
1491  struct jingle_pvt *p = ast->tech_pvt;
1492  struct jingle *client;
1493 
1494  ast_mutex_lock(&p->lock);
1495  client = p->parent;
1496  p->owner = NULL;
1497  ast->tech_pvt = NULL;
1498  if (!p->alreadygone)
1499  jingle_action(client, p, JINGLE_TERMINATE);
1500  ast_mutex_unlock(&p->lock);
1501 
1502  jingle_free_pvt(client, p);
1503 
1504  return 0;
1505 }
int alreadygone
Definition: chan_jingle.c:107
void * tech_pvt
Definition: channel.h:744
struct jingle * parent
Definition: chan_jingle.c:101
#define ast_mutex_lock(a)
Definition: lock.h:155
struct ast_channel * owner
Definition: chan_jingle.c:115
ast_mutex_t lock
Definition: chan_jingle.c:99
#define JINGLE_TERMINATE
Definition: jingle.h:64
static int jingle_action(struct jingle *client, struct jingle_pvt *p, const char *action)
Definition: chan_jingle.c:895
static void jingle_free_pvt(struct jingle *client, struct jingle_pvt *p)
Definition: chan_jingle.c:938
#define ast_mutex_unlock(a)
Definition: lock.h:156
static int jingle_hangup_farend ( struct jingle client,
ikspak *  pak 
)
static

Definition at line 558 of file chan_jingle.c.

References jingle_pvt::alreadygone, ast_debug, ast_log(), ast_queue_hangup(), JINGLE_NODE, jingle_response(), JINGLE_SID, LOG_NOTICE, jingle::name, jingle_pvt::next, jingle_pvt::owner, jingle::p, and jingle_pvt::sid.

Referenced by jingle_parser().

559 {
560  struct jingle_pvt *tmp;
561 
562  ast_debug(1, "The client is %s\n", client->name);
563  /* Make sure our new call doesn't exist yet */
564  for (tmp = client->p; tmp; tmp = tmp->next) {
565  if (iks_find_with_attrib(pak->x, JINGLE_NODE, JINGLE_SID, tmp->sid))
566  break;
567  }
568 
569  if (tmp) {
570  tmp->alreadygone = 1;
571  if (tmp->owner)
572  ast_queue_hangup(tmp->owner);
573  } else
574  ast_log(LOG_NOTICE, "Whoa, didn't find call!\n");
575  jingle_response(client, pak, NULL, NULL);
576  return 1;
577 }
struct jingle_pvt * p
Definition: chan_jingle.c:145
int ast_queue_hangup(struct ast_channel *chan)
Queue a hangup frame.
Definition: channel.c:1569
int alreadygone
Definition: chan_jingle.c:107
struct jingle_pvt * next
Definition: chan_jingle.c:122
#define JINGLE_NODE
Definition: jingle.h:37
char sid[100]
Definition: chan_jingle.c:102
struct ast_channel * owner
Definition: chan_jingle.c:115
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
char name[80]
Definition: chan_jingle.c:142
static int jingle_response(struct jingle *client, ikspak *pak, const char *reasonstr, const char *reasonstr2)
Definition: chan_jingle.c:442
#define JINGLE_SID
Definition: jingle.h:52
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define LOG_NOTICE
Definition: logger.h:133
static int jingle_indicate ( struct ast_channel ast,
int  condition,
const void *  data,
size_t  datalen 
)
static

Definition at line 1285 of file chan_jingle.c.

References AST_CONTROL_HOLD, AST_CONTROL_UNHOLD, ast_log(), ast_moh_start(), ast_moh_stop(), and LOG_NOTICE.

1286 {
1287  int res = 0;
1288 
1289  switch (condition) {
1290  case AST_CONTROL_HOLD:
1291  ast_moh_start(ast, data, NULL);
1292  break;
1293  case AST_CONTROL_UNHOLD:
1294  ast_moh_stop(ast);
1295  break;
1296  default:
1297  ast_log(LOG_NOTICE, "Don't know how to indicate condition '%d'\n", condition);
1298  res = -1;
1299  }
1300 
1301  return res;
1302 }
void ast_moh_stop(struct ast_channel *chan)
Turn off music on hold on a given channel.
Definition: channel.c:8051
int ast_moh_start(struct ast_channel *chan, const char *mclass, const char *interpclass)
Turn on music on hold on a given channel.
Definition: channel.c:8040
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define LOG_NOTICE
Definition: logger.h:133
static int jingle_is_answered ( struct jingle client,
ikspak *  pak 
)
static

Definition at line 474 of file chan_jingle.c.

References AST_CONTROL_ANSWER, ast_debug, ast_log(), ast_queue_control(), JINGLE_NODE, jingle_response(), JINGLE_SID, LOG_NOTICE, jingle::name, jingle_pvt::next, jingle_pvt::owner, jingle::p, and jingle_pvt::sid.

Referenced by jingle_parser().

475 {
476  struct jingle_pvt *tmp;
477 
478  ast_debug(1, "The client is %s\n", client->name);
479  /* Make sure our new call doesn't exist yet */
480  for (tmp = client->p; tmp; tmp = tmp->next) {
481  if (iks_find_with_attrib(pak->x, JINGLE_NODE, JINGLE_SID, tmp->sid))
482  break;
483  }
484 
485  if (tmp) {
486  if (tmp->owner)
488  } else
489  ast_log(LOG_NOTICE, "Whoa, didn't find call!\n");
490  jingle_response(client, pak, NULL, NULL);
491  return 1;
492 }
struct jingle_pvt * p
Definition: chan_jingle.c:145
int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
Queue a control frame with payload.
Definition: channel.c:1601
struct jingle_pvt * next
Definition: chan_jingle.c:122
#define JINGLE_NODE
Definition: jingle.h:37
char sid[100]
Definition: chan_jingle.c:102
struct ast_channel * owner
Definition: chan_jingle.c:115
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
char name[80]
Definition: chan_jingle.c:142
static int jingle_response(struct jingle *client, ikspak *pak, const char *reasonstr, const char *reasonstr2)
Definition: chan_jingle.c:442
#define JINGLE_SID
Definition: jingle.h:52
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define LOG_NOTICE
Definition: logger.h:133
static int jingle_load_config ( void  )
static

Definition at line 1766 of file chan_jingle.c.

References jingle::allowguest, ast_aji_client_destroy(), ast_aji_get_clients(), ast_calloc, ast_category_browse(), ast_config_destroy(), ast_config_load, ast_copy_string(), ast_gethostbyname(), ast_jb_read_conf(), ast_log(), ast_parse_allow_disallow(), ast_true(), ast_variable_browse(), ast_variable_retrieve(), ASTOBJ_CONTAINER_LINK, ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_INIT, ASTOBJ_UNLOCK, ASTOBJ_UNREF, ASTOBJ_WRLOCK, jingle::capability, clients, CONFIG_STATUS_FILEINVALID, jingle::connection, context, jingle::context, global_jbconf, hp, JINGLE_CONFIG, jingle_create_member(), JINGLE_DTMF_NS, jingle_free_candidates(), jingle_list, jingle_member_destroy(), JINGLE_NS, jingle_parser(), LOG_WARNING, ast_variable::name, jingle::name, ast_variable::next, jingle::parkinglot, jingle::prefs, prefs, jingle::user, ast_variable::value, and var.

Referenced by load_module().

1767 {
1768  char *cat = NULL;
1769  struct ast_config *cfg = NULL;
1770  char context[100];
1771  int allowguest = 1;
1772  struct ast_variable *var;
1773  struct jingle *member;
1774  struct hostent *hp;
1775  struct ast_hostent ahp;
1776  struct ast_codec_pref prefs;
1777  struct aji_client_container *clients;
1778  struct jingle_candidate *global_candidates = NULL;
1779  struct ast_flags config_flags = { 0 };
1780 
1781  cfg = ast_config_load(JINGLE_CONFIG, config_flags);
1782  if (!cfg || cfg == CONFIG_STATUS_FILEINVALID) {
1783  return 0;
1784  }
1785 
1786  /* Copy the default jb config over global_jbconf */
1787  memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));
1788 
1789  cat = ast_category_browse(cfg, NULL);
1790  for (var = ast_variable_browse(cfg, "general"); var; var = var->next) {
1791  /* handle jb conf */
1792  if (!ast_jb_read_conf(&global_jbconf, var->name, var->value))
1793  continue;
1794 
1795  if (!strcasecmp(var->name, "allowguest"))
1796  allowguest =
1797  (ast_true(ast_variable_retrieve(cfg, "general", "allowguest"))) ? 1 : 0;
1798  else if (!strcasecmp(var->name, "disallow"))
1800  else if (!strcasecmp(var->name, "allow"))
1802  else if (!strcasecmp(var->name, "context"))
1803  ast_copy_string(context, var->value, sizeof(context));
1804  else if (!strcasecmp(var->name, "externip"))
1805  ast_copy_string(externip, var->value, sizeof(externip));
1806  else if (!strcasecmp(var->name, "bindaddr")) {
1807  if (!(hp = ast_gethostbyname(var->value, &ahp))) {
1808  ast_log(LOG_WARNING, "Invalid address: %s\n", var->value);
1809  } else {
1810  memcpy(&bindaddr.sin_addr, hp->h_addr, sizeof(bindaddr.sin_addr));
1811  }
1812  }
1813 /* Idea to allow for custom candidates */
1814 /*
1815  else if (!strcasecmp(var->name, "candidate")) {
1816  candidate = jingle_create_candidate(var->value);
1817  if (candidate) {
1818  candidate->next = global_candidates;
1819  global_candidates = candidate;
1820  }
1821  }
1822 */
1823  }
1824  while (cat) {
1825  if (strcasecmp(cat, "general")) {
1826  var = ast_variable_browse(cfg, cat);
1827  member = ast_calloc(1, sizeof(*member));
1828  ASTOBJ_INIT(member);
1829  ASTOBJ_WRLOCK(member);
1830  if (!strcasecmp(cat, "guest")) {
1831  ast_copy_string(member->name, "guest", sizeof(member->name));
1832  ast_copy_string(member->user, "guest", sizeof(member->user));
1833  ast_copy_string(member->context, context, sizeof(member->context));
1834  member->allowguest = allowguest;
1835  member->prefs = prefs;
1836  while (var) {
1837  if (!strcasecmp(var->name, "disallow"))
1838  ast_parse_allow_disallow(&member->prefs, &member->capability,
1839  var->value, 0);
1840  else if (!strcasecmp(var->name, "allow"))
1841  ast_parse_allow_disallow(&member->prefs, &member->capability,
1842  var->value, 1);
1843  else if (!strcasecmp(var->name, "context"))
1844  ast_copy_string(member->context, var->value,
1845  sizeof(member->context));
1846  else if (!strcasecmp(var->name, "parkinglot"))
1847  ast_copy_string(member->parkinglot, var->value,
1848  sizeof(member->parkinglot));
1849 /* Idea to allow for custom candidates */
1850 /*
1851  else if (!strcasecmp(var->name, "candidate")) {
1852  candidate = jingle_create_candidate(var->value);
1853  if (candidate) {
1854  candidate->next = member->ourcandidates;
1855  member->ourcandidates = candidate;
1856  }
1857  }
1858 */
1859  var = var->next;
1860  }
1861  ASTOBJ_UNLOCK(member);
1862  clients = ast_aji_get_clients();
1863  if (clients) {
1864  ASTOBJ_CONTAINER_TRAVERSE(clients, 1, {
1865  ASTOBJ_WRLOCK(iterator);
1866  ASTOBJ_WRLOCK(member);
1867  if (member->connection) {
1869  }
1870  member->connection = NULL;
1871  iks_filter_add_rule(iterator->f, jingle_parser, member, IKS_RULE_TYPE, IKS_PAK_IQ, IKS_RULE_NS, JINGLE_NS, IKS_RULE_DONE);
1872  iks_filter_add_rule(iterator->f, jingle_parser, member, IKS_RULE_TYPE, IKS_PAK_IQ, IKS_RULE_NS, JINGLE_DTMF_NS, IKS_RULE_DONE);
1873  ASTOBJ_UNLOCK(member);
1874  ASTOBJ_UNLOCK(iterator);
1875  });
1877  } else {
1878  ASTOBJ_UNLOCK(member);
1880  }
1881  } else {
1882  ASTOBJ_UNLOCK(member);
1883  if (jingle_create_member(cat, var, allowguest, prefs, context, member))
1886  }
1887  }
1888  cat = ast_category_browse(cfg, cat);
1889  }
1890  ast_config_destroy(cfg);
1891  jingle_free_candidates(global_candidates);
1892  return 1;
1893 }
static char externip[16]
Definition: chan_jingle.c:224
const char * ast_variable_retrieve(const struct ast_config *config, const char *category, const char *variable)
Gets a variable.
Definition: config.c:625
static struct ast_jb_conf global_jbconf
Definition: chan_jingle.c:84
static void jingle_free_candidates(struct jingle_candidate *candidate)
Definition: chan_jingle.c:928
#define LOG_WARNING
Definition: logger.h:144
struct ast_variable * ast_variable_browse(const struct ast_config *config, const char *category)
Goes through variables.
Definition: config.c:597
int ast_jb_read_conf(struct ast_jb_conf *conf, const char *varname, const char *value)
Sets jitterbuffer configuration property.
Definition: abstract_jb.c:577
char parkinglot[AST_MAX_CONTEXT]
Definition: chan_jingle.c:158
Structure for variables, used for configurations and for channel variables.
Definition: config.h:75
#define var
Definition: ast_expr2f.c:606
static int jingle_parser(void *data, ikspak *pak)
Definition: chan_jingle.c:1635
int allowguest
Definition: chan_jingle.c:155
#define ASTOBJ_WRLOCK(object)
Lock an ASTOBJ for writing.
Definition: astobj.h:104
format_t capability
Definition: chan_jingle.c:151
static struct jingle_container jingle_list
Definition: chan_jingle.c:226
void ast_config_destroy(struct ast_config *config)
Destroys a config.
Definition: config.c:1037
struct ast_codec_pref prefs
Definition: chan_jingle.c:146
#define JINGLE_NS
Definition: jingle.h:40
static void jingle_member_destroy(struct jingle *obj)
Definition: chan_jingle.c:228
const char * value
Definition: config.h:79
char name[80]
Definition: chan_jingle.c:142
#define ast_config_load(filename, flags)
Load a config file.
Definition: config.h:170
char context[100]
Definition: chan_jingle.c:149
char * ast_category_browse(struct ast_config *config, const char *prev)
Goes through categories.
Definition: config.c:810
#define ASTOBJ_INIT(object)
Initialize an object.
Definition: astobj.h:264
const char * name
Definition: config.h:77
#define ASTOBJ_UNREF(object, destructor)
Decrement the reference count on an object.
Definition: astobj.h:218
static struct ast_hostent ahp
Definition: chan_skinny.c:1047
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is &quot;true&quot;. This function checks to see whether a string passed to it is an indication of an &quot;true&quot; value. It checks to see if the string is &quot;yes&quot;, &quot;true&quot;, &quot;y&quot;, &quot;t&quot;, &quot;on&quot; or &quot;1&quot;.
Definition: utils.c:1533
#define ASTOBJ_CONTAINER_LINK(container, newobj)
Add an object to a container.
Definition: astobj.h:776
static int jingle_create_member(char *label, struct ast_variable *var, int allowguest, struct ast_codec_pref prefs, char *context, struct jingle *member)
Definition: chan_jingle.c:1708
static struct ast_codec_pref prefs
Definition: chan_iax2.c:258
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define ASTOBJ_CONTAINER_TRAVERSE(container, continue, eval)
Iterate through the objects in a container.
Definition: astobj.h:376
static struct ast_jb_conf default_jbconf
Definition: chan_jingle.c:76
#define ASTOBJ_UNLOCK(object)
Unlock a locked object.
Definition: astobj.h:109
#define JINGLE_CONFIG
Definition: chan_jingle.c:73
static format_t global_capability
Definition: chan_jingle.c:168
Structure used to handle boolean flags.
Definition: utils.h:200
static struct aji_client_container clients
Definition: res_jabber.c:392
static struct sockaddr_in bindaddr
Definition: chan_gtalk.c:225
void ast_aji_client_destroy(struct aji_client *obj)
Definition: res_jabber.c:410
struct hostent * ast_gethostbyname(const char *host, struct ast_hostent *hp)
Thread-safe gethostbyname function to use in Asterisk.
Definition: utils.c:195
#define ast_calloc(a, b)
Definition: astmm.h:82
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:223
#define JINGLE_DTMF_NS
Definition: jingle.h:44
struct aji_client * connection
Definition: chan_jingle.c:143
struct ast_variable * next
Definition: config.h:82
#define CONFIG_STATUS_FILEINVALID
Definition: config.h:52
static char context[AST_MAX_CONTEXT]
Definition: chan_alsa.c:107
static struct hostent * hp
Definition: chan_skinny.c:1048
General jitterbuffer configuration.
Definition: abstract_jb.h:55
char user[100]
Definition: chan_jingle.c:148
int ast_parse_allow_disallow(struct ast_codec_pref *pref, format_t *mask, const char *list, int allowing)
Parse an &quot;allow&quot; or &quot;deny&quot; line in a channel or device configuration and update the capabilities mask...
Definition: frame.c:1272
struct aji_client_container * ast_aji_get_clients(void)
Definition: res_jabber.c:4597
static void jingle_member_destroy ( struct jingle obj)
static

Definition at line 228 of file chan_jingle.c.

References ast_free.

Referenced by jingle_load_config(), jingle_parser(), and unload_module().

229 {
230  ast_free(obj);
231 }
#define ast_free(a)
Definition: astmm.h:97
static struct ast_channel* jingle_new ( struct jingle client,
struct jingle_pvt i,
int  state,
const char *  title,
const char *  linkedid 
)
static

Start new jingle channel.

Definition at line 807 of file chan_jingle.c.

References jingle::accountcode, accountcode, ast_channel::adsicpe, jingle::amaflags, ast_channel::amaflags, ast_party_caller::ani, AST_ADSI_UNAVAILABLE, ast_best_codec(), AST_CAUSE_SWITCH_CONGESTION, ast_channel_alloc(), ast_channel_set_fd(), ast_codec_choose(), ast_copy_string(), AST_FORMAT_VIDEO_MASK, ast_hangup(), ast_jb_configure(), ast_log(), ast_pbx_start(), ast_random(), ast_rtp_codecs_packetization_set(), ast_rtp_instance_fd(), ast_rtp_instance_get_codecs(), AST_STATE_DOWN, AST_STATE_RING, ast_strdup, ast_string_field_set, ast_strlen_zero(), ast_channel::caller, jingle::callgroup, ast_channel::callgroup, jingle::callingpres, jingle_pvt::capability, jingle_pvt::cid_name, jingle_pvt::cid_num, jingle::context, ast_channel::context, ast_channel::dialed, jingle_pvt::exten, ast_channel::exten, global_capability, global_jbconf, ast_channel::hangupcause, ast_party_caller::id, jingle_tech, jingle_pvt::jointcapability, language, jingle::language, LOG_WARNING, musicclass, jingle::musicclass, ast_party_id::name, ast_channel::name, ast_channel::nativeformats, ast_party_id::number, ast_party_dialed::number, jingle_pvt::owner, jingle::pickupgroup, ast_channel::pickupgroup, jingle_pvt::prefs, ast_party_name::presentation, ast_party_number::presentation, ast_channel::priority, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readformat, ast_channel::rings, jingle_pvt::rtp, str, ast_party_number::str, ast_party_dialed::str, ast_channel::tech, ast_channel::tech_pvt, jingle_pvt::them, ast_party_number::valid, jingle_pvt::vrtp, and ast_channel::writeformat.

Referenced by jingle_newcall(), and jingle_request().

808 {
809  struct ast_channel *tmp;
810  int fmt;
811  int what;
812  const char *str;
813 
814  if (title)
815  str = title;
816  else
817  str = i->them;
818  tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, "", "", "", linkedid, 0, "Jingle/%s-%04lx", str, (unsigned long)(ast_random() & 0xffff));
819  if (!tmp) {
820  ast_log(LOG_WARNING, "Unable to allocate Jingle channel structure!\n");
821  return NULL;
822  }
823  tmp->tech = &jingle_tech;
824 
825  /* Select our native format based on codec preference until we receive
826  something from another device to the contrary. */
827  if (i->jointcapability)
828  what = i->jointcapability;
829  else if (i->capability)
830  what = i->capability;
831  else
832  what = global_capability;
833 
834  /* Set Frame packetization */
835  if (i->rtp)
837 
839  fmt = ast_best_codec(tmp->nativeformats);
840 
841  if (i->rtp) {
844  }
845  if (i->vrtp) {
848  }
849  if (state == AST_STATE_RING)
850  tmp->rings = 1;
852  tmp->writeformat = fmt;
853  tmp->rawwriteformat = fmt;
854  tmp->readformat = fmt;
855  tmp->rawreadformat = fmt;
856  tmp->tech_pvt = i;
857 
858  tmp->callgroup = client->callgroup;
859  tmp->pickupgroup = client->pickupgroup;
860  tmp->caller.id.name.presentation = client->callingpres;
861  tmp->caller.id.number.presentation = client->callingpres;
862  if (!ast_strlen_zero(client->accountcode))
864  if (client->amaflags)
865  tmp->amaflags = client->amaflags;
866  if (!ast_strlen_zero(client->language))
867  ast_string_field_set(tmp, language, client->language);
868  if (!ast_strlen_zero(client->musicclass))
870  i->owner = tmp;
871  ast_copy_string(tmp->context, client->context, sizeof(tmp->context));
872  ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
873  /* Don't use ast_set_callerid() here because it will
874  * generate an unnecessary NewCallerID event */
875  if (!ast_strlen_zero(i->cid_num)) {
876  tmp->caller.ani.number.valid = 1;
877  tmp->caller.ani.number.str = ast_strdup(i->cid_num);
878  }
879  if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s")) {
880  tmp->dialed.number.str = ast_strdup(i->exten);
881  }
882  tmp->priority = 1;
883  if (i->rtp)
885  if (state != AST_STATE_DOWN && ast_pbx_start(tmp)) {
886  ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
888  ast_hangup(tmp);
889  tmp = NULL;
890  }
891 
892  return tmp;
893 }
void ast_rtp_codecs_packetization_set(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, struct ast_codec_pref *prefs)
Set codec packetization preferences.
Definition: rtp_engine.c:727
static char musicclass[MAX_MUSICCLASS]
Definition: chan_mgcp.c:155
static struct ast_channel_tech jingle_tech
PBX interface structure for channel registration.
Definition: chan_jingle.c:191
int ast_hangup(struct ast_channel *chan)
Hang up a channel.
Definition: channel.c:2804
static char accountcode[AST_MAX_ACCOUNT_CODE]
Definition: chan_iax2.c:383
int presentation
Q.931 encoded presentation-indicator encoded field.
Definition: channel.h:227
Main Channel structure associated with a channel.
Definition: channel.h:742
char * str
Subscriber phone number (Malloced)
Definition: channel.h:241
int rings
Definition: channel.h:840
char * str
Subscriber phone number (Malloced)
Definition: channel.h:336
struct ast_party_caller caller
Channel Caller ID information.
Definition: channel.h:804
int priority
Definition: channel.h:841
ast_group_t callgroup
Definition: chan_jingle.c:152
int presentation
Q.931 presentation-indicator and screening-indicator encoded fields.
Definition: channel.h:245
#define ast_strdup(a)
Definition: astmm.h:109
format_t writeformat
Definition: channel.h:854
char musicclass[MAX_MUSICCLASS]
Definition: chan_jingle.c:157
#define AST_CAUSE_SWITCH_CONGESTION
Definition: causes.h:122
static struct ast_jb_conf global_jbconf
Definition: chan_jingle.c:84
struct ast_party_name name
Subscriber name.
Definition: channel.h:290
void * tech_pvt
Definition: channel.h:744
char context[AST_MAX_CONTEXT]
Definition: channel.h:868
struct ast_rtp_codecs * ast_rtp_instance_get_codecs(struct ast_rtp_instance *instance)
Get the codecs structure of an RTP instance.
Definition: rtp_engine.c:483
#define LOG_WARNING
Definition: logger.h:144
enum ast_pbx_result ast_pbx_start(struct ast_channel *c)
Create a new thread and start the PBX.
Definition: pbx.c:5879
format_t capability
Definition: chan_jingle.c:108
format_t jointcapability
Definition: chan_jingle.c:120
format_t rawwriteformat
Definition: channel.h:856
format_t ast_best_codec(format_t fmts)
Pick the best audio codec.
Definition: channel.c:1062
format_t nativeformats
Definition: channel.h:852
const char * str
Definition: app_jack.c:144
ast_group_t pickupgroup
Definition: chan_jingle.c:153
const ast_string_field linkedid
Definition: channel.h:787
enum ast_channel_adsicpe adsicpe
Definition: channel.h:844
format_t rawreadformat
Definition: channel.h:855
ast_group_t pickupgroup
Definition: channel.h:819
struct ast_channel * owner
Definition: chan_jingle.c:115
ast_group_t callgroup
Definition: channel.h:818
struct ast_channel * ast_channel_alloc(int needqueue, int state, const char *cid_num, const char *cid_name, const char *acctcode, const char *exten, const char *context, const char *linkedid, const int amaflag, const char *name_fmt,...)
Definition: channel.c:9825
struct ast_party_id id
Caller party ID.
Definition: channel.h:370
char language[MAX_LANGUAGE]
Definition: chan_jingle.c:156
struct ast_party_id ani
Automatic Number Identification (ANI)
Definition: channel.h:377
struct ast_party_dialed::@155 number
Dialed/Called number.
char context[100]
Definition: chan_jingle.c:149
char cid_num[80]
Definition: chan_jingle.c:112
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:63
long int ast_random(void)
Definition: utils.c:1640
static char language[MAX_LANGUAGE]
Definition: chan_alsa.c:108
char them[AJI_MAX_JIDLEN]
Definition: chan_jingle.c:103
struct ast_rtp_instance * vrtp
Definition: chan_jingle.c:119
struct ast_party_dialed dialed
Dialed/Called information.
Definition: channel.h:797
int amaflags
Definition: chan_jingle.c:147
const ast_string_field name
Definition: channel.h:787
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
format_t ast_codec_choose(struct ast_codec_pref *pref, format_t formats, int find_best)
Select the best audio format according to preference list from supplied options. If &quot;find_best&quot; is no...
Definition: frame.c:1249
char accountcode[AST_MAX_ACCOUNT_CODE]
Definition: chan_jingle.c:150
char exten[80]
Definition: chan_jingle.c:114
#define AST_FORMAT_VIDEO_MASK
Definition: frame.h:290
struct ast_codec_pref prefs
Definition: chan_jingle.c:109
int ast_rtp_instance_fd(struct ast_rtp_instance *instance, int rtcp)
Get the file descriptor for an RTP session (or RTCP)
Definition: rtp_engine.c:786
static format_t global_capability
Definition: chan_jingle.c:168
void ast_channel_set_fd(struct ast_channel *chan, int which, int fd)
Definition: channel.c:2631
void ast_jb_configure(struct ast_channel *chan, const struct ast_jb_conf *conf)
Configures a jitterbuffer on a channel.
Definition: abstract_jb.c:616
struct ast_rtp_instance * rtp
Definition: chan_jingle.c:117
format_t readformat
Definition: channel.h:853
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:223
char cid_name[80]
Definition: chan_jingle.c:113
int hangupcause
Definition: channel.h:849
int callingpres
Definition: chan_jingle.c:154
int amaflags
Definition: channel.h:843
struct ast_channel_tech * tech
Definition: channel.h:743
unsigned char valid
TRUE if the number information is valid/present.
Definition: channel.h:247
char exten[AST_MAX_EXTENSION]
Definition: channel.h:869
#define ast_string_field_set(x, field, data)
Set a field to a simple string value.
Definition: stringfields.h:344
struct ast_party_number number
Subscriber phone number.
Definition: channel.h:292
static int jingle_newcall ( struct jingle client,
ikspak *  pak 
)
static

Definition at line 966 of file chan_jingle.c.

References ast_aji_client_destroy(), ast_aji_get_client(), ast_copy_string(), ast_log(), ast_mutex_lock, ast_mutex_unlock, AST_PBX_CALL_LIMIT, AST_PBX_FAILED, ast_pbx_start(), AST_PBX_SUCCESS, ast_rtp_codecs_payloads_set_m_type(), ast_rtp_codecs_payloads_set_rtpmap_type(), ast_rtp_instance_get_codecs(), ast_setstate(), AST_STATE_DOWN, AST_STATE_RING, ASTOBJ_UNREF, jingle_pvt::audio_content_name, jingle::connection, aji_client::jid, jingle_alloc(), JINGLE_AUDIO_RTP_NS, jingle_create_candidates(), jingle_free_pvt(), jingle_new(), JINGLE_NODE, jingle_response(), JINGLE_SID, JINGLE_VIDEO_RTP_NS, jingle_pvt::lock, LOG_ERROR, LOG_NOTICE, LOG_WARNING, jingle::name, jingle_pvt::next, jingle::p, jingle_pvt::rtp, jingle_pvt::sid, jingle_pvt::them, and jingle_pvt::video_content_name.

Referenced by jingle_parser().

967 {
968  struct jingle_pvt *p, *tmp = client->p;
969  struct ast_channel *chan;
970  int res;
971  iks *codec, *content, *description;
972  char *from = NULL;
973 
974  /* Make sure our new call doesn't exist yet */
975  from = iks_find_attrib(pak->x,"to");
976  if(!from)
977  from = client->connection->jid->full;
978 
979  while (tmp) {
980  if (iks_find_with_attrib(pak->x, JINGLE_NODE, JINGLE_SID, tmp->sid)) {
981  ast_log(LOG_NOTICE, "Ignoring duplicate call setup on SID %s\n", tmp->sid);
982  jingle_response(client, pak, "out-of-order", NULL);
983  return -1;
984  }
985  tmp = tmp->next;
986  }
987 
988  if (!strcasecmp(client->name, "guest")){
989  /* the guest account is not tied to any configured XMPP client,
990  let's set it now */
991  if (client->connection) {
993  }
994  client->connection = ast_aji_get_client(from);
995  if (!client->connection) {
996  ast_log(LOG_ERROR, "No XMPP client to talk to, us (partial JID) : %s\n", from);
997  return -1;
998  }
999  }
1000 
1001  p = jingle_alloc(client, pak->from->partial, iks_find_attrib(pak->query, JINGLE_SID));
1002  if (!p) {
1003  ast_log(LOG_WARNING, "Unable to allocate jingle structure!\n");
1004  return -1;
1005  }
1006  chan = jingle_new(client, p, AST_STATE_DOWN, pak->from->user, NULL);
1007  if (!chan) {
1008  jingle_free_pvt(client, p);
1009  return -1;
1010  }
1011  ast_mutex_lock(&p->lock);
1012  ast_copy_string(p->them, pak->from->full, sizeof(p->them));
1013  if (iks_find_attrib(pak->query, JINGLE_SID)) {
1014  ast_copy_string(p->sid, iks_find_attrib(pak->query, JINGLE_SID),
1015  sizeof(p->sid));
1016  }
1017 
1018  /* content points to the first <content/> tag */
1019  content = iks_child(iks_child(pak->x));
1020  while (content) {
1021  description = iks_find_with_attrib(content, "description", "xmlns", JINGLE_AUDIO_RTP_NS);
1022  if (description) {
1023  /* audio content found */
1024  codec = iks_child(iks_child(content));
1025  ast_copy_string(p->audio_content_name, iks_find_attrib(content, "name"), sizeof(p->audio_content_name));
1026 
1027  while (codec) {
1028  ast_rtp_codecs_payloads_set_m_type(ast_rtp_instance_get_codecs(p->rtp), p->rtp, atoi(iks_find_attrib(codec, "id")));
1029  ast_rtp_codecs_payloads_set_rtpmap_type(ast_rtp_instance_get_codecs(p->rtp), p->rtp, atoi(iks_find_attrib(codec, "id")), "audio", iks_find_attrib(codec, "name"), 0);
1030  codec = iks_next(codec);
1031  }
1032  }
1033 
1034  description = NULL;
1035  codec = NULL;
1036 
1037  description = iks_find_with_attrib(content, "description", "xmlns", JINGLE_VIDEO_RTP_NS);
1038  if (description) {
1039  /* video content found */
1040  codec = iks_child(iks_child(content));
1041  ast_copy_string(p->video_content_name, iks_find_attrib(content, "name"), sizeof(p->video_content_name));
1042 
1043  while (codec) {
1044  ast_rtp_codecs_payloads_set_m_type(ast_rtp_instance_get_codecs(p->rtp), p->rtp, atoi(iks_find_attrib(codec, "id")));
1045  ast_rtp_codecs_payloads_set_rtpmap_type(ast_rtp_instance_get_codecs(p->rtp), p->rtp, atoi(iks_find_attrib(codec, "id")), "audio", iks_find_attrib(codec, "name"), 0);
1046  codec = iks_next(codec);
1047  }
1048  }
1049 
1050  content = iks_next(content);
1051  }
1052 
1053  ast_mutex_unlock(&p->lock);
1055  res = ast_pbx_start(chan);
1056 
1057  switch (res) {
1058  case AST_PBX_FAILED:
1059  ast_log(LOG_WARNING, "Failed to start PBX :(\n");
1060  jingle_response(client, pak, "service-unavailable", NULL);
1061  break;
1062  case AST_PBX_CALL_LIMIT:
1063  ast_log(LOG_WARNING, "Failed to start PBX (call limit reached) \n");
1064  jingle_response(client, pak, "service-unavailable", NULL);
1065  break;
1066  case AST_PBX_SUCCESS:
1067  jingle_response(client, pak, NULL, NULL);
1068  jingle_create_candidates(client, p,
1069  iks_find_attrib(pak->query, JINGLE_SID),
1070  iks_find_attrib(pak->x, "from"));
1071  /* nothing to do */
1072  break;
1073  }
1074 
1075  return 1;
1076 }
struct jingle_pvt * p
Definition: chan_jingle.c:145
Main Channel structure associated with a channel.
Definition: channel.h:742
static struct jingle_pvt * jingle_alloc(struct jingle *client, const char *from, const char *sid)
Definition: chan_jingle.c:739
struct ast_rtp_codecs * ast_rtp_instance_get_codecs(struct ast_rtp_instance *instance)
Get the codecs structure of an RTP instance.
Definition: rtp_engine.c:483
#define LOG_WARNING
Definition: logger.h:144
enum ast_pbx_result ast_pbx_start(struct ast_channel *c)
Create a new thread and start the PBX.
Definition: pbx.c:5879
char audio_content_name[100]
Definition: chan_jingle.c:116
struct jingle_pvt * next
Definition: chan_jingle.c:122
#define JINGLE_NODE
Definition: jingle.h:37
#define ast_mutex_lock(a)
Definition: lock.h:155
static int jingle_create_candidates(struct jingle *client, struct jingle_pvt *p, char *sid, char *from)
Definition: chan_jingle.c:579
#define JINGLE_VIDEO_RTP_NS
Definition: jingle.h:42
char sid[100]
Definition: chan_jingle.c:102
#define JINGLE_AUDIO_RTP_NS
Definition: jingle.h:41
ast_mutex_t lock
Definition: chan_jingle.c:99
char name[80]
Definition: chan_jingle.c:142
static int jingle_response(struct jingle *client, ikspak *pak, const char *reasonstr, const char *reasonstr2)
Definition: chan_jingle.c:442
char them[AJI_MAX_JIDLEN]
Definition: chan_jingle.c:103
int ast_rtp_codecs_payloads_set_rtpmap_type(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload, char *mimetype, char *mimesubtype, enum ast_rtp_options options)
Record payload information that was seen in an a=rtpmap: SDP line.
Definition: rtp_engine.c:597
char video_content_name[100]
Definition: chan_jingle.c:118
#define ASTOBJ_UNREF(object, destructor)
Decrement the reference count on an object.
Definition: astobj.h:218
#define LOG_ERROR
Definition: logger.h:155
#define JINGLE_SID
Definition: jingle.h:52
iksid * jid
Definition: jabber.h:160
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define LOG_NOTICE
Definition: logger.h:133
struct aji_client * ast_aji_get_client(const char *name)
grab a aji_client structure by label name or JID. Bumps the refcount. (without the resource string) ...
Definition: res_jabber.c:4575
struct ast_rtp_instance * rtp
Definition: chan_jingle.c:117
void ast_aji_client_destroy(struct aji_client *obj)
Definition: res_jabber.c:410
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:223
int ast_setstate(struct ast_channel *chan, enum ast_channel_state)
Change the state of a channel.
Definition: channel.c:7119
struct aji_client * connection
Definition: chan_jingle.c:143
static void jingle_free_pvt(struct jingle *client, struct jingle_pvt *p)
Definition: chan_jingle.c:938
static struct ast_channel * jingle_new(struct jingle *client, struct jingle_pvt *i, int state, const char *title, const char *linkedid)
Start new jingle channel.
Definition: chan_jingle.c:807
void ast_rtp_codecs_payloads_set_m_type(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload)
Record payload information that was seen in an m= SDP line.
Definition: rtp_engine.c:532
#define ast_mutex_unlock(a)
Definition: lock.h:156
static int jingle_parser ( void *  data,
ikspak *  pak 
)
static

Definition at line 1635 of file chan_jingle.c.

References ast_debug, ast_log(), ASTOBJ_REF, ASTOBJ_UNREF, JINGLE_ACCEPT, jingle_add_candidate(), jingle_handle_dtmf(), jingle_hangup_farend(), JINGLE_INFO, JINGLE_INITIATE, jingle_is_answered(), jingle_member_destroy(), JINGLE_NEGOTIATE, jingle_newcall(), JINGLE_NODE, JINGLE_TERMINATE, and LOG_NOTICE.

Referenced by jingle_create_member(), and jingle_load_config().

1636 {
1637  struct jingle *client = ASTOBJ_REF((struct jingle *) data);
1638  ast_log(LOG_NOTICE, "Filter matched\n");
1639 
1640  if (iks_find_with_attrib(pak->x, JINGLE_NODE, "action", JINGLE_INITIATE)) {
1641  /* New call */
1642  jingle_newcall(client, pak);
1643  } else if (iks_find_with_attrib(pak->x, JINGLE_NODE, "action", JINGLE_NEGOTIATE)) {
1644  ast_debug(3, "About to add candidate!\n");
1645  jingle_add_candidate(client, pak);
1646  ast_debug(3, "Candidate Added!\n");
1647  } else if (iks_find_with_attrib(pak->x, JINGLE_NODE, "action", JINGLE_ACCEPT)) {
1648  jingle_is_answered(client, pak);
1649  } else if (iks_find_with_attrib(pak->x, JINGLE_NODE, "action", JINGLE_INFO)) {
1650  jingle_handle_dtmf(client, pak);
1651  } else if (iks_find_with_attrib(pak->x, JINGLE_NODE, "action", JINGLE_TERMINATE)) {
1652  jingle_hangup_farend(client, pak);
1653  } else if (iks_find_with_attrib(pak->x, JINGLE_NODE, "action", "reject")) {
1654  jingle_hangup_farend(client, pak);
1655  }
1657  return IKS_FILTER_EAT;
1658 }
static int jingle_add_candidate(struct jingle *client, ikspak *pak)
Definition: chan_jingle.c:1106
#define JINGLE_NODE
Definition: jingle.h:37
static void jingle_member_destroy(struct jingle *obj)
Definition: chan_jingle.c:228
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
static int jingle_hangup_farend(struct jingle *client, ikspak *pak)
Definition: chan_jingle.c:558
#define ASTOBJ_UNREF(object, destructor)
Decrement the reference count on an object.
Definition: astobj.h:218
#define JINGLE_TERMINATE
Definition: jingle.h:64
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define LOG_NOTICE
Definition: logger.h:133
static int jingle_handle_dtmf(struct jingle *client, ikspak *pak)
Definition: chan_jingle.c:494
#define JINGLE_ACCEPT
Definition: jingle.h:57
#define JINGLE_INITIATE
Definition: jingle.h:55
static int jingle_is_answered(struct jingle *client, ikspak *pak)
Definition: chan_jingle.c:474
#define JINGLE_INFO
Definition: jingle.h:63
static int jingle_newcall(struct jingle *client, ikspak *pak)
Definition: chan_jingle.c:966
#define JINGLE_NEGOTIATE
Definition: jingle.h:60
#define ASTOBJ_REF(object)
Increment an object reference count.
Definition: astobj.h:201
static struct ast_frame * jingle_read ( struct ast_channel ast)
static

Definition at line 1212 of file chan_jingle.c.

References ast_mutex_lock, ast_mutex_unlock, jingle_rtp_read(), jingle_pvt::lock, and ast_channel::tech_pvt.

1213 {
1214  struct ast_frame *fr;
1215  struct jingle_pvt *p = ast->tech_pvt;
1216 
1217  ast_mutex_lock(&p->lock);
1218  fr = jingle_rtp_read(ast, p);
1219  ast_mutex_unlock(&p->lock);
1220  return fr;
1221 }
void * tech_pvt
Definition: channel.h:744
#define ast_mutex_lock(a)
Definition: lock.h:155
ast_mutex_t lock
Definition: chan_jingle.c:99
static struct ast_frame * jingle_rtp_read(struct ast_channel *ast, struct jingle_pvt *p)
Definition: chan_jingle.c:1184
Data structure associated with a single frame of data.
Definition: frame.h:142
#define ast_mutex_unlock(a)
Definition: lock.h:156
static struct ast_channel * jingle_request ( const char *  type,
format_t  format,
const struct ast_channel requestor,
void *  data,
int *  cause 
)
static

Part of PBX interface.

Definition at line 1508 of file chan_jingle.c.

References ast_aji_client_destroy(), ast_aji_get_client(), ast_log(), AST_STATE_DOWN, ast_strdupa, ASTOBJ_UNLOCK, ASTOBJ_UNREF, ASTOBJ_WRLOCK, jingle::connection, find_jingle(), jingle_alloc(), jingle_new(), ast_channel::linkedid, LOG_ERROR, LOG_WARNING, jingle::name, and strsep().

1509 {
1510  struct jingle_pvt *p = NULL;
1511  struct jingle *client = NULL;
1512  char *sender = NULL, *to = NULL, *s = NULL;
1513  struct ast_channel *chan = NULL;
1514 
1515  if (data) {
1516  s = ast_strdupa(data);
1517  sender = strsep(&s, "/");
1518  if (sender && (sender[0] != '\0')) {
1519  to = strsep(&s, "/");
1520  }
1521  if (!to) {
1522  ast_log(LOG_ERROR, "Bad arguments in Jingle Dialstring: %s\n", (char*) data);
1523  return NULL;
1524  }
1525  }
1526 
1527  client = find_jingle(to, sender);
1528  if (!client) {
1529  ast_log(LOG_WARNING, "Could not find recipient.\n");
1530  return NULL;
1531  }
1532  if (!strcasecmp(client->name, "guest")){
1533  /* the guest account is not tied to any configured XMPP client,
1534  let's set it now */
1535  if (client->connection) {
1537  }
1538  client->connection = ast_aji_get_client(sender);
1539  if (!client->connection) {
1540  ast_log(LOG_ERROR, "No XMPP client to talk to, us (partial JID) : %s\n", sender);
1541  return NULL;
1542  }
1543  }
1544 
1545  ASTOBJ_WRLOCK(client);
1546  p = jingle_alloc(client, to, NULL);
1547  if (p)
1548  chan = jingle_new(client, p, AST_STATE_DOWN, to, requestor ? requestor->linkedid : NULL);
1549  ASTOBJ_UNLOCK(client);
1550 
1551  return chan;
1552 }
Main Channel structure associated with a channel.
Definition: channel.h:742
static struct jingle_pvt * jingle_alloc(struct jingle *client, const char *from, const char *sid)
Definition: chan_jingle.c:739
char * strsep(char **str, const char *delims)
#define LOG_WARNING
Definition: logger.h:144
#define ASTOBJ_WRLOCK(object)
Lock an ASTOBJ for writing.
Definition: astobj.h:104
const char * data
Definition: channel.h:755
const ast_string_field linkedid
Definition: channel.h:787
char name[80]
Definition: chan_jingle.c:142
#define ASTOBJ_UNREF(object, destructor)
Decrement the reference count on an object.
Definition: astobj.h:218
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: utils.h:663
#define LOG_ERROR
Definition: logger.h:155
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
struct aji_client * ast_aji_get_client(const char *name)
grab a aji_client structure by label name or JID. Bumps the refcount. (without the resource string) ...
Definition: res_jabber.c:4575
#define ASTOBJ_UNLOCK(object)
Unlock a locked object.
Definition: astobj.h:109
void ast_aji_client_destroy(struct aji_client *obj)
Definition: res_jabber.c:410
static struct jingle * find_jingle(char *name, char *connection)
Definition: chan_jingle.c:233
struct aji_client * connection
Definition: chan_jingle.c:143
static struct ast_channel * jingle_new(struct jingle *client, struct jingle_pvt *i, int state, const char *title, const char *linkedid)
Start new jingle channel.
Definition: chan_jingle.c:807
static int jingle_response ( struct jingle client,
ikspak *  pak,
const char *  reasonstr,
const char *  reasonstr2 
)
static

Definition at line 442 of file chan_jingle.c.

References ast_aji_send(), jingle::connection, and aji_client::jid.

Referenced by jingle_handle_dtmf(), jingle_hangup_farend(), jingle_is_answered(), and jingle_newcall().

443 {
444  iks *response = NULL, *error = NULL, *reason = NULL;
445  int res = -1;
446 
447  response = iks_new("iq");
448  if (response) {
449  iks_insert_attrib(response, "type", "result");
450  iks_insert_attrib(response, "from", client->connection->jid->full);
451  iks_insert_attrib(response, "to", iks_find_attrib(pak->x, "from"));
452  iks_insert_attrib(response, "id", iks_find_attrib(pak->x, "id"));
453  if (reasonstr) {
454  error = iks_new("error");
455  if (error) {
456  iks_insert_attrib(error, "type", "cancel");
457  reason = iks_new(reasonstr);
458  if (reason)
459  iks_insert_node(error, reason);
460  iks_insert_node(response, error);
461  }
462  }
463  ast_aji_send(client->connection, response);
464  res = 0;
465  }
466 
467  iks_delete(reason);
468  iks_delete(error);
469  iks_delete(response);
470 
471  return res;
472 }
int ast_aji_send(struct aji_client *client, iks *x)
Wraps raw sending.
Definition: res_jabber.c:1439
iksid * jid
Definition: jabber.h:160
struct aji_client * connection
Definition: chan_jingle.c:143
static int jingle_ringing_ack ( void *  data,
ikspak *  pak 
)
static

Definition at line 365 of file chan_jingle.c.

References AST_CONTROL_RINGING, ast_queue_control(), jingle::connection, aji_client::f, jingle_pvt::owner, jingle_pvt::parent, and jingle_pvt::ringrule.

Referenced by jingle_call().

366 {
367  struct jingle_pvt *p = data;
368 
369  if (p->ringrule)
370  iks_filter_remove_rule(p->parent->connection->f, p->ringrule);
371  p->ringrule = NULL;
372  if (p->owner)
374  return IKS_FILTER_EAT;
375 }
int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
Queue a control frame with payload.
Definition: channel.c:1601
struct jingle * parent
Definition: chan_jingle.c:101
struct ast_channel * owner
Definition: chan_jingle.c:115
iksrule * ringrule
Definition: chan_jingle.c:105
struct aji_client * connection
Definition: chan_jingle.c:143
iksfilter * f
Definition: jabber.h:162
static struct ast_frame* jingle_rtp_read ( struct ast_channel ast,
struct jingle_pvt p 
)
static

Definition at line 1184 of file chan_jingle.c.

References ast_debug, AST_FORMAT_AUDIO_MASK, AST_FORMAT_VIDEO_MASK, AST_FRAME_VOICE, ast_getformatname(), ast_null_frame, ast_rtp_instance_read(), ast_set_read_format(), ast_set_write_format(), ast_frame_subclass::codec, f, ast_frame::frametype, jingle_update_stun(), ast_channel::nativeformats, jingle_pvt::owner, jingle_pvt::parent, ast_channel::readformat, jingle_pvt::rtp, ast_frame::subclass, and ast_channel::writeformat.

Referenced by jingle_read().

1185 {
1186  struct ast_frame *f;
1187 
1188  if (!p->rtp)
1189  return &ast_null_frame;
1190  f = ast_rtp_instance_read(p->rtp, 0);
1191  jingle_update_stun(p->parent, p);
1192  if (p->owner) {
1193  /* We already hold the channel lock */
1194  if (f->frametype == AST_FRAME_VOICE) {
1196  ast_debug(1, "Oooh, format changed to %s\n", ast_getformatname(f->subclass.codec));
1197  p->owner->nativeformats =
1201  }
1202 /* if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
1203  f = ast_dsp_process(p->owner, p->vad, f);
1204  if (f && (f->frametype == AST_FRAME_DTMF))
1205  ast_debug(1, "* Detected inband DTMF '%c'\n", f->subclass.codec);
1206  } */
1207  }
1208  }
1209  return f;
1210 }
union ast_frame_subclass subclass
Definition: frame.h:146
struct ast_frame ast_null_frame
Definition: frame.c:131
format_t writeformat
Definition: channel.h:854
static int jingle_update_stun(struct jingle *client, struct jingle_pvt *p)
Definition: chan_jingle.c:1078
struct jingle * parent
Definition: chan_jingle.c:101
format_t nativeformats
Definition: channel.h:852
format_t codec
Definition: frame.h:137
struct ast_channel * owner
Definition: chan_jingle.c:115
int ast_set_write_format(struct ast_channel *chan, format_t format)
Sets write format on channel chan Set write format for channel to whichever component of &quot;format&quot; is ...
Definition: channel.c:5307
int ast_set_read_format(struct ast_channel *chan, format_t format)
Sets read format on channel chan Set read format for channel to whichever component of &quot;format&quot; is be...
Definition: channel.c:5301
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
char * ast_getformatname(format_t format)
Get the name of a format.
Definition: frame.c:578
#define AST_FORMAT_VIDEO_MASK
Definition: frame.h:290
#define AST_FORMAT_AUDIO_MASK
Definition: frame.h:274
static struct ast_format f[]
Definition: format_g726.c:181
struct ast_rtp_instance * rtp
Definition: chan_jingle.c:117
format_t readformat
Definition: channel.h:853
Data structure associated with a single frame of data.
Definition: frame.h:142
enum ast_frame_type frametype
Definition: frame.h:144
struct ast_frame * ast_rtp_instance_read(struct ast_rtp_instance *instance, int rtcp)
Receive a frame over RTP.
Definition: rtp_engine.c:379
static int jingle_sendhtml ( struct ast_channel ast,
int  subclass,
const char *  data,
int  datalen 
)
static

Definition at line 1380 of file chan_jingle.c.

References ast_log(), and LOG_NOTICE.

1381 {
1382  ast_log(LOG_NOTICE, "XXX Implement jingle sendhtml XXX\n");
1383 
1384  return -1;
1385 }
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define LOG_NOTICE
Definition: logger.h:133
static int jingle_sendtext ( struct ast_channel ast,
const char *  text 
)
static

Definition at line 1304 of file chan_jingle.c.

References ast_aji_send_chat(), ast_log(), jingle::connection, LOG_ERROR, jingle_pvt::parent, ast_channel::tech_pvt, and jingle_pvt::them.

1305 {
1306  int res = 0;
1307  struct aji_client *client = NULL;
1308  struct jingle_pvt *p = chan->tech_pvt;
1309 
1310 
1311  if (!p->parent) {
1312  ast_log(LOG_ERROR, "Parent channel not found\n");
1313  return -1;
1314  }
1315  if (!p->parent->connection) {
1316  ast_log(LOG_ERROR, "XMPP client not found\n");
1317  return -1;
1318  }
1319  client = p->parent->connection;
1320  res = ast_aji_send_chat(client, p->them, text);
1321  return res;
1322 }
struct jingle * parent
Definition: chan_jingle.c:101
char * text
Definition: app_queue.c:1091
int ast_aji_send_chat(struct aji_client *client, const char *address, const char *message)
sends messages.
Definition: res_jabber.c:2582
char them[AJI_MAX_JIDLEN]
Definition: chan_jingle.c:103
#define LOG_ERROR
Definition: logger.h:155
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
struct aji_client * connection
Definition: chan_jingle.c:143
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,
format_t  codecs,
int  nat_active 
)
static

Definition at line 415 of file chan_jingle.c.

References ast_mutex_lock, ast_mutex_unlock, jingle_pvt::lock, and ast_channel::tech_pvt.

416 {
417  struct jingle_pvt *p;
418 
419  p = chan->tech_pvt;
420  if (!p)
421  return -1;
422  ast_mutex_lock(&p->lock);
423 
424 /* if (rtp)
425  ast_rtp_get_peer(rtp, &p->redirip);
426  else
427  memset(&p->redirip, 0, sizeof(p->redirip));
428  p->redircodecs = codecs; */
429 
430  /* Reset lastrtprx timer */
431  ast_mutex_unlock(&p->lock);
432  return 0;
433 }
void * tech_pvt
Definition: channel.h:744
#define ast_mutex_lock(a)
Definition: lock.h:155
ast_mutex_t lock
Definition: chan_jingle.c:99
#define ast_mutex_unlock(a)
Definition: lock.h:156
static char * jingle_show_channels ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
)
static

CLI command "jingle show channels".

Definition at line 1555 of file chan_jingle.c.

References AJI_MAX_JIDLEN, ast_cli_args::argc, ast_cli(), ast_copy_string(), ast_getformatname(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_UNLOCK, ASTOBJ_WRLOCK, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, FORMAT, jingle_list, jinglelock, LOG_WARNING, ast_channel::name, jingle_pvt::next, jingle_pvt::owner, ast_channel::readformat, jingle_pvt::them, ast_cli_entry::usage, and ast_channel::writeformat.

1556 {
1557 #define FORMAT "%-30.30s %-30.30s %-15.15s %-5.5s %-5.5s \n"
1558  struct jingle_pvt *p;
1559  struct ast_channel *chan;
1560  int numchans = 0;
1561  char them[AJI_MAX_JIDLEN];
1562  char *jid = NULL;
1563  char *resource = NULL;
1564 
1565  switch (cmd) {
1566  case CLI_INIT:
1567  e->command = "jingle show channels";
1568  e->usage =
1569  "Usage: jingle show channels\n"
1570  " Shows current state of the Jingle channels.\n";
1571  return NULL;
1572  case CLI_GENERATE:
1573  return NULL;
1574  }
1575 
1576  if (a->argc != 3)
1577  return CLI_SHOWUSAGE;
1578 
1580  ast_cli(a->fd, FORMAT, "Channel", "Jabber ID", "Resource", "Read", "Write");
1582  ASTOBJ_WRLOCK(iterator);
1583  p = iterator->p;
1584  while(p) {
1585  chan = p->owner;
1586  ast_copy_string(them, p->them, sizeof(them));
1587  jid = them;
1588  resource = strchr(them, '/');
1589  if (!resource)
1590  resource = "None";
1591  else {
1592  *resource = '\0';
1593  resource ++;
1594  }
1595  if (chan)
1596  ast_cli(a->fd, FORMAT,
1597  chan->name,
1598  jid,
1599  resource,
1602  );
1603  else
1604  ast_log(LOG_WARNING, "No available channel\n");
1605  numchans ++;
1606  p = p->next;
1607  }
1608  ASTOBJ_UNLOCK(iterator);
1609  });
1610 
1612 
1613  ast_cli(a->fd, "%d active jingle channel%s\n", numchans, (numchans != 1) ? "s" : "");
1614  return CLI_SUCCESS;
1615 #undef FORMAT
1616 }
Main Channel structure associated with a channel.
Definition: channel.h:742
format_t writeformat
Definition: channel.h:854
const int argc
Definition: cli.h:154
#define LOG_WARNING
Definition: logger.h:144
struct jingle_pvt * next
Definition: chan_jingle.c:122
Definition: cli.h:146
#define ASTOBJ_WRLOCK(object)
Lock an ASTOBJ for writing.
Definition: astobj.h:104
#define ast_mutex_lock(a)
Definition: lock.h:155
void ast_cli(int fd, const char *fmt,...)
Definition: cli.c:105
static struct jingle_container jingle_list
Definition: chan_jingle.c:226
struct ast_channel * owner
Definition: chan_jingle.c:115
const int fd
Definition: cli.h:153
char them[AJI_MAX_JIDLEN]
Definition: chan_jingle.c:103
#define FORMAT
char * ast_getformatname(format_t format)
Get the name of a format.
Definition: frame.c:578
#define CLI_SHOWUSAGE
Definition: cli.h:44
const ast_string_field name
Definition: channel.h:787
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define AJI_MAX_JIDLEN
Definition: jabber.h:73
#define ASTOBJ_CONTAINER_TRAVERSE(container, continue, eval)
Iterate through the objects in a container.
Definition: astobj.h:376
#define ASTOBJ_UNLOCK(object)
Unlock a locked object.
Definition: astobj.h:109
char * command
Definition: cli.h:180
const char * usage
Definition: cli.h:171
#define CLI_SUCCESS
Definition: cli.h:43
format_t readformat
Definition: channel.h:853
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:223
static ast_mutex_t jinglelock
Definition: chan_jingle.c:170
#define ast_mutex_unlock(a)
Definition: lock.h:156
static int jingle_transmit_invite ( struct jingle_pvt p)
static

Definition at line 1386 of file chan_jingle.c.

References ast_aji_increment_mid(), ast_aji_send(), ast_copy_string(), jingle_pvt::audio_content_name, jingle::connection, aji_client::jid, aji_client::jingle, JINGLE_AUDIO_RTP_NS, JINGLE_ICE_UDP_NS, JINGLE_INITIATE, JINGLE_NODE, JINGLE_NS, JINGLE_SID, aji_client::mid, jingle_pvt::parent, jingle_pvt::sid, and jingle_pvt::them.

Referenced by jingle_call().

1387 {
1388  struct jingle *aux = NULL;
1389  struct aji_client *client = NULL;
1390  iks *iq, *jingle, *content, *description, *transport;
1391  iks *payload_eg711u, *payload_pcmu;
1392 
1393  aux = p->parent;
1394  client = aux->connection;
1395  iq = iks_new("iq");
1396  jingle = iks_new(JINGLE_NODE);
1397  content = iks_new("content");
1398  description = iks_new("description");
1399  transport = iks_new("transport");
1400  payload_pcmu = iks_new("payload-type");
1401  payload_eg711u = iks_new("payload-type");
1402 
1403  ast_copy_string(p->audio_content_name, "asterisk-audio-content", sizeof(p->audio_content_name));
1404 
1405  iks_insert_attrib(iq, "type", "set");
1406  iks_insert_attrib(iq, "to", p->them);
1407  iks_insert_attrib(iq, "from", client->jid->full);
1408  iks_insert_attrib(iq, "id", client->mid);
1409  ast_aji_increment_mid(client->mid);
1410  iks_insert_attrib(jingle, "action", JINGLE_INITIATE);
1411  iks_insert_attrib(jingle, JINGLE_SID, p->sid);
1412  iks_insert_attrib(jingle, "initiator", client->jid->full);
1413  iks_insert_attrib(jingle, "xmlns", JINGLE_NS);
1414 
1415  /* For now, we only send one audio based content */
1416  iks_insert_attrib(content, "creator", "initiator");
1417  iks_insert_attrib(content, "name", p->audio_content_name);
1418  iks_insert_attrib(content, "profile", "RTP/AVP");
1419  iks_insert_attrib(description, "xmlns", JINGLE_AUDIO_RTP_NS);
1420  iks_insert_attrib(transport, "xmlns", JINGLE_ICE_UDP_NS);
1421  iks_insert_attrib(payload_pcmu, "id", "0");
1422  iks_insert_attrib(payload_pcmu, "name", "PCMU");
1423  iks_insert_attrib(payload_eg711u, "id", "100");
1424  iks_insert_attrib(payload_eg711u, "name", "EG711U");
1425  iks_insert_node(description, payload_pcmu);
1426  iks_insert_node(description, payload_eg711u);
1427  iks_insert_node(content, description);
1428  iks_insert_node(content, transport);
1429  iks_insert_node(jingle, content);
1430  iks_insert_node(iq, jingle);
1431 
1432  ast_aji_send(client, iq);
1433 
1434  iks_delete(iq);
1435  iks_delete(jingle);
1436  iks_delete(content);
1437  iks_delete(description);
1438  iks_delete(transport);
1439  iks_delete(payload_eg711u);
1440  iks_delete(payload_pcmu);
1441  return 0;
1442 }
int ast_aji_send(struct aji_client *client, iks *x)
Wraps raw sending.
Definition: res_jabber.c:1439
char audio_content_name[100]
Definition: chan_jingle.c:116
struct jingle * parent
Definition: chan_jingle.c:101
#define JINGLE_NODE
Definition: jingle.h:37
char sid[100]
Definition: chan_jingle.c:102
#define JINGLE_AUDIO_RTP_NS
Definition: jingle.h:41
#define JINGLE_ICE_UDP_NS
Definition: jingle.h:43
#define JINGLE_NS
Definition: jingle.h:40
char them[AJI_MAX_JIDLEN]
Definition: chan_jingle.c:103
#define JINGLE_SID
Definition: jingle.h:52
iksid * jid
Definition: jabber.h:160
#define JINGLE_INITIATE
Definition: jingle.h:55
void * jingle
Definition: jabber.h:186
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:223
struct aji_client * connection
Definition: chan_jingle.c:143
char mid[6]
Definition: jabber.h:159
void ast_aji_increment_mid(char *mid)
increments the mid field for messages and other events.
Definition: res_jabber.c:2790
static int jingle_update_stun ( struct jingle client,
struct jingle_pvt p 
)
static

Definition at line 1078 of file chan_jingle.c.

References ast_gethostbyname(), ast_rtp_instance_stun_request(), ast_sockaddr_from_sin, hp, jingle_candidate::ip, jingle_pvt::laststun, jingle_candidate::next, jingle_pvt::ourcandidates, jingle_candidate::port, jingle_pvt::rtp, jingle_pvt::theircandidates, and jingle_candidate::ufrag.

Referenced by jingle_add_candidate(), and jingle_rtp_read().

1079 {
1080  struct jingle_candidate *tmp;
1081  struct hostent *hp;
1082  struct ast_hostent ahp;
1083  struct sockaddr_in sin;
1084  struct ast_sockaddr sin_tmp;
1085 
1086  if (time(NULL) == p->laststun)
1087  return 0;
1088 
1089  tmp = p->theircandidates;
1090  p->laststun = time(NULL);
1091  while (tmp) {
1092  char username[256];
1093  hp = ast_gethostbyname(tmp->ip, &ahp);
1094  sin.sin_family = AF_INET;
1095  memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
1096  sin.sin_port = htons(tmp->port);
1097  snprintf(username, sizeof(username), "%s:%s", tmp->ufrag, p->ourcandidates->ufrag);
1098 
1099  ast_sockaddr_from_sin(&sin_tmp, &sin);
1100  ast_rtp_instance_stun_request(p->rtp, &sin_tmp, username);
1101  tmp = tmp->next;
1102  }
1103  return 1;
1104 }
struct jingle_candidate * next
Definition: chan_jingle.c:138
struct jingle_candidate * theircandidates
Definition: chan_jingle.c:110
Socket address structure.
Definition: netsock2.h:63
void ast_rtp_instance_stun_request(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username)
Request that the underlying RTP engine send a STUN BIND request.
Definition: rtp_engine.c:1749
#define ast_sockaddr_from_sin(addr, sin)
Converts a struct sockaddr_in to a struct ast_sockaddr.
Definition: netsock2.h:642
static struct ast_hostent ahp
Definition: chan_skinny.c:1047
struct ast_rtp_instance * rtp
Definition: chan_jingle.c:117
struct hostent * ast_gethostbyname(const char *host, struct ast_hostent *hp)
Thread-safe gethostbyname function to use in Asterisk.
Definition: utils.c:195
struct jingle_candidate * ourcandidates
Definition: chan_jingle.c:111
time_t laststun
Definition: chan_jingle.c:100
static struct hostent * hp
Definition: chan_skinny.c:1048
char ufrag[100]
Definition: chan_jingle.c:136
unsigned int port
Definition: chan_jingle.c:131
static int jingle_write ( struct ast_channel ast,
struct ast_frame f 
)
static

Send frame to media channel (rtp)

Definition at line 1224 of file chan_jingle.c.

References AST_FRAME_IMAGE, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_getformatname(), ast_getformatname_multiple(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_rtp_instance_write(), ast_frame_subclass::codec, ast_frame::frametype, jingle_pvt::lock, LOG_WARNING, ast_channel::nativeformats, ast_channel::readformat, jingle_pvt::rtp, ast_frame::subclass, ast_channel::tech_pvt, jingle_pvt::vrtp, and ast_channel::writeformat.

1225 {
1226  struct jingle_pvt *p = ast->tech_pvt;
1227  int res = 0;
1228  char buf[256];
1229 
1230  switch (frame->frametype) {
1231  case AST_FRAME_VOICE:
1232  if (!(frame->subclass.codec & ast->nativeformats)) {
1234  "Asked to transmit frame type %s, while native formats is %s (read/write = %s/%s)\n",
1235  ast_getformatname(frame->subclass.codec),
1236  ast_getformatname_multiple(buf, sizeof(buf), ast->nativeformats),
1239  return 0;
1240  }
1241  if (p) {
1242  ast_mutex_lock(&p->lock);
1243  if (p->rtp) {
1244  res = ast_rtp_instance_write(p->rtp, frame);
1245  }
1246  ast_mutex_unlock(&p->lock);
1247  }
1248  break;
1249  case AST_FRAME_VIDEO:
1250  if (p) {
1251  ast_mutex_lock(&p->lock);
1252  if (p->vrtp) {
1253  res = ast_rtp_instance_write(p->vrtp, frame);
1254  }
1255  ast_mutex_unlock(&p->lock);
1256  }
1257  break;
1258  case AST_FRAME_IMAGE:
1259  return 0;
1260  break;
1261  default:
1262  ast_log(LOG_WARNING, "Can't send %u type frames with Jingle write\n",
1263  frame->frametype);
1264  return 0;
1265  }
1266 
1267  return res;
1268 }
format_t writeformat
Definition: channel.h:854
void * tech_pvt
Definition: channel.h:744
#define LOG_WARNING
Definition: logger.h:144
int ast_rtp_instance_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
Send a frame out over RTP.
Definition: rtp_engine.c:374
#define ast_mutex_lock(a)
Definition: lock.h:155
format_t nativeformats
Definition: channel.h:852
ast_mutex_t lock
Definition: chan_jingle.c:99
struct ast_rtp_instance * vrtp
Definition: chan_jingle.c:119
char * ast_getformatname(format_t format)
Get the name of a format.
Definition: frame.c:578
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
struct ast_rtp_instance * rtp
Definition: chan_jingle.c:117
format_t readformat
Definition: channel.h:853
char * ast_getformatname_multiple(char *buf, size_t size, format_t format)
Get the names of a set of formats.
Definition: frame.c:591
#define ast_mutex_unlock(a)
Definition: lock.h:156
static int load_module ( void  )
static

Load module into PBX, register channel.

Definition at line 1896 of file chan_jingle.c.

References __ourip, ARRAY_LEN, ast_channel_register(), ast_cli_register_multiple(), ast_find_ourip(), ast_log(), ast_module_helper(), AST_MODULE_LOAD_DECLINE, ast_rtp_glue_register, ast_sockaddr_from_sin, ast_sockaddr_ipv4(), ASTOBJ_CONTAINER_INIT, free, io_context_create(), JINGLE_CONFIG, jingle_list, jingle_load_config(), LOG_ERROR, LOG_WARNING, and sched_context_create().

1897 {
1898  struct ast_sockaddr ourip_tmp;
1899  struct ast_sockaddr bindaddr_tmp;
1900 
1901  char *jabber_loaded = ast_module_helper("", "res_jabber.so", 0, 0, 0, 0);
1902  free(jabber_loaded);
1903  if (!jabber_loaded) {
1904  /* Dependency module has a different name, if embedded */
1905  jabber_loaded = ast_module_helper("", "res_jabber", 0, 0, 0, 0);
1906  free(jabber_loaded);
1907  if (!jabber_loaded) {
1908  ast_log(LOG_ERROR, "chan_jingle.so depends upon res_jabber.so\n");
1909  return AST_MODULE_LOAD_DECLINE;
1910  }
1911  }
1912 
1914  if (!jingle_load_config()) {
1915  ast_log(LOG_ERROR, "Unable to read config file %s. Not loading module.\n", JINGLE_CONFIG);
1916  return AST_MODULE_LOAD_DECLINE;
1917  }
1918 
1920  if (!sched) {
1921  ast_log(LOG_WARNING, "Unable to create schedule context\n");
1922  }
1923 
1924  io = io_context_create();
1925  if (!io) {
1926  ast_log(LOG_WARNING, "Unable to create I/O context\n");
1927  }
1928 
1929  bindaddr.sin_family = AF_INET;
1930  ast_sockaddr_from_sin(&bindaddr_tmp, &bindaddr);
1931  if (ast_find_ourip(&ourip_tmp, &bindaddr_tmp, AF_INET)) {
1932  ast_log(LOG_WARNING, "Unable to get own IP address, Jingle disabled\n");
1933  return 0;
1934  }
1935  __ourip.s_addr = htonl(ast_sockaddr_ipv4(&ourip_tmp));
1936 
1939  /* Make sure we can register our channel type */
1941  ast_log(LOG_ERROR, "Unable to register channel class %s\n", channel_type);
1942  return -1;
1943  }
1944  return 0;
1945 }
static struct ast_channel_tech jingle_tech
PBX interface structure for channel registration.
Definition: chan_jingle.c:191
#define ARRAY_LEN(a)
Definition: isdn_lib.c:42
static struct in_addr __ourip
Definition: chan_jingle.c:216
int ast_find_ourip(struct ast_sockaddr *ourip, const struct ast_sockaddr *bindaddr, int family)
Find our IP address.
Definition: acl.c:744
#define LOG_WARNING
Definition: logger.h:144
#define ast_rtp_glue_register(glue)
Definition: rtp_engine.h:476
Definition: sched.c:57
uint32_t ast_sockaddr_ipv4(const struct ast_sockaddr *addr)
Get an IPv4 address of an ast_sockaddr.
Definition: netsock2.c:394
int ast_channel_register(const struct ast_channel_tech *tech)
Register a channel technology (a new channel driver) Called by a channel module to register the kind ...
Definition: channel.c:907
static int jingle_load_config(void)
Definition: chan_jingle.c:1766
static struct jingle_container jingle_list
Definition: chan_jingle.c:226
Socket address structure.
Definition: netsock2.h:63
static const char channel_type[]
Definition: chan_jingle.c:166
#define ASTOBJ_CONTAINER_INIT(container)
Initialize a container.
Definition: astobj.h:752
#define ast_sockaddr_from_sin(addr, sin)
Converts a struct sockaddr_in to a struct ast_sockaddr.
Definition: netsock2.h:642
char * ast_module_helper(const char *line, const char *word, int pos, int state, int rpos, int needsreload)
Match modules names for the Asterisk cli.
Definition: loader.c:626
#define LOG_ERROR
Definition: logger.h:155
static struct ast_rtp_glue jingle_rtp_glue
Definition: chan_jingle.c:435
#define free(a)
Definition: astmm.h:94
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
static struct io_context * io
Definition: chan_jingle.c:215
#define JINGLE_CONFIG
Definition: chan_jingle.c:73
static struct sockaddr_in bindaddr
Definition: chan_gtalk.c:225
struct sched_context * sched_context_create(void)
New schedule context.
Definition: sched.c:246
int ast_cli_register_multiple(struct ast_cli_entry *e, int len)
Register multiple commands.
Definition: cli.c:2167
static struct ast_cli_entry jingle_cli[]
Definition: chan_jingle.c:218
struct io_context * io_context_create(void)
Creates a context Create a context for I/O operations Basically mallocs an IO structure and sets up s...
Definition: io.c:76
static int reload ( void  )
static

Reload module.

Definition at line 1948 of file chan_jingle.c.

1949 {
1950  return 0;
1951 }
static int unload_module ( void  )
static

Unload the jingle channel from Asterisk.

Definition at line 1954 of file chan_jingle.c.

References ARRAY_LEN, ast_channel_unregister(), ast_cli_unregister_multiple(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_rtp_glue_unregister(), ast_softhangup(), AST_SOFTHANGUP_APPUNLOAD, ASTOBJ_CONTAINER_DESTROY, ASTOBJ_CONTAINER_DESTROYALL, ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_UNLOCK, ASTOBJ_WRLOCK, jingle_list, jingle_member_destroy(), jinglelock, LOG_WARNING, jingle_pvt::next, and jingle_pvt::owner.

1955 {
1956  struct jingle_pvt *privates = NULL;
1958  /* First, take us out of the channel loop */
1961 
1962  if (!ast_mutex_lock(&jinglelock)) {
1963  /* Hangup all interfaces if they have an owner */
1965  ASTOBJ_WRLOCK(iterator);
1966  privates = iterator->p;
1967  while(privates) {
1968  if (privates->owner)
1970  privates = privates->next;
1971  }
1972  iterator->p = NULL;
1973  ASTOBJ_UNLOCK(iterator);
1974  });
1976  } else {
1977  ast_log(LOG_WARNING, "Unable to lock the monitor\n");
1978  return -1;
1979  }
1982  return 0;
1983 }
static struct ast_channel_tech jingle_tech
PBX interface structure for channel registration.
Definition: chan_jingle.c:191
#define ARRAY_LEN(a)
Definition: isdn_lib.c:42
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
Unregister multiple commands.
Definition: cli.c:2177
void ast_channel_unregister(const struct ast_channel_tech *tech)
Unregister a channel technology.
Definition: channel.c:938
#define LOG_WARNING
Definition: logger.h:144
struct jingle_pvt * next
Definition: chan_jingle.c:122
#define ASTOBJ_WRLOCK(object)
Lock an ASTOBJ for writing.
Definition: astobj.h:104
#define ast_mutex_lock(a)
Definition: lock.h:155
static struct jingle_container jingle_list
Definition: chan_jingle.c:226
struct ast_channel * owner
Definition: chan_jingle.c:115
static void jingle_member_destroy(struct jingle *obj)
Definition: chan_jingle.c:228
int ast_softhangup(struct ast_channel *chan, int reason)
Softly hangup up a channel.
Definition: channel.c:2746
#define ASTOBJ_CONTAINER_DESTROY(container)
Destroy a container.
Definition: astobj.h:765
#define ASTOBJ_CONTAINER_DESTROYALL(container, destructor)
Empty a container.
Definition: astobj.h:453
static struct ast_rtp_glue jingle_rtp_glue
Definition: chan_jingle.c:435
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
#define ASTOBJ_CONTAINER_TRAVERSE(container, continue, eval)
Iterate through the objects in a container.
Definition: astobj.h:376
#define ASTOBJ_UNLOCK(object)
Unlock a locked object.
Definition: astobj.h:109
static ast_mutex_t jinglelock
Definition: chan_jingle.c:170
int ast_rtp_glue_unregister(struct ast_rtp_glue *glue)
Unregister RTP glue.
Definition: rtp_engine.c:266
static struct ast_cli_entry jingle_cli[]
Definition: chan_jingle.c:218
#define ast_mutex_unlock(a)
Definition: lock.h:156

Variable Documentation

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Jingle Channel Driver" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "ac1f6a56484a8820659555499174e588" , .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DRIVER, }
static

Definition at line 1990 of file chan_jingle.c.

struct in_addr __ourip
static

Definition at line 216 of file chan_jingle.c.

Referenced by load_module().

Definition at line 1990 of file chan_jingle.c.

struct sockaddr_in bindaddr = { 0, }
static

The address we bind to

Definition at line 212 of file chan_jingle.c.

const char channel_type[] = "Jingle"
static

Definition at line 166 of file chan_jingle.c.

struct ast_jb_conf default_jbconf
static

Global jitterbuffer configuration - by default, jb is disabled

Definition at line 76 of file chan_jingle.c.

const char desc[] = "Jingle Channel"
static

Definition at line 165 of file chan_jingle.c.

char externip[16]
static

Definition at line 224 of file chan_jingle.c.

Definition at line 168 of file chan_jingle.c.

Referenced by jingle_new().

struct ast_jb_conf global_jbconf
static

Definition at line 84 of file chan_jingle.c.

Referenced by jingle_load_config(), and jingle_new().

struct io_context* io
static

The IO context

Definition at line 215 of file chan_jingle.c.

struct ast_cli_entry jingle_cli[]
static
Initial value:
= {
AST_CLI_DEFINE(jingle_do_reload, "Reload Jingle configuration"),
AST_CLI_DEFINE(jingle_show_channels, "Show Jingle channels"),
}
#define AST_CLI_DEFINE(fn, txt,...)
Definition: cli.h:191
static char * jingle_do_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
CLI command &quot;jingle reload&quot;.
Definition: chan_jingle.c:1619
static char * jingle_show_channels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
CLI command &quot;jingle show channels&quot;.
Definition: chan_jingle.c:1555

Definition at line 218 of file chan_jingle.c.

struct jingle_container jingle_list
static
struct ast_rtp_glue jingle_rtp_glue
static

Definition at line 435 of file chan_jingle.c.

struct ast_channel_tech jingle_tech
static

PBX interface structure for channel registration.

Definition at line 191 of file chan_jingle.c.

Referenced by jingle_new().

ast_mutex_t jinglelock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 }
static

Protect the interface list (of jingle_pvt's)

Definition at line 170 of file chan_jingle.c.

Referenced by jingle_alloc(), jingle_show_channels(), and unload_module().

struct sched_context* sched
static

The scheduling context

Definition at line 214 of file chan_jingle.c.