libDingaLing Library

Data Structures
struct	ldl_candidate
	A structure to store a jingle candidate. More...
struct	ldl_payload
	A structure to store a jingle payload. More...
Defines
#define	ldl_test_flag(obj, flag)   ((obj)->flags & flag)
	Test for the existance of a flag on an arbitary object.
#define	ldl_set_flag(obj, flag)   (obj)->flags |= (flag)
	Set a flag on an arbitrary object.
#define	ldl_clear_flag(obj, flag)   (obj)->flags &= ~(flag)
	Clear a flag on an arbitrary object.
#define	ldl_set_flag_locked(obj, flag)
	Set a flag on an arbitrary object while locked.
#define	ldl_clear_flag_locked(obj, flag)   apr_thread_mutex_lock(obj->flag_mutex); (obj)->flags &= ~(flag); apr_thread_mutex_unlock(obj->flag_mutex);
	Clear a flag on an arbitrary object.
#define	ldl_copy_flags(dest, src, flags)   (dest)->flags &= ~(flags); (dest)->flags |= ((src)->flags & (flags))
	Copy flags from one arbitrary object to another.
#define	ldl_strlen_zero(s)   (s && *s != '\0') ? 0 : 1
	Test for NULL or zero length string.
Functions
ldl_status	ldl_session_destroy (ldl_session_t **session_p)
	Destroy a Jingle Session.
char *	ldl_session_get_value (ldl_session_t *session, char *key)
	Get a value from a session.
void	ldl_session_set_value (ldl_session_t *session, char *key, char *val)
	Set a value on a session.
ldl_status	ldl_session_create (ldl_session_t **session_p, ldl_handle_t *handle, char *id, char *them, char *me)
	Create a Jingle Session.
char *	ldl_session_get_id (ldl_session_t *session)
	get the id of a session
char *	ldl_session_get_caller (ldl_session_t *session)
	Get the caller name of a session.
char *	ldl_session_get_callee (ldl_session_t *session)
	Get the callee name of a session.
void	ldl_session_set_ip (ldl_session_t *session, char *ip)
	Set the ip of a session.
char *	ldl_session_get_ip (ldl_session_t *session)
	Get the ip of a session.
void	ldl_session_set_private (ldl_session_t *session, void *private_data)
	Set a private pointer to associate with the session.
void *	ldl_session_get_private (ldl_session_t *session)
	Get a private pointer from a session.
void	ldl_session_accept_candidate (ldl_session_t *session, ldl_candidate_t *candidate)
	Accept a candidate.
void	ldl_global_set_logger (ldl_logger_t logger)
	Set a custom logger.
char *	ldl_handle_probe (ldl_handle_t *handle, char *id, char *from, char *buf, unsigned int len)
	Perform a probe on a given id to resolve the proper Jingle Resource.
char *	ldl_handle_disco (ldl_handle_t *handle, char *id, char *from, char *buf, unsigned int len)
	Perform a discovery on a given id to resolve the proper Jingle Resource.
unsigned int	ldl_session_terminate (ldl_session_t *session)
	Signal a termination request on a given session.
void *	ldl_handle_get_private (ldl_handle_t *handle)
	Get the private data of a connection handle.
void	ldl_session_send_msg (ldl_session_t *session, char *subject, char *body)
	Send a message to a session.
void	ldl_handle_send_presence (ldl_handle_t *handle, char *from, char *to, char *type, char *rpid, char *message)
	Send a presence notification to a target.
void	ldl_handle_send_vcard (ldl_handle_t *handle, char *from, char *to, char *id, char *vcard)
	Send a vcard.
void	ldl_handle_send_msg (ldl_handle_t *handle, char *from, char *to, char *subject, char *body)
	Send a message.
unsigned int	ldl_session_candidates (ldl_session_t *session, ldl_candidate_t *candidates, unsigned int clen)
	Offer candidates to a potential session.
unsigned int	ldl_session_describe (ldl_session_t *session, ldl_payload_t *payloads, unsigned int plen, ldl_description_t description)
	Initiate or Accept a new session and provide transport options.
ldl_state_t	ldl_session_get_state (ldl_session_t *session)
	get a session's state
ldl_status	ldl_session_get_candidates (ldl_session_t *session, ldl_candidate_t **candidates, unsigned int *len)
	get the candidates
ldl_status	ldl_session_get_payloads (ldl_session_t *session, ldl_payload_t **payloads, unsigned int *len)
	get the payloads
ldl_status	ldl_global_init (int debug)
	Initilize libDingaLing.
ldl_status	ldl_global_destroy (void)
	Destroy libDingaLing.
void	ldl_global_set_log_stream (FILE *log_stream)
	Set the log stream.
ldl_status	ldl_handle_init (ldl_handle_t **handle, char *login, char *password, char *server, ldl_user_flag_t flags, char *status_msg, ldl_loop_callback_t loop_callback, ldl_session_callback_t session_callback, ldl_response_callback_t response_callback, void *private_info)
	Initilize a new libDingaLing handle.
void	ldl_handle_run (ldl_handle_t *handle)
	Run a libDingaLing handle.
void	ldl_handle_stop (ldl_handle_t *handle)
	Stop a libDingaLing handle.
ldl_status	ldl_handle_destroy (ldl_handle_t **handle)
	Destroy a libDingaLing handle.
void	ldl_handle_set_log_stream (ldl_handle_t *handle, FILE *log_stream)
	Set the log stream on a handle.

---

Define Documentation

#define ldl_clear_flag (  obj, flag   )     (obj)->flags &= ~(flag)

Clear a flag on an arbitrary object. Parameters: obj  the object to test flag  the or'd list of flags to clear

#define ldl_clear_flag_locked (  obj, flag   )     apr_thread_mutex_lock(obj->flag_mutex); (obj)->flags &= ~(flag); apr_thread_mutex_unlock(obj->flag_mutex);

Clear a flag on an arbitrary object. Parameters: obj  the object to test flag  the or'd list of flags to clear

#define ldl_copy_flags (  dest, src, flags   )     (dest)->flags &= ~(flags); (dest)->flags |= ((src)->flags & (flags))

Copy flags from one arbitrary object to another. Parameters: dest  the object to copy the flags to src  the object to copy the flags from flags  the flags to copy

#define ldl_set_flag (  obj, flag   )     (obj)->flags |= (flag)

Set a flag on an arbitrary object. Parameters: obj  the object to set the flags on flag  the or'd list of flags to set

#define ldl_set_flag_locked (  obj, flag   )

Value: assert(obj->flag_mutex != NULL);\ apr_thread_mutex_lock(obj->flag_mutex);\ (obj)->flags |= (flag);\ apr_thread_mutex_unlock(obj->flag_mutex); Set a flag on an arbitrary object while locked. Parameters: obj  the object to set the flags on flag  the or'd list of flags to set

#define ldl_strlen_zero (  s   )     (s && *s != '\0') ? 0 : 1

Test for NULL or zero length string. Parameters: s  the string to test Returns: true value if the string is NULL or zero length

#define ldl_test_flag (  obj, flag   )     ((obj)->flags & flag)

Test for the existance of a flag on an arbitary object. Parameters: obj  the object to test flag  the or'd list of flags to test Returns: true value if the object has the flags defined

---

Function Documentation

ldl_status ldl_global_destroy (  void   )

Destroy libDingaLing. Returns: success or failure { if (ldl_test_flag(&globals, LDL_FLAG_INIT)) { return LDL_STATUS_FALSE; } apr_pool_destroy(globals.memory_pool); ldl_clear_flag(&globals, LDL_FLAG_INIT); apr_terminate(); return LDL_STATUS_SUCCESS; }

ldl_status ldl_global_init (  int  debug  )

Initilize libDingaLing. Parameters: debug  debug level Returns: success or failure { if (ldl_test_flag((&globals), LDL_FLAG_INIT)) { return LDL_STATUS_FALSE; } if (apr_initialize() != LDL_STATUS_SUCCESS) { apr_terminate(); return LDL_STATUS_MEMERR; } memset(&globals, 0, sizeof(globals)); if (apr_pool_create(&globals.memory_pool, NULL) != LDL_STATUS_SUCCESS) { globals.logger(DL_LOG_DEBUG, "Could not allocate memory pool\n"); return LDL_STATUS_MEMERR; } apr_thread_mutex_create(&globals.flag_mutex, APR_THREAD_MUTEX_NESTED, globals.memory_pool); globals.log_stream = stdout; globals.debug = debug; globals.id = 300; globals.logger = default_logger; ldl_set_flag_locked((&globals), LDL_FLAG_INIT); return LDL_STATUS_SUCCESS; }

void ldl_global_set_log_stream (  FILE *  log_stream  )

Set the log stream. Parameters: log_stream  the new log stream { assert(ldl_test_flag(&globals, LDL_FLAG_INIT)); globals.log_stream = log_stream; }

void ldl_global_set_logger (  ldl_logger_t  logger  )

Set a custom logger. Parameters: logger  the logger function { globals.logger = logger; }

ldl_status ldl_handle_destroy (  ldl_handle_t **  handle  )

Destroy a libDingaLing handle. Parameters: handle  the Dingaling handle to destroy Returns: success or failure { apr_pool_t *pool = (*handle)->pool; ldl_flush_queue(*handle, 1); apr_pool_destroy(pool); *handle = NULL; return LDL_STATUS_SUCCESS; }

char* ldl_handle_disco (  ldl_handle_t *  handle, char *  id, char *  from, char *  buf, unsigned int  len )

Perform a discovery on a given id to resolve the proper Jingle Resource. Parameters: handle  the connection handle to use. id  the id to probe from  the from string buf  a string to store the result len  the size in bytes of the string Returns: a pointer to buf if a successful lookup was made otherwise NULL { iks *iq, *query, *msg; char *lid = NULL; struct ldl_buffer buffer; apr_time_t started; unsigned int elapsed; char *notice = "Call Me!"; int again = 0; unsigned int myid; char idbuf[80]; myid = next_id(); snprintf(idbuf, sizeof(idbuf), "%u", myid); buffer.buf = buf; buffer.len = len; buffer.hit = 0; if ((iq = iks_new("iq"))) { if ((query = iks_insert(iq, "query"))) { iks_insert_attrib(iq, "type", "get"); iks_insert_attrib(iq, "to", id); iks_insert_attrib(iq,"from", from); iks_insert_attrib(iq, "id", idbuf); iks_insert_attrib(query, "xmlns", "http://jabber.org/protocol/disco#info"); } else { iks_delete(iq); globals.logger(DL_LOG_DEBUG, "Memory ERROR!\n"); return NULL; } } else { globals.logger(DL_LOG_DEBUG, "Memory ERROR!\n"); return NULL; } apr_hash_set(handle->probe_hash, id, APR_HASH_KEY_STRING, &buffer); msg = iks_make_s10n (IKS_TYPE_SUBSCRIBE, id, notice); apr_queue_push(handle->queue, msg); msg = iks_make_s10n (IKS_TYPE_SUBSCRIBED, id, notice); apr_queue_push(handle->queue, msg); apr_queue_push(handle->queue, iq); //schedule_packet(handle, next_id(), pres, LDL_RETRY); started = apr_time_now(); for(;;) { elapsed = (unsigned int)((apr_time_now() - started) / 1000); if (elapsed > 5000 && ! again) { msg = iks_make_s10n (IKS_TYPE_SUBSCRIBE, id, notice); apr_queue_push(handle->queue, msg); again++; } if (elapsed > 10000) { break; } if (buffer.hit) { lid = buffer.buf; break; } ldl_yield(1000); } apr_hash_set(handle->probe_hash, id, APR_HASH_KEY_STRING, NULL); return lid; }

void* ldl_handle_get_private (  ldl_handle_t *  handle  )

Get the private data of a connection handle. Parameters: handle  the conection handle Returns: the requested data { return handle->private_info; }

ldl_status ldl_handle_init (  ldl_handle_t **  handle, char *  login, char *  password, char *  server, ldl_user_flag_t  flags, char *  status_msg, ldl_loop_callback_t  loop_callback, ldl_session_callback_t  session_callback, ldl_response_callback_t  response_callback, void *  private_info )

Initilize a new libDingaLing handle. Parameters: handle  the Dingaling handle to initialize login  the xmpp login password  the password server  the server address flags  user flags status_msg  status message to advertise loop_callback  optional loop callback session_callback  function to call on session signalling response_callback  function to call on responses private_info  optional pointer to private data Returns: success or failure { apr_pool_t *pool; assert(ldl_test_flag(&globals, LDL_FLAG_INIT)); *handle = NULL; if ((apr_pool_create(&pool, globals.memory_pool)) != LDL_STATUS_SUCCESS) { return LDL_STATUS_MEMERR; } if (!login) { globals.logger(DL_LOG_ERR, "No login supplied!\n"); return LDL_STATUS_FALSE; } if (!password) { globals.logger(DL_LOG_ERR, "No password supplied!\n"); return LDL_STATUS_FALSE; } if ((*handle = apr_palloc(pool, sizeof(ldl_handle_t)))) { ldl_handle_t *new_handle = *handle; memset(new_handle, 0, sizeof(ldl_handle_t)); new_handle->log_stream = globals.log_stream; new_handle->login = apr_pstrdup(pool, login); new_handle->password = apr_pstrdup(pool, password); if (server) { char *p; new_handle->server = apr_pstrdup(pool, server); if ((p = strchr(new_handle->server, ':'))) { *p++ = '\0'; new_handle->port = (uint16_t)atoi(p); } } if (status_msg) { new_handle->status_msg = apr_pstrdup(pool, status_msg); } if (loop_callback) { new_handle->loop_callback = loop_callback; } if (session_callback) { new_handle->session_callback = session_callback; } if (response_callback) { new_handle->response_callback = response_callback; } new_handle->private_info = private_info; new_handle->pool = pool; new_handle->flags |= flags; apr_queue_create(&new_handle->queue, LDL_HANDLE_QLEN, new_handle->pool); apr_queue_create(&new_handle->retry_queue, LDL_HANDLE_QLEN, new_handle->pool); new_handle->features |= IKS_STREAM_BIND|IKS_STREAM_SESSION; if (new_handle->flags & LDL_FLAG_SASL_PLAIN) { new_handle->features |= IKS_STREAM_SASL_PLAIN; } else if (new_handle->flags & LDL_FLAG_SASL_MD5) { new_handle->features |= IKS_STREAM_SASL_MD5; } new_handle->sessions = apr_hash_make(new_handle->pool); new_handle->retry_hash = apr_hash_make(new_handle->pool); new_handle->probe_hash = apr_hash_make(new_handle->pool); new_handle->sub_hash = apr_hash_make(new_handle->pool); apr_thread_mutex_create(&new_handle->lock, APR_THREAD_MUTEX_NESTED, new_handle->pool); apr_thread_mutex_create(&new_handle->flag_mutex, APR_THREAD_MUTEX_NESTED, new_handle->pool); return LDL_STATUS_SUCCESS; } return LDL_STATUS_FALSE; }

char* ldl_handle_probe (  ldl_handle_t *  handle, char *  id, char *  from, char *  buf, unsigned int  len )

Perform a probe on a given id to resolve the proper Jingle Resource. Parameters: handle  the connection handle to use. id  the id to probe from  the from string buf  a string to store the result len  the size in bytes of the string Returns: a pointer to buf if a successful lookup was made otherwise NULL { iks *pres, *msg; char *lid = NULL; struct ldl_buffer buffer; apr_time_t started; unsigned int elapsed; char *notice = "Call Me!"; int again = 0; buffer.buf = buf; buffer.len = len; buffer.hit = 0; pres = iks_new("presence"); iks_insert_attrib(pres, "type", "probe"); iks_insert_attrib(pres, "from", from); iks_insert_attrib(pres, "to", id); apr_hash_set(handle->probe_hash, id, APR_HASH_KEY_STRING, &buffer); msg = iks_make_s10n (IKS_TYPE_SUBSCRIBE, id, notice); iks_insert_attrib(pres, "from", from); apr_queue_push(handle->queue, msg); msg = iks_make_s10n (IKS_TYPE_SUBSCRIBED, id, notice); apr_queue_push(handle->queue, msg); apr_queue_push(handle->queue, pres); //schedule_packet(handle, next_id(), pres, LDL_RETRY); started = apr_time_now(); for(;;) { elapsed = (unsigned int)((apr_time_now() - started) / 1000); if (elapsed > 5000 && ! again) { msg = iks_make_s10n (IKS_TYPE_SUBSCRIBE, id, notice); iks_insert_attrib(msg, "from", from); apr_queue_push(handle->queue, msg); again++; } if (elapsed > 10000) { break; } if (buffer.hit) { lid = buffer.buf; break; } ldl_yield(1000); } apr_hash_set(handle->probe_hash, id, APR_HASH_KEY_STRING, NULL); return lid; }

void ldl_handle_run (  ldl_handle_t *  handle  )

Run a libDingaLing handle. Parameters: handle  the Dingaling handle to run { ldl_set_flag_locked(handle, LDL_FLAG_RUNNING); xmpp_connect(handle, handle->login, handle->password); ldl_clear_flag_locked(handle, LDL_FLAG_RUNNING); }

void ldl_handle_send_msg (  ldl_handle_t *  handle, char *  from, char *  to, char *  subject, char *  body )

Send a message. Parameters: handle  the conection handle from  the message sender to  the message recipiant subject  optional subject body  body of the message { iks *msg; char *t, *e; char *bdup = NULL; int on = 0; int len = 0; assert(handle != NULL); assert(body != NULL); if (strchr(body, '<')) { len = (int) strlen(body); if (!(bdup = malloc(len))) { return; } memset(bdup, 0, len); e = bdup; for(t = body; *t; t++) { if (*t == '<') { on = 1; } else if (*t == '>') { t++; on = 0; } if (!on) { *e++ = *t; } } body = bdup; } msg = iks_make_msg(IKS_TYPE_NONE, to, body); iks_insert_attrib(msg, "type", "chat"); if (!from) { from = handle->login; } iks_insert_attrib(msg, "from", from); if (subject) { iks_insert_attrib(msg, "subject", subject); } if (bdup) { free(bdup); } apr_queue_push(handle->queue, msg); }

void ldl_handle_send_presence (  ldl_handle_t *  handle, char *  from, char *  to, char *  type, char *  rpid, char *  message )

Send a presence notification to a target. Parameters: handle  the handle to send with from  the from address to  the to address type  the type of presence rpid  data for the icon message  a status message { do_presence(handle, from, to, type, rpid, message); }

void ldl_handle_send_vcard (  ldl_handle_t *  handle, char *  from, char *  to, char *  id, char *  vcard )

Send a vcard. Parameters: handle  the handle to send with from  the from address to  the to address id  the request id vcard  the text xml of the vcard { iks *vxml, *iq; int e = 0; if (!(vxml = iks_tree(vcard, 0, &e))) { globals.logger(DL_LOG_ERR, "Parse returned error [%d]\n", e); return; } if (!(iq = iks_new("iq"))) { globals.logger(DL_LOG_ERR, "Memory Error\n"); return; } iks_insert_attrib(iq, "to", to); iks_insert_attrib(iq, "xmlns", "jabber:client"); iks_insert_attrib(iq,"from", from); iks_insert_attrib(iq, "type", "result"); iks_insert_attrib(iq, "id", id); iks_insert_node(iq, vxml); apr_queue_push(handle->queue, iq); iks_free(vxml); }

void ldl_handle_set_log_stream (  ldl_handle_t *  handle, FILE *  log_stream )

Set the log stream on a handle. Parameters: handle  the Dingaling handle log_stream  the new log stream { assert(ldl_test_flag(&globals, LDL_FLAG_INIT)); handle->log_stream = log_stream; }

void ldl_handle_stop (  ldl_handle_t *  handle  )

Stop a libDingaLing handle. Parameters: handle  the Dingaling handle to stop { ldl_clear_flag_locked(handle, LDL_FLAG_RUNNING); }

void ldl_session_accept_candidate (  ldl_session_t *  session, ldl_candidate_t *  candidate )

Accept a candidate. Parameters: session  the session to accept on candidate  the candidate to accept { iks *iq, *sess, *tp; unsigned int myid; char idbuf[80]; myid = next_id(); snprintf(idbuf, sizeof(idbuf), "%u", myid); iq = iks_new("iq"); iks_insert_attrib(iq, "type", "set"); iks_insert_attrib(iq, "id", idbuf); iks_insert_attrib(iq, "from", session->login); iks_insert_attrib(iq, "to", session->them); sess = iks_insert (iq, "session"); iks_insert_attrib(sess, "xmlns", "http://www.google.com/session"); iks_insert_attrib(sess, "type", "transport-accept"); iks_insert_attrib(sess, "id", candidate->tid); iks_insert_attrib(sess, "xmlns", "http://www.google.com/session"); iks_insert_attrib(sess, "initiator", session->initiator ? session->initiator : session->them); tp = iks_insert (sess, "transport"); iks_insert_attrib(tp, "xmlns", "http://www.google.com/transport/p2p"); apr_queue_push(session->handle->queue, iq); }

unsigned int ldl_session_candidates (  ldl_session_t *  session, ldl_candidate_t *  candidates, unsigned int  clen )

Offer candidates to a potential session. Parameters: session  the session to send candidates on candidates  an array of candidate description objects clen  the number of elements in the candidates array Returns: the message_id of the generated xmpp request { iks *iq, *sess, *tag; unsigned int x, id = 0; for (x = 0; x < clen; x++) { char buf[512]; iq = NULL; sess = NULL; id = 0; new_session_iq(session, &iq, &sess, &id, "transport-info"); tag = iks_insert(sess, "transport"); iks_insert_attrib(tag, "xmlns", "http://www.google.com/transport/p2p"); tag = iks_insert(tag, "candidate"); if (candidates[x].name) { iks_insert_attrib(tag, "name", candidates[x].name); } if (candidates[x].address) { iks_insert_attrib(tag, "address", candidates[x].address); } if (candidates[x].port) { snprintf(buf, sizeof(buf), "%u", candidates[x].port); iks_insert_attrib(tag, "port", buf); } if (candidates[x].username) { iks_insert_attrib(tag, "username", candidates[x].username); } if (candidates[x].password) { iks_insert_attrib(tag, "password", candidates[x].password); } if (candidates[x].pref) { snprintf(buf, sizeof(buf), "%0.1f", candidates[x].pref); iks_insert_attrib(tag, "preference", buf); } if (candidates[x].protocol) { iks_insert_attrib(tag, "protocol", candidates[x].protocol); } if (candidates[x].type) { iks_insert_attrib(tag, "type", candidates[x].type); } iks_insert_attrib(tag, "network", "0"); iks_insert_attrib(tag, "generation", "0"); schedule_packet(session->handle, id, iq, LDL_RETRY); } return id; }

ldl_status ldl_session_create (  ldl_session_t **  session_p, ldl_handle_t *  handle, char *  id, char *  them, char *  me )

Create a Jingle Session. Parameters: session_p  pointer to reference the session handle  handle to associate the session with id  the id to use for the session them  the id of the other end of the call me  the id of our end of the call Returns: SUCCESS OR FAILURE { ldl_session_t *session = NULL; if (!(session = apr_palloc(handle->pool, sizeof(ldl_session_t)))) { globals.logger(DL_LOG_DEBUG, "Memory ERROR!\n"); *session_p = NULL; return LDL_STATUS_MEMERR; } memset(session, 0, sizeof(ldl_session_t)); apr_pool_create(&session->pool, globals.memory_pool); session->id = apr_pstrdup(session->pool, id); session->them = apr_pstrdup(session->pool, them); //if (me) { //session->initiator = apr_pstrdup(session->pool, them); //} if (ldl_test_flag(handle, LDL_FLAG_COMPONENT)) { session->login = apr_pstrdup(session->pool, me); } else { session->login = apr_pstrdup(session->pool, handle->login); } apr_hash_set(handle->sessions, session->id, APR_HASH_KEY_STRING, session); apr_hash_set(handle->sessions, session->them, APR_HASH_KEY_STRING, session); session->handle = handle; session->created = apr_time_now(); session->state = LDL_STATE_NEW; session->variables = apr_hash_make(session->pool); *session_p = session; if (globals.debug) { globals.logger(DL_LOG_DEBUG, "Created Session %s\n", id); } return LDL_STATUS_SUCCESS; }

unsigned int ldl_session_describe (  ldl_session_t *  session, ldl_payload_t *  payloads, unsigned int  plen, ldl_description_t  description )

Initiate or Accept a new session and provide transport options. Parameters: session  the session to initiate or accept payloads  an array of payload description objects plen  the number of elements in the payloads array description  the type of description LDL_DESCRIPTION_INITIATE or LDL_DESCRIPTION_ACCEPT Returns: the message_id of the generated xmpp request { iks *iq, *sess, *tag, *payload, *tp; unsigned int x, id; new_session_iq(session, &iq, &sess, &id, description == LDL_DESCRIPTION_ACCEPT ? "accept" : "initiate"); tag = iks_insert(sess, "description"); iks_insert_attrib(tag, "xmlns", "http://www.google.com/session/phone"); iks_insert_attrib(tag, "xml:lang", "en"); for (x = 0; x < plen; x++) { char idbuf[80]; payload = iks_insert(tag, "payload-type"); iks_insert_attrib(payload, "xmlns", "http://www.google.com/session/phone"); sprintf(idbuf, "%d", payloads[x].id); iks_insert_attrib(payload, "id", idbuf); iks_insert_attrib(payload, "name", payloads[x].name); if (payloads[x].rate) { sprintf(idbuf, "%d", payloads[x].rate); iks_insert_attrib(payload, "clockrate", idbuf); } if (payloads[x].bps) { sprintf(idbuf, "%d", payloads[x].bps); iks_insert_attrib(payload, "bitrate", idbuf); } } if (description == LDL_DESCRIPTION_INITIATE) { tp = iks_insert (sess, "transport"); iks_insert_attrib(tp, "xmlns", "http://www.google.com/transport/p2p"); } schedule_packet(session->handle, id, iq, LDL_RETRY); return id; }

ldl_status ldl_session_destroy (  ldl_session_t **  session_p  )

Destroy a Jingle Session. Parameters: session_p  the session to destroy Returns: SUCCESS OR FAILURE { ldl_session_t *session = *session_p; if (session) { apr_pool_t *pool = session->pool; apr_hash_t *hash = session->handle->sessions; if (globals.debug) { globals.logger(DL_LOG_DEBUG, "Destroyed Session %s\n", session->id); } if (session->id) { apr_hash_set(hash, session->id, APR_HASH_KEY_STRING, NULL); } if (session->them) { apr_hash_set(hash, session->them, APR_HASH_KEY_STRING, NULL); } apr_pool_destroy(pool); pool = NULL; *session_p = NULL; return LDL_STATUS_SUCCESS; } return LDL_STATUS_FALSE; }

char* ldl_session_get_callee (  ldl_session_t *  session  )

Get the callee name of a session. Parameters: session  the session to get the callee from Returns: the callee name { return session->login; }

char* ldl_session_get_caller (  ldl_session_t *  session  )

Get the caller name of a session. Parameters: session  the session to get the caller from Returns: the caller name { return session->them; }

ldl_status ldl_session_get_candidates (  ldl_session_t *  session, ldl_candidate_t **  candidates, unsigned int *  len )

get the candidates Parameters: session  the session candidates  pointer to point at array of the candidates len  the resulting len of the array pointer Returns: success or failure { if (session->candidate_len) { *candidates = session->candidates; *len = session->candidate_len; return LDL_STATUS_SUCCESS; } else { *candidates = NULL; *len = 0; return LDL_STATUS_FALSE; } }

char* ldl_session_get_id (  ldl_session_t *  session  )

get the id of a session Parameters: session  the session to get the id of Returns: the requested id { return session->id; }

char* ldl_session_get_ip (  ldl_session_t *  session  )

Get the ip of a session. Parameters: session  the session to get the ip from Returns: the ip { return session->ip; }

ldl_status ldl_session_get_payloads (  ldl_session_t *  session, ldl_payload_t **  payloads, unsigned int *  len )

get the payloads Parameters: session  the session payloads  pointer to point at array of the payloads len  the resulting len of the array pointer Returns: success or failure { if (session->payload_len) { *payloads = session->payloads; *len = session->payload_len; return LDL_STATUS_SUCCESS; } else { *payloads = NULL; *len = 0; return LDL_STATUS_FALSE; } }

void* ldl_session_get_private (  ldl_session_t *  session  )

Get a private pointer from a session. Parameters: session  the session to get the data from Returns: the data { return session->private_data; }

ldl_state_t ldl_session_get_state (  ldl_session_t *  session  )

get a session's state Parameters: session  a session to get the state from Returns: the state { return session->state; }

char* ldl_session_get_value (  ldl_session_t *  session, char *  key )

Get a value from a session. Parameters: session  the session key  the key to look up Returns: the value { return apr_hash_get(session->variables, key, APR_HASH_KEY_STRING); }

void ldl_session_send_msg (  ldl_session_t *  session, char *  subject, char *  body )

Send a message to a session. Parameters: session  the session handle subject  optional subject body  body of the message { ldl_handle_send_msg(session->handle, session->login, session->them, subject, body); }

void ldl_session_set_ip (  ldl_session_t *  session, char *  ip )

Set the ip of a session. Parameters: session  the session to set the ip on ip  the ip { session->ip = apr_pstrdup(session->pool, ip); }

void ldl_session_set_private (  ldl_session_t *  session, void *  private_data )

Set a private pointer to associate with the session. Parameters: session  the session to set the data pointer to private_data  the data to associate { session->private_data = private_data; }