int custom_hdrs_add(struct list *hdrs, const char *name,
const char *fmt, ...)
{
struct pl temp_pl = { NULL, 0 };
struct sip_hdr *hdr;
char *value = NULL;
va_list ap;
int err = 0;
va_start(ap, fmt);
err = re_vsdprintf(&value, fmt, ap);
va_end(ap);
hdr = mem_zalloc(sizeof(*hdr), hdr_destructor);
if (!hdr || !value)
goto error;
pl_set_str(&temp_pl, name);
err = pl_dup(&hdr->name, &temp_pl);
if (err)
goto error;
pl_set_str(&hdr->val, value);
hdr->id = SIP_HDR_NONE;
list_append(hdrs, &hdr->le, hdr);
return 0;
error:
mem_deref(hdr);
return err;
}
/**
* Print a formatted string to a buffer
*
* @param strp Buffer pointer for output string
* @param fmt Formatted string
*
* @return 0 if success, otherwise errorcode
*/
int re_sdprintf(char **strp, const char *fmt, ...)
{
va_list ap;
int err;
va_start(ap, fmt);
err = re_vsdprintf(strp, fmt, ap);
va_end(ap);
return err;
}
int sip_req_send(struct ua *ua, const char *method, const char *uri,
sip_resp_h *resph, void *arg, const char *fmt, ...)
{
const char *routev[1];
struct sip_req *sr;
int err;
info("baresip.sipreq.sip_req_send()\n");
if (!ua || !method || !uri || !fmt)
return EINVAL;
routev[0] = ua_outbound(ua);
sr = mem_zalloc(sizeof(*sr), destructor);
if (!sr)
return ENOMEM;
sr->resph = resph;
sr->arg = arg;
err = str_dup(&sr->method, method);
if (fmt) {
va_list ap;
va_start(ap, fmt);
err |= re_vsdprintf(&sr->fmt, fmt, ap);
va_end(ap);
}
if (err)
goto out;
err = sip_dialog_alloc(&sr->dlg, uri, uri, NULL, ua_aor(ua),
routev[0] ? routev : NULL,
routev[0] ? 1 : 0);
if (err)
goto out;
err = sip_auth_alloc(&sr->auth, auth_handler, ua_prm(ua), true);
if (err)
goto out;
err = request(sr);
out:
if (err)
mem_deref(sr);
return err;
}
int sdp_format_set_params(struct sdp_format *fmt, const char *params, ...)
{
int err = 0;
if (!fmt)
return EINVAL;
fmt->params = mem_deref(fmt->params);
if (params) {
va_list ap;
va_start(ap, params);
err = re_vsdprintf(&fmt->params, params, ap);
va_end(ap);
}
return err;
}
void vlog(enum log_level level, const char *fmt, va_list ap)
{
struct le *le;
char *msg;
int err;
err = re_vsdprintf(&msg, fmt, ap);
if (err)
return;
if (lg.stder) {
bool color = level == LOG_LEVEL_WARN
|| level == LOG_LEVEL_ERROR;
if (color)
(void)re_fprintf(stderr, "\x1b[31m"); /* Red */
(void)re_fprintf(stderr, "%s", msg);
if (color)
(void)re_fprintf(stderr, "\x1b[;m");
}
le = lg.logl.head;
while (le) {
struct log *log = le->data;
le = le->next;
if (log->h)
log->h(level, msg);
}
mem_deref(msg);
}
int mqtt_publish_message(struct mqtt *mqtt, const char *topic,
const char *fmt, ...)
{
char *message;
va_list ap;
int ret;
int err = 0;
if (!mqtt || !topic || !fmt)
return EINVAL;
va_start(ap, fmt);
err = re_vsdprintf(&message, fmt, ap);
va_end(ap);
if (err)
return err;
ret = mosquitto_publish(mqtt->mosq,
NULL,
topic,
(int)str_len(message),
message,
0,
false);
if (ret != MOSQ_ERR_SUCCESS) {
warning("mqtt: failed to publish (%s)\n",
mosquitto_strerror(ret));
err = EINVAL;
goto out;
}
out:
mem_deref(message);
return err;
}
int sdp_format_add(struct sdp_format **fmtp, struct sdp_media *m,
bool prepend, const char *id, const char *name,
uint32_t srate, uint8_t ch,
sdp_fmtp_cmp_h *cmph, void *data, bool ref,
const char *params, ...)
{
struct sdp_format *fmt;
int err;
if (!m)
return EINVAL;
if (!id && (m->dynpt > RTP_DYNPT_END))
return ERANGE;
fmt = mem_zalloc(sizeof(*fmt), destructor);
if (!fmt)
return ENOMEM;
if (prepend)
list_prepend(&m->lfmtl, &fmt->le, fmt);
else
list_append(&m->lfmtl, &fmt->le, fmt);
if (id)
err = str_dup(&fmt->id, id);
else
err = re_sdprintf(&fmt->id, "%i", m->dynpt++);
if (err)
goto out;
if (name) {
err = str_dup(&fmt->name, name);
if (err)
goto out;
}
if (params) {
va_list ap;
va_start(ap, params);
err = re_vsdprintf(&fmt->params, params, ap);
va_end(ap);
if (err)
goto out;
}
fmt->pt = atoi(fmt->id);
fmt->srate = srate;
fmt->ch = ch;
fmt->cmph = cmph;
fmt->data = ref ? mem_ref(data) : data;
fmt->ref = ref;
fmt->sup = true;
out:
if (err)
mem_deref(fmt);
else if (fmtp)
*fmtp = fmt;
return err;
}
int sipevent_accept(struct sipnot **notp, struct sipevent_sock *sock,
const struct sip_msg *msg, struct sip_dialog *dlg,
const struct sipevent_event *event,
uint16_t scode, const char *reason, uint32_t expires_min,
uint32_t expires_dfl, uint32_t expires_max,
const char *cuser, const char *ctype,
sip_auth_h *authh, void *aarg, bool aref,
sipnot_close_h *closeh, void *arg, const char *fmt, ...)
{
struct sipnot *not;
uint32_t expires;
int err;
if (!notp || !sock || !msg || !scode || !reason || !expires_dfl ||
!expires_max || !cuser || !ctype || expires_dfl < expires_min)
return EINVAL;
not = mem_zalloc(sizeof(*not), destructor);
if (!not)
return ENOMEM;
if (!pl_strcmp(&msg->met, "REFER")) {
err = str_dup(¬->event, "refer");
if (err)
goto out;
err = re_sdprintf(¬->id, "%u", msg->cseq.num);
if (err)
goto out;
}
else {
if (!event) {
err = EINVAL;
goto out;
}
err = pl_strdup(¬->event, &event->event);
if (err)
goto out;
if (pl_isset(&event->id)) {
err = pl_strdup(¬->id, &event->id);
if (err)
goto out;
}
}
if (dlg) {
not->dlg = mem_ref(dlg);
}
else {
err = sip_dialog_accept(¬->dlg, msg);
if (err)
goto out;
}
hash_append(sock->ht_not,
hash_joaat_str(sip_dialog_callid(not->dlg)),
¬->he, not);
err = sip_auth_alloc(¬->auth, authh, aarg, aref);
if (err)
goto out;
err = str_dup(¬->cuser, cuser);
if (err)
goto out;
err = str_dup(¬->ctype, ctype);
if (err)
goto out;
if (fmt) {
va_list ap;
va_start(ap, fmt);
err = re_vsdprintf(¬->hdrs, fmt, ap);
va_end(ap);
if (err)
goto out;
}
not->expires_min = expires_min;
not->expires_dfl = expires_dfl;
not->expires_max = expires_max;
not->substate = SIPEVENT_PENDING;
not->sock = mem_ref(sock);
not->sip = mem_ref(sock->sip);
not->closeh = closeh ? closeh : internal_close_handler;
not->arg = arg;
if (pl_isset(&msg->expires))
expires = pl_u32(&msg->expires);
else
expires = not->expires_dfl;
sipnot_refresh(not, expires);
err = sipnot_reply(not, msg, scode, reason);
if (err)
goto out;
not->subscribed = true;
out:
if (err)
mem_deref(not);
else
*notp = not;
return err;
}
