Asterisk - The Open Source Telephony Project  21.4.1
res_pjsip_transport_websocket.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Jason Parker <jparker@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18 
19 /*!
20  * \brief WebSocket transport module
21  */
22 
23 /*** MODULEINFO
24  <depend>pjproject</depend>
25  <depend>res_pjsip</depend>
26  <depend>res_http_websocket</depend>
27  <support_level>core</support_level>
28  ***/
29 
30 #include "asterisk.h"
31 
32 #include <pjsip.h>
33 #include <pjsip_ua.h>
34 
35 #include "asterisk/module.h"
37 #include "asterisk/res_pjsip.h"
38 #include "asterisk/res_pjsip_session.h"
39 #include "asterisk/taskprocessor.h"
40 
41 static int transport_type_wss;
42 static int transport_type_wss_ipv6;
43 
44 /*!
45  * Used to ensure uniqueness among WS transport names
46  */
47 static int ws_obj_name_serial;
48 
49 /*!
50  * \brief Wrapper for pjsip_transport, for storing the WebSocket session
51  */
52 struct ws_transport {
53  pjsip_transport transport;
54  pjsip_rx_data rdata;
55  struct ast_websocket *ws_session;
56 };
57 
58 /*!
59  * \brief Send a message over the WebSocket connection.
60  *
61  * Called by pjsip transport manager.
62  */
63 static pj_status_t ws_send_msg(pjsip_transport *transport,
64  pjsip_tx_data *tdata,
65  const pj_sockaddr_t *rem_addr,
66  int addr_len,
67  void *token,
68  pjsip_transport_callback callback)
69 {
70  struct ws_transport *wstransport = (struct ws_transport *)transport;
71  uint64_t len = tdata->buf.cur - tdata->buf.start;
72 
73  if (ast_websocket_write(wstransport->ws_session, AST_WEBSOCKET_OPCODE_TEXT, tdata->buf.start, len)) {
74  return PJ_EUNKNOWN;
75  }
76 
77  return PJ_SUCCESS;
78 }
79 
80 /*!
81  * \brief Destroy the pjsip transport.
82  *
83  * Called by pjsip transport manager.
84  */
85 static pj_status_t ws_destroy(pjsip_transport *transport)
86 {
87  struct ws_transport *wstransport = (struct ws_transport *)transport;
88 
89  ao2_ref(wstransport, -1);
90 
91  return PJ_SUCCESS;
92 }
93 
94 /*!
95  * \brief Shut down the pjsip transport.
96  *
97  * Called by pjsip transport manager.
98  */
99 static pj_status_t ws_shutdown(pjsip_transport *transport)
100 {
101  struct ws_transport *wstransport = (struct ws_transport *)transport;
102  int fd = ast_websocket_fd(wstransport->ws_session);
103 
104  if (fd > 0) {
105  ast_websocket_close(wstransport->ws_session, 1000);
106  shutdown(fd, SHUT_RDWR);
107  }
108 
109  return PJ_SUCCESS;
110 }
111 
112 static void transport_dtor(void *arg)
113 {
114  struct ws_transport *wstransport = arg;
115 
116  if (wstransport->ws_session) {
117  ast_websocket_unref(wstransport->ws_session);
118  }
119 
120  if (wstransport->transport.ref_cnt) {
121  pj_atomic_destroy(wstransport->transport.ref_cnt);
122  }
123 
124  if (wstransport->transport.lock) {
125  pj_lock_destroy(wstransport->transport.lock);
126  }
127 
128  if (wstransport->transport.endpt && wstransport->transport.pool) {
129  pjsip_endpt_release_pool(wstransport->transport.endpt, wstransport->transport.pool);
130  }
131 
132  if (wstransport->rdata.tp_info.pool) {
133  pjsip_endpt_release_pool(wstransport->transport.endpt, wstransport->rdata.tp_info.pool);
134  }
135 }
136 
137 static int transport_shutdown(void *data)
138 {
139  struct ws_transport *wstransport = data;
140 
141  if (!wstransport->transport.is_shutdown && !wstransport->transport.is_destroying) {
142  pjsip_transport_shutdown(&wstransport->transport);
143  }
144 
145  /* Note that the destructor calls PJSIP functions,
146  * therefore it must be called in a PJSIP thread.
147  */
148  ao2_ref(wstransport, -1);
149 
150  return 0;
151 }
152 
154  struct ws_transport *transport;
155  struct ast_websocket *ws_session;
156 };
157 
158 /*!
159  * \brief Create a pjsip transport.
160  */
161 static int transport_create(void *data)
162 {
163  struct transport_create_data *create_data = data;
164  struct ws_transport *newtransport = NULL;
165  pjsip_tp_state_callback state_cb;
166 
167  pjsip_endpoint *endpt = ast_sip_get_pjsip_endpoint();
168  struct pjsip_tpmgr *tpmgr = pjsip_endpt_get_tpmgr(endpt);
169 
170  char *ws_addr_str;
171  pj_pool_t *pool;
172  pj_str_t buf;
173  pj_status_t status;
174 
175  newtransport = ao2_t_alloc_options(sizeof(*newtransport), transport_dtor,
176  AO2_ALLOC_OPT_LOCK_NOLOCK, "pjsip websocket transport");
177  if (!newtransport) {
178  ast_log(LOG_ERROR, "Failed to allocate WebSocket transport.\n");
179  goto on_error;
180  }
181 
182  /* Give websocket transport a unique name for its lifetime */
183  snprintf(newtransport->transport.obj_name, PJ_MAX_OBJ_NAME, "ws%p-%d",
184  &newtransport->transport, ast_atomic_fetchadd_int(&ws_obj_name_serial, 1));
185 
186  newtransport->transport.endpt = endpt;
187 
188  if (!(pool = pjsip_endpt_create_pool(endpt, "ws", 512, 512))) {
189  ast_log(LOG_ERROR, "Failed to allocate WebSocket endpoint pool.\n");
190  goto on_error;
191  }
192 
193  newtransport->transport.pool = pool;
194  newtransport->ws_session = create_data->ws_session;
195 
196  /* Keep the session until transport dies */
197  ast_websocket_ref(newtransport->ws_session);
198 
199  status = pj_atomic_create(pool, 0, &newtransport->transport.ref_cnt);
200  if (status != PJ_SUCCESS) {
201  goto on_error;
202  }
203 
204  status = pj_lock_create_recursive_mutex(pool, pool->obj_name, &newtransport->transport.lock);
205  if (status != PJ_SUCCESS) {
206  goto on_error;
207  }
208 
209  /*
210  * The type_name here is mostly used by log messages eihter in
211  * pjproject or Asterisk. Other places are reconstituting subscriptions
212  * after a restart (which could never work for a websocket connection anyway),
213  * received MESSAGE requests to set PJSIP_TRANSPORT, and most importantly
214  * by pjproject when generating the Via header.
215  */
216  newtransport->transport.type_name = ast_websocket_is_secure(newtransport->ws_session)
217  ? "WSS" : "WS";
218 
219  ws_addr_str = ast_sockaddr_stringify(ast_websocket_remote_address(newtransport->ws_session));
220  ast_debug(4, "Creating websocket transport for %s:%s\n",
221  newtransport->transport.type_name, ws_addr_str);
222 
223  newtransport->transport.info = (char *) pj_pool_alloc(newtransport->transport.pool,
224  strlen(newtransport->transport.type_name) + strlen(ws_addr_str) + sizeof(" to "));
225  sprintf(newtransport->transport.info, "%s to %s", newtransport->transport.type_name, ws_addr_str);
226 
227  pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, ws_addr_str), &newtransport->transport.key.rem_addr);
228  if (newtransport->transport.key.rem_addr.addr.sa_family == pj_AF_INET6()) {
229  newtransport->transport.key.type = transport_type_wss_ipv6;
230  } else {
231  newtransport->transport.key.type = transport_type_wss;
232  }
233 
234  newtransport->transport.addr_len = pj_sockaddr_get_len(&newtransport->transport.key.rem_addr);
235 
236  ws_addr_str = ast_sockaddr_stringify(ast_websocket_local_address(newtransport->ws_session));
237  pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, ws_addr_str), &newtransport->transport.local_addr);
238  pj_strdup2(pool, &newtransport->transport.local_name.host, ast_sockaddr_stringify_addr(ast_websocket_local_address(newtransport->ws_session)));
239  newtransport->transport.local_name.port = ast_sockaddr_port(ast_websocket_local_address(newtransport->ws_session));
240  pj_strdup2(pool, &newtransport->transport.remote_name.host, ast_sockaddr_stringify_addr(ast_websocket_remote_address(newtransport->ws_session)));
241  newtransport->transport.remote_name.port = ast_sockaddr_port(ast_websocket_remote_address(newtransport->ws_session));
242 
243  newtransport->transport.flag = pjsip_transport_get_flag_from_type((pjsip_transport_type_e)newtransport->transport.key.type);
244  newtransport->transport.dir = PJSIP_TP_DIR_INCOMING;
245  newtransport->transport.tpmgr = tpmgr;
246  newtransport->transport.send_msg = &ws_send_msg;
247  newtransport->transport.do_shutdown = &ws_shutdown;
248  newtransport->transport.destroy = &ws_destroy;
249 
250  status = pjsip_transport_register(newtransport->transport.tpmgr,
251  (pjsip_transport *)newtransport);
252  if (status != PJ_SUCCESS) {
253  goto on_error;
254  }
255 
256  /* Add a reference for pjsip transport manager */
257  ao2_ref(newtransport, +1);
258 
259  newtransport->rdata.tp_info.transport = &newtransport->transport;
260  newtransport->rdata.tp_info.pool = pjsip_endpt_create_pool(endpt, "rtd%p",
261  PJSIP_POOL_RDATA_LEN, PJSIP_POOL_RDATA_INC);
262  if (!newtransport->rdata.tp_info.pool) {
263  ast_log(LOG_ERROR, "Failed to allocate WebSocket rdata.\n");
264  pjsip_transport_destroy((pjsip_transport *)newtransport);
265  goto on_error;
266  }
267 
268  create_data->transport = newtransport;
269 
270  /* Notify application of transport state */
271  state_cb = pjsip_tpmgr_get_state_cb(newtransport->transport.tpmgr);
272  if (state_cb) {
273  pjsip_transport_state_info state_info;
274 
275  memset(&state_info, 0, sizeof(state_info));
276  state_cb(&newtransport->transport, PJSIP_TP_STATE_CONNECTED, &state_info);
277  }
278 
279  return 0;
280 
281 on_error:
282  ao2_cleanup(newtransport);
283  return -1;
284 }
285 
287  struct ws_transport *transport;
288  char *payload;
289  uint64_t payload_len;
290 };
291 
292 /*!
293  * \brief Pass WebSocket data into pjsip transport manager.
294  */
295 static int transport_read(void *data)
296 {
297  struct transport_read_data *read_data = data;
298  struct ws_transport *newtransport = read_data->transport;
299  struct ast_websocket *session = newtransport->ws_session;
300 
301  pjsip_rx_data *rdata = &newtransport->rdata;
302  int recvd;
303  pj_str_t buf;
304  int pjsip_pkt_len;
305 
306  pj_gettimeofday(&rdata->pkt_info.timestamp);
307 
308  pjsip_pkt_len = PJSIP_MAX_PKT_LEN < read_data->payload_len ? PJSIP_MAX_PKT_LEN : read_data->payload_len;
309  pj_memcpy(rdata->pkt_info.packet, read_data->payload, pjsip_pkt_len);
310  rdata->pkt_info.len = pjsip_pkt_len;
311  rdata->pkt_info.zero = 0;
312 
313  pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, ast_sockaddr_stringify(ast_websocket_remote_address(session))), &rdata->pkt_info.src_addr);
314  rdata->pkt_info.src_addr_len = sizeof(rdata->pkt_info.src_addr);
315 
316  pj_ansi_strcpy(rdata->pkt_info.src_name, ast_sockaddr_stringify_addr(ast_websocket_remote_address(session)));
317  rdata->pkt_info.src_port = ast_sockaddr_port(ast_websocket_remote_address(session));
318 
319  recvd = pjsip_tpmgr_receive_packet(rdata->tp_info.transport->tpmgr, rdata);
320 
321  pj_pool_reset(rdata->tp_info.pool);
322 
323  return (read_data->payload_len == recvd) ? 0 : -1;
324 }
325 
326 static int get_write_timeout(void)
327 {
328  int write_timeout = -1;
329  struct ao2_container *transport_states;
330 
331  transport_states = ast_sip_get_transport_states();
332 
333  if (transport_states) {
334  struct ao2_iterator it_transport_states = ao2_iterator_init(transport_states, 0);
335  struct ast_sip_transport_state *transport_state;
336 
337  for (; (transport_state = ao2_iterator_next(&it_transport_states)); ao2_cleanup(transport_state)) {
338  struct ast_sip_transport *transport;
339 
340  if (transport_state->type != AST_TRANSPORT_WS && transport_state->type != AST_TRANSPORT_WSS) {
341  continue;
342  }
343  transport = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "transport", transport_state->id);
344  if (!transport) {
345  continue;
346  }
347  ast_debug(5, "Found %s transport with write timeout: %d\n",
348  transport->type == AST_TRANSPORT_WS ? "WS" : "WSS",
349  transport->write_timeout);
350  write_timeout = MAX(write_timeout, transport->write_timeout);
351  }
352  ao2_iterator_destroy(&it_transport_states);
353  ao2_cleanup(transport_states);
354  }
355 
356  if (write_timeout < 0) {
357  write_timeout = AST_DEFAULT_WEBSOCKET_WRITE_TIMEOUT;
358  }
359 
360  ast_debug(1, "Write timeout for WS/WSS transports: %d\n", write_timeout);
361  return write_timeout;
362 }
363 
364 static struct ast_taskprocessor *create_websocket_serializer(void)
365 {
366  char tps_name[AST_TASKPROCESSOR_MAX_NAME + 1];
367 
368  /* Create name with seq number appended. */
369  ast_taskprocessor_build_name(tps_name, sizeof(tps_name), "pjsip/websocket");
370 
371  return ast_sip_create_serializer(tps_name);
372 }
373 
374 /*! \brief WebSocket connection handler. */
375 static void websocket_cb(struct ast_websocket *session, struct ast_variable *parameters, struct ast_variable *headers)
376 {
378  struct transport_create_data create_data;
379  struct ws_transport *transport;
380  struct transport_read_data read_data;
381 
382  if (ast_websocket_set_nonblock(session)) {
383  ast_websocket_unref(session);
384  return;
385  }
386 
387  if (ast_websocket_set_timeout(session, get_write_timeout())) {
388  ast_websocket_unref(session);
389  return;
390  }
391 
392  serializer = create_websocket_serializer();
393  if (!serializer) {
394  ast_websocket_unref(session);
395  return;
396  }
397 
398  create_data.ws_session = session;
399 
400  if (ast_sip_push_task_wait_serializer(serializer, transport_create, &create_data)) {
401  ast_log(LOG_ERROR, "Could not create WebSocket transport.\n");
402  ast_taskprocessor_unreference(serializer);
403  ast_websocket_unref(session);
404  return;
405  }
406 
407  transport = create_data.transport;
408  read_data.transport = transport;
409 
410  pjsip_transport_add_ref(&transport->transport);
411  while (ast_websocket_wait_for_input(session, -1) > 0) {
412  enum ast_websocket_opcode opcode;
413  int fragmented;
414 
415  if (ast_websocket_read(session, &read_data.payload, &read_data.payload_len, &opcode, &fragmented)) {
416  break;
417  }
418 
419  if (opcode == AST_WEBSOCKET_OPCODE_TEXT || opcode == AST_WEBSOCKET_OPCODE_BINARY) {
420  if (read_data.payload_len) {
421  ast_sip_push_task_wait_serializer(serializer, transport_read, &read_data);
422  }
423  } else if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
424  break;
425  }
426  }
427  pjsip_transport_dec_ref(&transport->transport);
428 
429  ast_sip_push_task_wait_serializer(serializer, transport_shutdown, transport);
430 
431  ast_taskprocessor_unreference(serializer);
432  ast_websocket_unref(session);
433 }
434 
435 static void save_orig_contact_host(pjsip_rx_data *rdata, pjsip_sip_uri *uri)
436 {
437  pjsip_param *x_orig_host;
438  pj_str_t p_value;
439 #define COLON_LEN 1
440 #define MAX_PORT_LEN 5
441 
442  if (rdata->msg_info.msg->type != PJSIP_REQUEST_MSG ||
443  rdata->msg_info.msg->line.req.method.id != PJSIP_REGISTER_METHOD) {
444  return;
445  }
446 
447  ast_debug(1, "Saving contact '%.*s:%d'\n",
448  (int)uri->host.slen, uri->host.ptr, uri->port);
449 
450  x_orig_host = PJ_POOL_ALLOC_T(rdata->tp_info.pool, pjsip_param);
451  x_orig_host->name = pj_strdup3(rdata->tp_info.pool, "x-ast-orig-host");
452  p_value.slen = pj_strlen(&uri->host) + COLON_LEN + MAX_PORT_LEN;
453  p_value.ptr = (char*)pj_pool_alloc(rdata->tp_info.pool, p_value.slen + 1);
454  p_value.slen = snprintf(p_value.ptr, p_value.slen + 1, "%.*s:%d", (int)uri->host.slen, uri->host.ptr, uri->port);
455  pj_strassign(&x_orig_host->value, &p_value);
456  pj_list_insert_before(&uri->other_param, x_orig_host);
457 
458  return;
459 }
460 
461 /*!
462  * \brief Store the transport a message came in on, so it can be used for outbound messages to that contact.
463  */
464 static pj_bool_t websocket_on_rx_msg(pjsip_rx_data *rdata)
465 {
466  static const pj_str_t STR_WS = { "ws", 2 };
467  pjsip_contact_hdr *contact;
468 
469  long type = rdata->tp_info.transport->key.type;
470 
471  if (type != (long) transport_type_wss && type != (long) transport_type_wss_ipv6) {
472  return PJ_FALSE;
473  }
474 
475  contact = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, NULL);
476  if (contact
477  && !contact->star
478  && (PJSIP_URI_SCHEME_IS_SIP(contact->uri) || PJSIP_URI_SCHEME_IS_SIPS(contact->uri))) {
479  pjsip_sip_uri *uri = pjsip_uri_get_uri(contact->uri);
480  const pj_str_t *txp_str = &STR_WS;
481 
482  /* Saving the contact on REGISTER so it can be restored on outbound response
483  * This will actually be done by restore_orig_contact_host in res_pjsip_nat, via nat_on_tx_message */
484  save_orig_contact_host(rdata, uri);
485 
486  if (DEBUG_ATLEAST(4)) {
487  char src_addr_buffer[AST_SOCKADDR_BUFLEN];
488  const char *ipv6_s = "", *ipv6_e = "";
489 
490  if (pj_strchr(&uri->host, ':')) {
491  ipv6_s = "[";
492  ipv6_e = "]";
493  }
494 
495  ast_log(LOG_DEBUG, "%s re-writing Contact URI from %s%.*s%s:%d%s%.*s to %s;transport=%s\n",
496  pjsip_rx_data_get_info(rdata),
497  ipv6_s, (int) pj_strlen(&uri->host), pj_strbuf(&uri->host), ipv6_e, uri->port,
498  pj_strlen(&uri->transport_param) ? ";transport=" : "",
499  (int) pj_strlen(&uri->transport_param), pj_strbuf(&uri->transport_param),
500  pj_sockaddr_print(&rdata->pkt_info.src_addr, src_addr_buffer, sizeof(src_addr_buffer), 3),
501  pj_strbuf(txp_str));
502  }
503 
504  pj_strdup2(rdata->tp_info.pool, &uri->host, rdata->pkt_info.src_name);
505  uri->port = rdata->pkt_info.src_port;
506  pj_strdup(rdata->tp_info.pool, &uri->transport_param, txp_str);
507  }
508 
509  rdata->msg_info.via->rport_param = 0;
510 
511  return PJ_FALSE;
512 }
513 
514 static pjsip_module websocket_module = {
515  .name = { "WebSocket Transport Module", 26 },
516  .id = -1,
517  .priority = PJSIP_MOD_PRIORITY_TRANSPORT_LAYER,
518  .on_rx_request = websocket_on_rx_msg,
519  .on_rx_response = websocket_on_rx_msg,
520 };
521 
522 /*! \brief Function called when an INVITE goes out */
523 static void websocket_outgoing_invite_request(struct ast_sip_session *session, struct pjsip_tx_data *tdata)
524 {
525  if (session->inv_session->state == PJSIP_INV_STATE_NULL) {
526  pjsip_dlg_add_usage(session->inv_session->dlg, &websocket_module, NULL);
527  }
528 }
529 
530 /*! \brief Supplement for adding Websocket functionality to dialog */
531 static struct ast_sip_session_supplement websocket_supplement = {
532  .method = "INVITE",
533  .priority = AST_SIP_SUPPLEMENT_PRIORITY_FIRST + 1,
534  .outgoing_request = websocket_outgoing_invite_request,
535 };
536 
537 static int load_module(void)
538 {
539  /*
540  * We only need one transport type name (ws) defined. Firefox
541  * and Chrome do not support anything other than secure websockets
542  * anymore.
543  *
544  * Also we really cannot have two transports with the same name
545  * and address family because it would be ambiguous. Outgoing
546  * requests may try to find the transport by name and pjproject
547  * only finds the first one registered.
548  */
549  pjsip_transport_register_type(PJSIP_TRANSPORT_RELIABLE | PJSIP_TRANSPORT_SECURE, "ws", 5060, &transport_type_wss);
550  pjsip_transport_register_type(PJSIP_TRANSPORT_RELIABLE | PJSIP_TRANSPORT_SECURE | PJSIP_TRANSPORT_IPV6, "ws", 5060, &transport_type_wss_ipv6);
551 
552  if (ast_sip_register_service(&websocket_module) != PJ_SUCCESS) {
554  }
555 
556  ast_sip_session_register_supplement(&websocket_supplement);
557 
558  if (ast_websocket_add_protocol("sip", websocket_cb)) {
559  ast_sip_session_unregister_supplement(&websocket_supplement);
560  ast_sip_unregister_service(&websocket_module);
562  }
563 
565 }
566 
567 static int unload_module(void)
568 {
569  ast_sip_unregister_service(&websocket_module);
570  ast_sip_session_unregister_supplement(&websocket_supplement);
571  ast_websocket_remove_protocol("sip", websocket_cb);
572 
573  return 0;
574 }
575 
576 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP WebSocket Transport Support",
577  .support_level = AST_MODULE_SUPPORT_CORE,
578  .load = load_module,
579  .unload = unload_module,
580  .load_pri = AST_MODPRI_APP_DEPEND,
581  .requires = "res_pjsip,res_http_websocket",
582 );
static char * ast_sockaddr_stringify_addr(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() to return an address only.
Definition: netsock2.h:286
enum ast_transport type
Definition: res_pjsip.h:133
void ast_taskprocessor_build_name(char *buf, unsigned int size, const char *format,...)
Build a taskprocessor name with a sequence number on the end.
Asterisk main include file. File version handling, generic pbx functions.
Structure for variables, used for configurations and for channel variables.
static pj_pool_t * pool
Global memory pool for configuration and timers.
int AST_OPTIONAL_API_NAME() ast_websocket_close(struct ast_websocket *session, uint16_t reason)
Close function for websocket session.
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
#define ao2_t_alloc_options(data_size, destructor_fn, options, debug_msg)
Allocate and initialize an object.
Definition: astobj2.h:402
#define AST_TASKPROCESSOR_MAX_NAME
Suggested maximum taskprocessor name length (less null terminator).
Definition: taskprocessor.h:61
struct pjsip_inv_session * inv_session
enum ast_transport type
Definition: res_pjsip.h:243
A structure describing a SIP session.
int ast_atomic_fetchadd_int(volatile int *p, int v)
Atomically add v to *p and return the previous value of *p.
Definition: lock.h:757
void * ast_sorcery_retrieve_by_id(const struct ast_sorcery *sorcery, const char *type, const char *id)
Retrieve an object using its unique identifier.
Definition: sorcery.c:1853
#define ast_sockaddr_port(addr)
Get the port number of a socket address.
Definition: netsock2.h:517
Structure for SIP transport information.
Definition: res_pjsip.h:119
int ast_sip_push_task_wait_serializer(struct ast_taskprocessor *serializer, int(*sip_task)(void *), void *task_data)
Push a task to the serializer and wait for it to complete.
Definition: res_pjsip.c:2179
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define ast_debug(level,...)
Log a DEBUG message.
Support for WebSocket connections within the Asterisk HTTP server and client WebSocket connections to...
#define AST_DEFAULT_WEBSOCKET_WRITE_TIMEOUT
Default websocket write timeout, in ms.
Transport to bind to.
Definition: res_pjsip.h:221
static char * ast_sockaddr_stringify(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() with default format.
Definition: netsock2.h:256
struct ast_taskprocessor * ast_sip_create_serializer(const char *name)
Create a new serializer for SIP tasks.
Definition: res_pjsip.c:2094
int AST_OPTIONAL_API_NAME() ast_websocket_write(struct ast_websocket *session, enum ast_websocket_opcode opcode, char *payload, uint64_t payload_size)
Write function for websocket traffic.
Structure definition for session.
Module has failed to load, may be in an inconsistent state.
Definition: module.h:78
An API for managing task processing threads that can be shared across modules.
A supplement to SIP message processing.
A ast_taskprocessor structure is a singleton by name.
Definition: taskprocessor.c:69
When we need to walk through a container, we use an ao2_iterator to keep track of the current positio...
Definition: astobj2.h:1821
void * ast_taskprocessor_unreference(struct ast_taskprocessor *tps)
Unreference the specified taskprocessor and its reference count will decrement.
Generic container type.
#define ASTERISK_GPL_KEY
The text the key() function should return.
Definition: module.h:46
Asterisk module definitions.
ast_websocket_opcode
WebSocket operation codes.
struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags) attribute_warn_unused_result
Create an iterator for a container.
char buf[MAXIMUM_FRAME_SIZE]
Wrapper for pjsip_transport, for storing the WebSocket session.