/*! * \brief Store the transport a message came in on, so it can be used for outbound messages to that contact. */ static pj_bool_t websocket_on_rx_msg(pjsip_rx_data *rdata) { static const pj_str_t STR_WS = { "ws", 2 }; static const pj_str_t STR_WSS = { "wss", 3 }; pjsip_contact_hdr *contact; long type = rdata->tp_info.transport->key.type; if (type != (long)transport_type_ws && type != (long)transport_type_wss) { return PJ_FALSE; } if ((contact = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, NULL)) && !contact->star && (PJSIP_URI_SCHEME_IS_SIP(contact->uri) || PJSIP_URI_SCHEME_IS_SIPS(contact->uri))) { pjsip_sip_uri *uri = pjsip_uri_get_uri(contact->uri); pj_cstr(&uri->host, rdata->pkt_info.src_name); uri->port = rdata->pkt_info.src_port; ast_debug(4, "Re-wrote Contact URI host/port to %.*s:%d\n", (int)pj_strlen(&uri->host), pj_strbuf(&uri->host), uri->port); pj_strdup(rdata->tp_info.pool, &uri->transport_param, (type == (long)transport_type_ws) ? &STR_WS : &STR_WSS); } rdata->msg_info.via->rport_param = 0; return PJ_FALSE; }
/* * Start ICE negotiation! This function is invoked from the menu. */ void natclient_start_nego(struct ice_trans_s* icetrans) { pj_str_t rufrag, rpwd; pj_status_t status; if (icetrans->icest == NULL) { PJ_LOG(1,(THIS_FILE, "Error: No ICE instance, create it first")); return; } if (!pj_ice_strans_has_sess(icetrans->icest)) { PJ_LOG(1,(THIS_FILE, "Error: No ICE session, initialize first")); return; } if (icetrans->rem.cand_cnt == 0) { PJ_LOG(1,(THIS_FILE, "Error: No remote info, input remote info first")); return; } PJ_LOG(3,(THIS_FILE, "Starting ICE negotiation..")); status = pj_ice_strans_start_ice(icetrans->icest, pj_cstr(&rufrag, icetrans->rem.ufrag), pj_cstr(&rpwd, icetrans->rem.pwd), icetrans->rem.cand_cnt, icetrans->rem.cand); if (status != PJ_SUCCESS) natclient_perror("Error starting ICE", status); else PJ_LOG(3,(THIS_FILE, "ICE negotiation started")); }
void SIPCall::sendSIPInfo(const char *const body, const char *const subtype) { if (not inv or not inv->dlg) throw VoipLinkException("Couldn't get invite dialog"); pj_str_t methodName = CONST_PJ_STR("INFO"); pjsip_method method; pjsip_method_init_np(&method, &methodName); /* Create request message. */ pjsip_tx_data *tdata; if (pjsip_dlg_create_request(inv->dlg, &method, -1, &tdata) != PJ_SUCCESS) { RING_ERR("[call:%s] Could not create dialog", getCallId().c_str()); return; } /* Create "application/<subtype>" message body. */ pj_str_t content; pj_cstr(&content, body); const pj_str_t type = CONST_PJ_STR("application"); pj_str_t pj_subtype; pj_cstr(&pj_subtype, subtype); tdata->msg->body = pjsip_msg_body_create(tdata->pool, &type, &pj_subtype, &content); if (tdata->msg->body == NULL) pjsip_tx_data_dec_ref(tdata); else pjsip_dlg_send_request(inv->dlg, tdata, getSIPVoIPLink()->getModId(), NULL); }
static int pidf_generate_body_content(void *body, void *data) { pjpidf_tuple *tuple; pj_str_t note, id, contact, priority; char *statestring = NULL, *pidfstate = NULL, *pidfnote = NULL; enum ast_sip_pidf_state local_state; char sanitized[PJSIP_MAX_URL_SIZE]; pjpidf_pres *pres = body; struct ast_sip_exten_state_data *state_data = data; ast_sip_presence_exten_state_to_str(state_data->exten_state, &statestring, &pidfstate, &pidfnote, &local_state); if (!pjpidf_pres_add_note(state_data->pool, pres, pj_cstr(¬e, pidfnote))) { ast_log(LOG_WARNING, "Unable to add note to PIDF presence\n"); return -1; } if (!(tuple = pjpidf_pres_add_tuple(state_data->pool, pres, pj_cstr(&id, state_data->exten)))) { ast_log(LOG_WARNING, "Unable to create PIDF tuple\n"); return -1; } ast_sip_sanitize_xml(state_data->remote, sanitized, sizeof(sanitized)); pjpidf_tuple_set_contact(state_data->pool, tuple, pj_cstr(&contact, sanitized)); pjpidf_tuple_set_contact_prio(state_data->pool, tuple, pj_cstr(&priority, "1")); pjpidf_status_set_basic_open(pjpidf_tuple_get_status(tuple), local_state == NOTIFY_OPEN); return 0; }
// helper for creating call-media-player static void create_player(pjsua_call_id call_id) { // get call infos pjsua_call_info ci; pjsua_call_get_info(call_id, &ci); pj_str_t name; pj_status_t status = PJ_ENOTFOUND; log_message("Creating player ... "); // create player for playback media if (app_cfg.wav_file) { status = pjsua_player_create(pj_cstr(&name, app_cfg.wav_file), 0, &play_id); } else { status = pjsua_player_create(pj_cstr(&name, app_cfg.tts_file), 0, &play_id); } if (status != PJ_SUCCESS) error_exit("Error playing sound-playback", status); // connect active call to media player pjsua_conf_connect(pjsua_player_get_conf_port(play_id), ci.conf_slot); // get media port (play_port) from play_id status = pjsua_player_get_port(play_id, &play_port); if (status != PJ_SUCCESS) error_exit("Error getting sound player port", status); // register media finished callback status = pjmedia_wav_player_set_eof_cb(play_port, NULL, &on_media_finished); if (status != PJ_SUCCESS) error_exit("Error adding sound-playback callback", status); log_message("Done.\n"); }
/*! \brief Function which adds ICE attributes to a media stream */ static void add_ice_to_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media, pj_pool_t *pool, pjmedia_sdp_media *media) { struct ast_rtp_engine_ice *ice; struct ao2_container *candidates; const char *username, *password; pj_str_t stmp; pjmedia_sdp_attr *attr; struct ao2_iterator it_candidates; struct ast_rtp_engine_ice_candidate *candidate; if (!session->endpoint->media.rtp.ice_support || !(ice = ast_rtp_instance_get_ice(session_media->rtp)) || !(candidates = ice->get_local_candidates(session_media->rtp))) { return; } if ((username = ice->get_ufrag(session_media->rtp))) { attr = pjmedia_sdp_attr_create(pool, "ice-ufrag", pj_cstr(&stmp, username)); media->attr[media->attr_count++] = attr; } if ((password = ice->get_password(session_media->rtp))) { attr = pjmedia_sdp_attr_create(pool, "ice-pwd", pj_cstr(&stmp, password)); media->attr[media->attr_count++] = attr; } it_candidates = ao2_iterator_init(candidates, 0); for (; (candidate = ao2_iterator_next(&it_candidates)); ao2_ref(candidate, -1)) { struct ast_str *attr_candidate = ast_str_create(128); ast_str_set(&attr_candidate, -1, "%s %u %s %d %s ", candidate->foundation, candidate->id, candidate->transport, candidate->priority, ast_sockaddr_stringify_addr_remote(&candidate->address)); ast_str_append(&attr_candidate, -1, "%s typ ", ast_sockaddr_stringify_port(&candidate->address)); switch (candidate->type) { case AST_RTP_ICE_CANDIDATE_TYPE_HOST: ast_str_append(&attr_candidate, -1, "host"); break; case AST_RTP_ICE_CANDIDATE_TYPE_SRFLX: ast_str_append(&attr_candidate, -1, "srflx"); break; case AST_RTP_ICE_CANDIDATE_TYPE_RELAYED: ast_str_append(&attr_candidate, -1, "relay"); break; } if (!ast_sockaddr_isnull(&candidate->relay_address)) { ast_str_append(&attr_candidate, -1, " raddr %s rport", ast_sockaddr_stringify_addr_remote(&candidate->relay_address)); ast_str_append(&attr_candidate, -1, " %s", ast_sockaddr_stringify_port(&candidate->relay_address)); } attr = pjmedia_sdp_attr_create(pool, "candidate", pj_cstr(&stmp, ast_str_buffer(attr_candidate))); media->attr[media->attr_count++] = attr; ast_free(attr_candidate); } ao2_iterator_destroy(&it_candidates); ao2_ref(candidates, -1); }
static int send_unsolicited_mwi_notify_to_contact(void *obj, void *arg, int flags) { struct unsolicited_mwi_data *mwi_data = arg; struct mwi_subscription *sub = mwi_data->sub; struct ast_sip_endpoint *endpoint = mwi_data->endpoint; pjsip_evsub_state state = mwi_data->state; const struct ast_sip_body *body = mwi_data->body; struct ast_sip_contact *contact = obj; const char *state_name; pjsip_tx_data *tdata; pjsip_sub_state_hdr *sub_state; pjsip_event_hdr *event; const pjsip_hdr *allow_events = pjsip_evsub_get_allow_events_hdr(NULL); if (ast_sip_create_request("NOTIFY", NULL, endpoint, NULL, contact, &tdata)) { ast_log(LOG_WARNING, "Unable to create unsolicited NOTIFY request to endpoint %s URI %s\n", sub->id, contact->uri); return 0; } if (!ast_strlen_zero(endpoint->subscription.mwi.fromuser)) { pjsip_fromto_hdr *from = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_FROM, NULL); pjsip_name_addr *from_name_addr = (pjsip_name_addr *) from->uri; pjsip_sip_uri *from_uri = pjsip_uri_get_uri(from_name_addr->uri); pj_strdup2(tdata->pool, &from_uri->user, endpoint->subscription.mwi.fromuser); } switch (state) { case PJSIP_EVSUB_STATE_ACTIVE: state_name = "active"; break; case PJSIP_EVSUB_STATE_TERMINATED: default: state_name = "terminated"; break; } sub_state = pjsip_sub_state_hdr_create(tdata->pool); pj_cstr(&sub_state->sub_state, state_name); pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) sub_state); event = pjsip_event_hdr_create(tdata->pool); pj_cstr(&event->event_type, "message-summary"); pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) event); pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, allow_events)); ast_sip_add_body(tdata, body); ast_sip_send_request(tdata, NULL, endpoint, NULL, NULL); return 0; }
static int set_outbound_authentication_credentials(pjsip_auth_clt_sess *auth_sess, const struct ast_sip_auth_vector *auth_vector, pjsip_rx_data *challenge) { size_t auth_size = AST_VECTOR_SIZE(auth_vector); struct ast_sip_auth **auths = ast_alloca(auth_size * sizeof(*auths)); pjsip_cred_info *auth_creds = ast_alloca(auth_size * sizeof(*auth_creds)); pjsip_www_authenticate_hdr *auth_hdr = NULL; int res = 0; int i; if (ast_sip_retrieve_auths(auth_vector, auths)) { res = -1; goto cleanup; } auth_hdr = get_auth_header(challenge); if (auth_hdr == NULL) { res = -1; ast_log(LOG_ERROR, "Unable to find authenticate header in challenge.\n"); goto cleanup; } for (i = 0; i < auth_size; ++i) { if (ast_strlen_zero(auths[i]->realm)) { auth_creds[i].realm = auth_hdr->challenge.common.realm; } else { pj_cstr(&auth_creds[i].realm, auths[i]->realm); } pj_cstr(&auth_creds[i].username, auths[i]->auth_user); pj_cstr(&auth_creds[i].scheme, "digest"); switch (auths[i]->type) { case AST_SIP_AUTH_TYPE_USER_PASS: pj_cstr(&auth_creds[i].data, auths[i]->auth_pass); auth_creds[i].data_type = PJSIP_CRED_DATA_PLAIN_PASSWD; break; case AST_SIP_AUTH_TYPE_MD5: pj_cstr(&auth_creds[i].data, auths[i]->md5_creds); auth_creds[i].data_type = PJSIP_CRED_DATA_DIGEST; break; case AST_SIP_AUTH_TYPE_ARTIFICIAL: ast_log(LOG_ERROR, "Trying to set artificial outbound auth credentials shouldn't happen.\n"); break; } } pjsip_auth_clt_set_credentials(auth_sess, auth_size, auth_creds); cleanup: ast_sip_cleanup_auths(auths, auth_size); return res; }
/*! * \brief Pass WebSocket data into pjsip transport manager. */ static int transport_read(void *data) { struct transport_read_data *read_data = data; struct ws_transport *newtransport = read_data->transport; struct ast_websocket *session = newtransport->ws_session; pjsip_rx_data *rdata = &newtransport->rdata; int recvd; pj_str_t buf; int pjsip_pkt_len; pj_gettimeofday(&rdata->pkt_info.timestamp); pjsip_pkt_len = PJSIP_MAX_PKT_LEN < read_data->payload_len ? PJSIP_MAX_PKT_LEN : read_data->payload_len; pj_memcpy(rdata->pkt_info.packet, read_data->payload, pjsip_pkt_len); rdata->pkt_info.len = pjsip_pkt_len; rdata->pkt_info.zero = 0; pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, ast_sockaddr_stringify(ast_websocket_remote_address(session))), &rdata->pkt_info.src_addr); rdata->pkt_info.src_addr.addr.sa_family = pj_AF_INET(); rdata->pkt_info.src_addr_len = sizeof(rdata->pkt_info.src_addr); pj_ansi_strcpy(rdata->pkt_info.src_name, ast_sockaddr_stringify_host(ast_websocket_remote_address(session))); rdata->pkt_info.src_port = ast_sockaddr_port(ast_websocket_remote_address(session)); recvd = pjsip_tpmgr_receive_packet(rdata->tp_info.transport->tpmgr, rdata); pj_pool_reset(rdata->tp_info.pool); return (read_data->payload_len == recvd) ? 0 : -1; }
static void open_udp_socket($UPROTO$_server_t *userver, char *addr, int port) { pj_sockaddr_in saddr; pj_str_t s; int optval = 1; SHOW_LOG(3, __FILE__":open_udp_socket: %s:%d\n", addr, port); // create udp socket here CHECK(__FILE__, pj_sock_socket(PJ_AF_INET, PJ_SOCK_DGRAM, 0, &userver->fd)); #ifdef __ICS_INTEL__ // Allow socket reuse //CHECK(__FILE__, pj_sock_setsockopt(userver->fd, PJ_SOL_SOCKET, 512, &optval, sizeof(optval))); CHECK(__FILE__, pj_sock_setsockopt(userver->fd, PJ_SOL_SOCKET, PJ_SO_REUSEADDR, &optval, sizeof(optval))); #endif // bind the socket pj_bzero(&saddr, sizeof(saddr)); saddr.sin_family = PJ_AF_INET; saddr.sin_port = pj_htons(port); saddr.sin_addr = pj_inet_addr(pj_cstr(&s,addr)); /*pj_status_t status = pj_sock_bind(userver->fd, &saddr, sizeof(saddr)); if( status != 0 ) { SHOW_LOG(1, __FILE__":open_udp_socket error(%d)\n", status); exit(-1); }*/ CHECK(__FILE__, pj_sock_bind(userver->fd, &saddr, sizeof(saddr))); }
/*! * \brief Common code for initializing a pjsip_auth_srv */ static void setup_auth_srv(pj_pool_t *pool, pjsip_auth_srv *auth_server, const char *realm) { pj_str_t realm_str; pj_cstr(&realm_str, realm); pjsip_auth_srv_init(pool, auth_server, &realm_str, digest_lookup, 0); }
/*! \brief Custom handler for turning a string bind into a pj_sockaddr */ static int transport_bind_handler(const struct aco_option *opt, struct ast_variable *var, void *obj) { struct ast_sip_transport *transport = obj; pj_str_t buf; return (pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, var->value), &transport->host) != PJ_SUCCESS) ? -1 : 0; }
void SipTransportBroker::findLocalAddressFromTransport(pjsip_transport *transport, pjsip_transport_type_e transportType, const std::string &host, std::string &addr, pj_uint16_t &port) const { // Initialize the sip port with the default SIP port port = pjsip_transport_get_default_port_for_type(transportType); // Initialize the sip address with the hostname const pj_str_t *pjMachineName = pj_gethostname(); addr = std::string(pjMachineName->ptr, pjMachineName->slen); // Update address and port with active transport RETURN_IF_NULL(transport, "Transport is NULL in findLocalAddress, using local address %s :%d", addr.c_str(), port); // get the transport manager associated with the SIP enpoint pjsip_tpmgr *tpmgr = pjsip_endpt_get_tpmgr(endpt_); RETURN_IF_NULL(tpmgr, "Transport manager is NULL in findLocalAddress, using local address %s :%d", addr.c_str(), port); pj_str_t pjstring; pj_cstr(&pjstring, host.c_str()); pjsip_tpselector tp_sel = getTransportSelector(transport); pjsip_tpmgr_fla2_param param = {transportType, &tp_sel, pjstring, PJ_FALSE, {nullptr, 0}, 0, nullptr}; if (pjsip_tpmgr_find_local_addr2(tpmgr, &pool_, ¶m) != PJ_SUCCESS) { WARN("Could not retrieve local address and port from transport, using %s :%d", addr.c_str(), port); return; } // Update local address based on the transport type addr = std::string(param.ret_addr.ptr, param.ret_addr.slen); // Determine the local port based on transport information port = param.ret_port; }
/* * Initialize and register AMR codec factory to pjmedia endpoint. */ PJ_DEF(pj_status_t) pjmedia_codec_opencore_amr_init( pjmedia_endpt *endpt, unsigned options) { pjmedia_codec_mgr *codec_mgr; pj_str_t codec_name; pj_status_t status; if (amr_codec_factory.pool != NULL) return PJ_SUCCESS; /* Create AMR codec factory. */ amr_codec_factory.base.op = &amr_factory_op; amr_codec_factory.base.factory_data = NULL; amr_codec_factory.endpt = endpt; #ifdef USE_AMRNB amr_codec_factory.init[IDX_AMR_NB] = ((options & PJMEDIA_AMR_NO_NB) == 0); #else amr_codec_factory.init[IDX_AMR_NB] = PJ_FALSE; #endif #ifdef USE_AMRWB amr_codec_factory.init[IDX_AMR_WB] = ((options & PJMEDIA_AMR_NO_WB) == 0); #else amr_codec_factory.init[IDX_AMR_WB] = PJ_FALSE; #endif amr_codec_factory.pool = pjmedia_endpt_create_pool(endpt, "amr", 1000, 1000); if (!amr_codec_factory.pool) return PJ_ENOMEM; /* Get the codec manager. */ codec_mgr = pjmedia_endpt_get_codec_mgr(endpt); if (!codec_mgr) { status = PJ_EINVALIDOP; goto on_error; } /* Register format match callback. */ pj_cstr(&codec_name, "AMR"); status = pjmedia_sdp_neg_register_fmt_match_cb( &codec_name, &pjmedia_codec_amr_match_sdp); if (status != PJ_SUCCESS) goto on_error; /* Register codec factory to endpoint. */ status = pjmedia_codec_mgr_register_factory(codec_mgr, &amr_codec_factory.base); if (status != PJ_SUCCESS) goto on_error; /* Done. */ return PJ_SUCCESS; on_error: pj_pool_release(amr_codec_factory.pool); amr_codec_factory.pool = NULL; return status; }
void $UPROTO$_server_join($UPROTO$_server_t *userver, char *multicast_ip) { pj_ip_mreq mreq; pj_str_t s, s1; pj_status_t ret; pj_bzero(&mreq, sizeof(pj_ip_mreq)); mreq.imr_multiaddr = pj_inet_addr(pj_cstr(&s, multicast_ip)); mreq.imr_interface = pj_inet_addr(pj_cstr(&s1, "0.0.0.0")); //mreq.imr_multiaddr.s_addr = inet_addr(multicast_ip); //mreq.imr_interface.s_addr = htonl(INADDR_ANY); pj_mutex_lock(userver->mutex); ret = pj_sock_setsockopt(userver->fd, PJ_SOL_IP, PJ_IP_ADD_MEMBERSHIP, &mreq,sizeof(mreq)); PERROR_IF_TRUE(ret != 0, "Error in joining mcast group"); pj_mutex_unlock(userver->mutex); }
/*! * \brief astobj2 callback for adding digest challenges to responses * * \param realm An auth's realm to build a challenge from * \param tdata The response to add the challenge to * \param rdata The request the challenge is in response to * \param is_stale Indicates whether nonce on incoming request was stale */ static void challenge(const char *realm, pjsip_tx_data *tdata, const pjsip_rx_data *rdata, int is_stale) { pj_str_t qop; pj_str_t pj_nonce; pjsip_auth_srv auth_server; struct ast_str *nonce = ast_str_alloca(256); char time_buf[32]; time_t timestamp = time(NULL); snprintf(time_buf, sizeof(time_buf), "%d", (int) timestamp); build_nonce(&nonce, time_buf, rdata, realm); setup_auth_srv(tdata->pool, &auth_server, realm); pj_cstr(&pj_nonce, ast_str_buffer(nonce)); pj_cstr(&qop, "auth"); pjsip_auth_srv_challenge(&auth_server, &qop, &pj_nonce, NULL, is_stale ? PJ_TRUE : PJ_FALSE, tdata); }
static pj_stun_msg* create_msgint3(pj_pool_t *pool, test_vector *v) { pj_stun_msg *msg; pj_sockaddr mapped_addr; pj_str_t s1; pj_status_t status; status = pj_stun_msg_create(pool, v->msg_type, PJ_STUN_MAGIC, (pj_uint8_t*)v->tsx_id, &msg); if (status != PJ_SUCCESS) goto on_error; status = pj_stun_msg_add_string_attr(pool, msg, PJ_STUN_ATTR_SOFTWARE, pj_cstr(&s1, "test vector")); if (status != PJ_SUCCESS) goto on_error; status = pj_sockaddr_init(pj_AF_INET6(), &mapped_addr, pj_cstr(&s1, "2001:db8:1234:5678:11:2233:4455:6677"), 32853); if (status != PJ_SUCCESS) goto on_error; status = pj_stun_msg_add_sockaddr_attr(pool, msg, PJ_STUN_ATTR_XOR_MAPPED_ADDR, PJ_TRUE, &mapped_addr, sizeof(pj_sockaddr)); if (status != PJ_SUCCESS) goto on_error; status = pj_stun_msg_add_msgint_attr(pool, msg); if (status != PJ_SUCCESS) goto on_error; status = pj_stun_msg_add_uint_attr(pool, msg, PJ_STUN_ATTR_FINGERPRINT, 0); if (status != PJ_SUCCESS) goto on_error; return msg; on_error: app_perror(" error: create_msgint3()", status); return NULL; }
static void rewrite_uri(pjsip_rx_data *rdata, pjsip_sip_uri *uri) { pj_cstr(&uri->host, rdata->pkt_info.src_name); if (strcasecmp("udp", rdata->tp_info.transport->type_name)) { uri->transport_param = pj_str(rdata->tp_info.transport->type_name); } else { uri->transport_param.slen = 0; } uri->port = rdata->pkt_info.src_port; }
static void *xpidf_allocate_body(void *data) { struct ast_sip_exten_state_data *state_data = data; char *local = ast_strdupa(state_data->local); pjxpidf_pres *pres; pj_str_t name; pres = pjxpidf_create(state_data->pool, pj_cstr(&name, ast_strip_quoted(local, "<", ">"))); return pres; }
static void *pidf_allocate_body(void *data) { struct ast_sip_exten_state_data *state_data = data; pjpidf_pres *pres; pj_str_t entity; pres = pjpidf_create(state_data->pool, pj_cstr(&entity, state_data->local)); return pres; }
void $UPROTO$_server_leave($UPROTO$_server_t *userver, char *multicast_ip) { pj_ip_mreq mreq; pj_str_t s; pj_status_t ret; mreq.imr_multiaddr = pj_inet_addr(pj_cstr(&s, multicast_ip)); mreq.imr_interface.s_addr = pj_htonl(PJ_INADDR_ANY); pj_mutex_lock(userver->mutex); ret = pj_sock_setsockopt(userver->fd, PJ_SOL_IP, PJ_IP_DROP_MEMBERSHIP, &mreq,sizeof(mreq)); PERROR_IF_TRUE(ret != 0, "Error in leaving mcast group"); pj_mutex_unlock(userver->mutex); }
void SIPAccount::initTlsConfiguration (void) { // TLS listener is unique and should be only modified through IP2IP_PROFILE setTlsListenerPort (atoi (_tlsPortStr.c_str())); delete _tlsSetting; _tlsSetting = new pjsip_tls_setting; assert (_tlsSetting); pjsip_tls_setting_default (_tlsSetting); pj_cstr (&_tlsSetting->ca_list_file, _tlsCaListFile.c_str()); pj_cstr (&_tlsSetting->cert_file, _tlsCertificateFile.c_str()); pj_cstr (&_tlsSetting->privkey_file, _tlsPrivateKeyFile.c_str()); pj_cstr (&_tlsSetting->password, _tlsPassword.c_str()); _tlsSetting->method = sslMethodStringToPjEnum (_tlsMethod); pj_cstr (&_tlsSetting->ciphers, _tlsCiphers.c_str()); pj_cstr (&_tlsSetting->server_name, _tlsServerName.c_str()); _tlsSetting->verify_server = _tlsVerifyServer ? PJ_TRUE: PJ_FALSE; _tlsSetting->verify_client = _tlsVerifyClient ? PJ_TRUE: PJ_FALSE; _tlsSetting->require_client_cert = _tlsRequireClientCertificate ? PJ_TRUE: PJ_FALSE; _tlsSetting->timeout.sec = atol (_tlsNegotiationTimeoutSec.c_str()); _tlsSetting->timeout.msec = atol (_tlsNegotiationTimeoutMsec.c_str()); }
static pj_stun_msg* create_msgint2(pj_pool_t *pool, test_vector *v) { pj_stun_msg *msg; pj_sockaddr_in mapped_addr; pj_str_t s1; pj_stun_msg_create(pool, v->msg_type, PJ_STUN_MAGIC, (pj_uint8_t*)v->tsx_id, &msg); pj_stun_msg_add_string_attr(pool, msg, PJ_STUN_ATTR_SOFTWARE, pj_cstr(&s1, "test vector")); pj_sockaddr_in_init(&mapped_addr, pj_cstr(&s1, "127.0.0.1"), 32853); pj_stun_msg_add_sockaddr_attr(pool, msg, PJ_STUN_ATTR_XOR_MAPPED_ADDR, PJ_TRUE, &mapped_addr, sizeof(pj_sockaddr_in)); pj_stun_msg_add_msgint_attr(pool, msg); pj_stun_msg_add_uint_attr(pool, msg, PJ_STUN_ATTR_FINGERPRINT, 0); return msg; }
/*! * \internal * \brief Implements PJSIP_HEADER 'add' by inserting the specified header into thge list. * * Retrieve the header_datastore from the session or create one if it doesn't exist. * Create and initialize the list if needed. * Create the pj_strs for name and value. * Create pjsip_msg and hdr_list_entry. * Add the entry to the list. */ static int add_header(void *obj) { struct header_data *data = obj; struct ast_sip_session *session = data->channel->session; pj_pool_t *pool = session->inv_session->dlg->pool; pj_str_t pj_header_name; pj_str_t pj_header_value; struct hdr_list_entry *le; struct hdr_list *list; RAII_VAR(struct ast_datastore *, datastore, ast_sip_session_get_datastore(session, header_datastore.type), ao2_cleanup); if (!datastore) { if (!(datastore = ast_sip_session_alloc_datastore(&header_datastore, header_datastore.type)) || !(datastore->data = pj_pool_alloc(pool, sizeof(struct hdr_list))) || ast_sip_session_add_datastore(session, datastore)) { ast_log(AST_LOG_ERROR, "Unable to create datastore for header functions.\n"); return -1; } AST_LIST_HEAD_INIT((struct hdr_list *) datastore->data); } ast_debug(1, "Adding header %s with value %s\n", data->header_name, data->header_value); pj_cstr(&pj_header_name, data->header_name); pj_cstr(&pj_header_value, data->header_value); le = pj_pool_zalloc(pool, sizeof(struct hdr_list_entry)); le->hdr = (pjsip_hdr *) pjsip_generic_string_hdr_create(pool, &pj_header_name, &pj_header_value); list = datastore->data; AST_LIST_INSERT_TAIL(list, le, nextptr); return 0; }
/* Util: create file player, each time trying different paths until we get * the file. */ static pj_status_t create_player(unsigned path_cnt, const char *paths[], pjsua_player_id *p_id) { pj_str_t name; pj_status_t status = PJ_ENOTFOUND; unsigned i; for (i=0; i<path_cnt; ++i) { status = pjsua_player_create(pj_cstr(&name, paths[i]), 0, p_id); if (status == PJ_SUCCESS) return PJ_SUCCESS; } return status; }
static pjmedia_sdp_attr* generate_rtpmap_attr(struct ast_sip_session *session, pjmedia_sdp_media *media, pj_pool_t *pool, int rtp_code, int asterisk_format, struct ast_format *format, int code) { pjmedia_sdp_rtpmap rtpmap; pjmedia_sdp_attr *attr = NULL; char tmp[64]; enum ast_rtp_options options = session->endpoint->media.g726_non_standard ? AST_RTP_OPT_G726_NONSTANDARD : 0; snprintf(tmp, sizeof(tmp), "%d", rtp_code); pj_strdup2(pool, &media->desc.fmt[media->desc.fmt_count++], tmp); rtpmap.pt = media->desc.fmt[media->desc.fmt_count - 1]; rtpmap.clock_rate = ast_rtp_lookup_sample_rate2(asterisk_format, format, code); pj_strdup2(pool, &rtpmap.enc_name, ast_rtp_lookup_mime_subtype2(asterisk_format, format, code, options)); if (!pj_stricmp2(&rtpmap.enc_name, "opus")) { pj_cstr(&rtpmap.param, "2"); } else { pj_cstr(&rtpmap.param, NULL); } pjmedia_sdp_rtpmap_to_attr(pool, &rtpmap, &attr); return attr; }
/*! \brief Custom handler for turning a string bind into a pj_sockaddr */ static int transport_bind_handler(const struct aco_option *opt, struct ast_variable *var, void *obj) { struct ast_sip_transport *transport = obj; pj_str_t buf; int rc; RAII_VAR(struct ast_sip_transport_state *, state, find_or_create_temporary_state(transport), ao2_cleanup); if (!state) { return -1; } rc = pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, var->value), &state->host); return rc != PJ_SUCCESS ? -1 : 0; }
int my_atoi(const char *cs) { pj_str_t s; pj_cstr(&s, cs); if (cs[0] == '-') { s.ptr++, s.slen--; return 0 - (int)pj_strtoul(&s); } else if (cs[0] == '+') { s.ptr++, s.slen--; return pj_strtoul(&s); } else { return pj_strtoul(&s); } }
static void open_udp_socket(response_client_t *uclient, char *server, int port) { pj_sockaddr_in *saddr; pj_str_t s; // open socket CHECK(__FILE__, pj_sock_socket(PJ_AF_INET, PJ_SOCK_STREAM, 0, &uclient->fd)); uclient->connect_data = malloc(sizeof(pj_sockaddr_in)); saddr = (pj_sockaddr_in *)uclient->connect_data; pj_bzero((void *)saddr, sizeof(pj_sockaddr_in)); saddr->sin_family = PJ_AF_INET; saddr->sin_port = pj_htons(port); saddr->sin_addr = pj_inet_addr(pj_cstr(&s, server)); CHECK(__FILE__,pj_sock_connect(uclient->fd, (const pj_sockaddr_t *)saddr, sizeof(pj_sockaddr_in))); }
pj_status_t parse_url(const char *url, pj_http_url *hurl) { pj_str_t surl; pj_status_t status; pj_cstr(&surl, url); status = pj_http_req_parse_url(&surl, hurl); #ifdef VERBOSE if (!status) { printf("URL: %s\nProtocol: %.*s\nHost: %.*s\nPort: %d\nPath: %.*s\n\n", url, STR_PREC(hurl->protocol), STR_PREC(hurl->host), hurl->port, STR_PREC(hurl->path)); } else { } #endif return status; }