/* set the body of a response */
static int set_reply_body(struct sip_msg* msg, str* body, str* content_type)
{
char* buf;
int len;
int value_len;
str nb = *body;
str nc = *content_type;
/* add content-type */
value_len = nc.len;
len=sizeof("Content-Type: ") - 1 + value_len + CRLF_LEN;
buf=pkg_malloc(sizeof(char)*(len));
if (buf==0) {
LM_ERR("out of pkg memory\n");
return -1;
}
memcpy(buf, "Content-Type: ", sizeof("Content-Type: ") - 1);
memcpy(buf+sizeof("Content-Type: ") - 1, nc.s, value_len);
memcpy(buf+sizeof("Content-Type: ") - 1 + value_len, CRLF, CRLF_LEN);
if (add_lump_rpl(msg, buf, len, LUMP_RPL_HDR) == 0) {
LM_ERR("failed to insert content-type lump\n");
pkg_free(buf);
return -1;
}
pkg_free(buf);
/* add body */
if (add_lump_rpl(msg, nb.s, nb.len, LUMP_RPL_BODY) == 0) {
LM_ERR("cannot add body lump\n");
return -1;
}
return 1;
}
static int xcaps_send_reply(sip_msg_t *msg, int code, str *reason,
str *hdrs, str *ctype, str *body)
{
str tbuf;
if(hdrs && hdrs->len>0)
{
if (add_lump_rpl(msg, hdrs->s, hdrs->len, LUMP_RPL_HDR) == 0)
{
LM_ERR("failed to insert extra-headers lump\n");
return -1;
}
}
if(ctype && ctype->len>0)
{
/* add content-type */
tbuf.len=sizeof("Content-Type: ") - 1 + ctype->len + CRLF_LEN;
tbuf.s=pkg_malloc(sizeof(char)*(tbuf.len));
if (tbuf.len==0)
{
LM_ERR("out of pkg memory\n");
return -1;
}
memcpy(tbuf.s, "Content-Type: ", sizeof("Content-Type: ") - 1);
memcpy(tbuf.s+sizeof("Content-Type: ") - 1, ctype->s, ctype->len);
memcpy(tbuf.s+sizeof("Content-Type: ") - 1 + ctype->len,
CRLF, CRLF_LEN);
if (add_lump_rpl(msg, tbuf.s, tbuf.len, LUMP_RPL_HDR) == 0)
{
LM_ERR("failed to insert content-type lump\n");
pkg_free(tbuf.s);
return -1;
}
pkg_free(tbuf.s);
}
if(body && body->len>0)
{
if (add_lump_rpl(msg, body->s, body->len, LUMP_RPL_BODY) < 0)
{
LM_ERR("Error while adding reply lump\n");
return -1;
}
}
if (slb.freply(msg, code, reason) < 0)
{
LM_ERR("Error while sending reply\n");
return -1;
}
return 0;
}
static int ws_send_reply(sip_msg_t *msg, int code, str *reason, str *hdrs)
{
if (hdrs && hdrs->len > 0)
{
if (add_lump_rpl(msg, hdrs->s, hdrs->len, LUMP_RPL_HDR) == 0)
{
LM_ERR("inserting extra-headers lump\n");
update_stat(ws_failed_handshakes, 1);
return -1;
}
}
if (ws_slb.freply(msg, code, reason) < 0)
{
LM_ERR("sending reply\n");
update_stat(ws_failed_handshakes, 1);
return -1;
}
update_stat(
code == 101 ? ws_successful_handshakes : ws_failed_handshakes,
1);
return 0;
}
/**
* reply 421 with require header
*/
int reply_421(struct sip_msg* msg)
{
str hdr_append;
char buffer[256];
hdr_append.s = buffer;
hdr_append.s[0]='\0';
hdr_append.len = sprintf(hdr_append.s, "Require: eventlist\r\n");
if(hdr_append.len < 0)
{
LM_ERR("unsuccessful sprintf\n");
return -1;
}
hdr_append.s[hdr_append.len]= '\0';
if (add_lump_rpl( msg, hdr_append.s, hdr_append.len, LUMP_RPL_HDR)==0 )
{
LM_ERR("unable to add lump_rl\n");
return -1;
}
if (slb.freply(msg, 421, &pu_421_rpl) < 0)
{
LM_ERR("while sending reply\n");
return -1;
}
return 0;
}
inline int add_contact(struct sip_msg* msg , str* user)
{
struct lump_rpl *lump;
char *buf, *p;
int len;
len = 9 /*"Contact: "*/ + user->len/*user*/ + 1 /*"@"*/
+ domain.len/*host*/ + 6/*"<sip:>"*/ + CRLF_LEN;
buf = pkg_malloc( len );
if(!buf) {
LM_ERR("out of memory! \n");
return -1;
}
p = buf;
append_str( p, "Contact: " , 9);
append_str( p, "<sip:" , 5);
append_str( p, user->s, user->len);
*(p++) = '@';
append_str( p, domain.s, domain.len);
*(p++) = '>';
append_str( p, CRLF, CRLF_LEN);
lump = build_lump_rpl( buf , len , LUMP_RPL_HDR);
if(!lump) {
LM_ERR("unable to build lump_rpl! \n");
pkg_free( buf );
return -1;
}
add_lump_rpl( msg , lump );
pkg_free(buf);
return 1;
}
static int append_time_f(struct sip_msg* msg, char* p1, char *p2)
{
size_t len;
char time_str[MAX_TIME];
time_t now;
struct tm *bd_time;
now=time(0);
bd_time=gmtime(&now);
if (bd_time==NULL) {
LOG(L_ERR, "ERROR: append_time: gmtime failed\n");
return -1;
}
len=strftime(time_str, MAX_TIME, TIME_FORMAT, bd_time);
if (len>MAX_TIME-2 || len==0) {
LOG(L_ERR, "ERROR: append_time: unexpected time length\n");
return -1;
}
time_str[len]='\r';
time_str[len+1]='\n';
if (add_lump_rpl(msg, time_str, len+2, LUMP_RPL_HDR)==0)
{
LOG(L_ERR, "ERROR: append_time: unable to add lump\n");
return -1;
}
return 1;
}
static int sr_mono_hdr_append_to_reply (MonoString *hv)
{
str txt = {0};
sr_mono_env_t *env_M;
env_M = sr_mono_env_get();
txt.s = mono_string_to_utf8(hv);
if(txt.s==NULL || env_M->msg==NULL)
goto error;
txt.len = strlen(txt.s);
LM_DBG("append to reply: %s\n", txt.s);
if(add_lump_rpl(env_M->msg, txt.s, txt.len, LUMP_RPL_HDR)==0)
{
LM_ERR("unable to add reply lump\n");
goto error;
}
mono_free(txt.s);
return 0;
error:
if(txt.s!=NULL)
mono_free(txt.s);
return -1;
}
/**
* Adds a header to the reply message
* @param msg - the request to add a header to its reply
* @param content - the str containing the new header
* @returns 1 on succes, 0 on failure
*/
int cscf_add_header_rpl(struct sip_msg *msg, str *hdr)
{
if (add_lump_rpl( msg, hdr->s, hdr->len, LUMP_RPL_HDR)==0) {
LM_ERR("ERR:cscf_add_header_rpl: Can't add header <%.*s>\n",
hdr->len,hdr->s);
return 0;
}
return 1;
}
/*
* Send a reply
*/
int send_reply(struct sip_msg* _m)
{
long code;
char* msg = MSG_200; /* makes gcc shut up */
char* buf;
if (contact.data_len > 0) {
add_lump_rpl( _m, contact.buf, contact.data_len, LUMP_RPL_HDR|LUMP_RPL_NODUP|LUMP_RPL_NOFREE);
contact.data_len = 0;
}
code = codes[rerrno];
switch(code) {
case 200: msg = MSG_200; break;
case 400: msg = MSG_400; break;
case 500: msg = MSG_500; break;
case 503: msg = MSG_503; break;
}
if (code != 200) {
buf = (char*)pkg_malloc(E_INFO_LEN + error_info[rerrno].len + CRLF_LEN + 1);
if (!buf) {
LOG(L_ERR, "send_reply(): No memory left\n");
return -1;
}
memcpy(buf, E_INFO, E_INFO_LEN);
memcpy(buf + E_INFO_LEN, error_info[rerrno].s, error_info[rerrno].len);
memcpy(buf + E_INFO_LEN + error_info[rerrno].len, CRLF, CRLF_LEN);
add_lump_rpl( _m, buf, E_INFO_LEN + error_info[rerrno].len + CRLF_LEN,
LUMP_RPL_HDR|LUMP_RPL_NODUP);
if (code >= 500 && code < 600 && retry_after) {
if (add_retry_after(_m) < 0) {
return -1;
}
}
}
if (sl_reply(_m, (char*)code, msg) == -1) {
LOG(L_ERR, "send_reply(): Error while sending %ld %s\n", code, msg);
return -1;
} else return 0;
}
static int append_to_reply_f(struct sip_msg* msg, char* key, char* str)
{
if ( add_lump_rpl( msg, key, strlen(key), LUMP_RPL_HDR)==0 )
{
LOG(L_ERR,"ERROR:append_to_reply : unable to add lump_rl\n");
return -1;
}
return 1;
}
int rls_prepare_subscription_response(rl_subscription_t *s, struct sip_msg *m) {
/* char *hdr = "Supported: eventlist\r\n"; */
char *hdr = "Require: eventlist\r\n";
if (s->type != rls_external_subscription) return -1;
if (!add_lump_rpl(m, hdr, strlen(hdr), LUMP_RPL_HDR)) return -1;
return sm_prepare_subscription_response(rls_manager, &s->u.external, m);
}
static void add_expires_to_rpl(struct sip_msg *_m, int expires)
{
char tmp[64];
if (expires < 0) expires = 0;
sprintf(tmp, "Expires: %d\r\n", expires);
if (!add_lump_rpl(_m, tmp, strlen(tmp), LUMP_RPL_HDR)) {
LOG(L_ERR, "Can't add expires header to the response\n");
}
}
static int l_siplua_add_lump_rpl(lua_State *L)
{
struct sipapi_object *o;
const char *name;
size_t len;
o = luaL_checkudata(L, 1, "siplua.api");
name = luaL_checklstring(L, 2, &len);
add_lump_rpl(o->msg, (char *)name, len, LUMP_RPL_HDR);
return 1;
}
static int cpl_update_contact(struct sip_msg* msg, char* str1, char* str2)
{
TRedirectMessage *redirect;
struct lump_rpl *lump;
char *buf, *p;
int len;
int i;
if (resp_code!=REDIRECT_CALL || !resp_buf || !resp_len)
return -1;
redirect = parseRedirectResponse( resp_buf , resp_len );
printRedirectMessage( redirect );
len = 9 /*"Contact: "*/;
/* locations*/
for( i=0 ; i<redirect->numberOfLocations; i++)
len += 2/*"<>"*/ + redirect->locations[i].urlLength;
len += redirect->numberOfLocations -1 /*","*/;
len += CRLF_LEN;
buf = pkg_malloc( len );
if(!buf)
{
LOG(L_ERR,"ERROR:cpl_update_contact: out of memory! \n");
return -1;
}
p = buf;
memcpy( p , "Contact: " , 9);
p += 9;
for( i=0 ; i<redirect->numberOfLocations; i++)
{
if (i) *(p++)=',';
*(p++) = '<';
memcpy(p,redirect->locations[i].URL,redirect->locations[i].urlLength);
p += redirect->locations[i].urlLength;
*(p++) = '>';
}
memcpy(p,CRLF,CRLF_LEN);
lump = build_lump_rpl( buf , len , LUMP_RPL_HDR);
if(!buf)
{
LOG(L_ERR,"ERROR:cpl_update_contact: unable to build lump_rpl! \n");
pkg_free( buf );
return -1;
}
add_lump_rpl( msg , lump );
freeRedirectMessage( redirect );
pkg_free(buf);
return 1;
}
static inline int do_script_download(struct sip_msg *msg)
{
str user = STR_NULL;
str script = STR_NULL;
/* get the destination user name */
if (get_dest_user( msg, &user, 0)==-1)
goto error;
/* get the user's xml script from the database */
if (get_user_script(&user, &script, 0)==-1)
goto error;
/* add a lump with content-type hdr */
if (add_lump_rpl( msg, CONTENT_TYPE_HDR, CONTENT_TYPE_HDR_LEN,
LUMP_RPL_HDR)==0) {
LOG(L_ERR,"ERROR:cpl-c:do_script_download: cannot build hdr lump\n");
cpl_err = &intern_err;
goto error;
}
if (script.s!=0) {
/*DBG("script len=%d\n--------\n%.*s\n--------\n",
script.len, script.len, script.s);*/
/* user has a script -> add a body lump */
if ( add_lump_rpl( msg, script.s, script.len, LUMP_RPL_BODY)==0) {
LOG(L_ERR,"ERROR:cpl-c:do_script_download: cannot build "
"body lump\n");
cpl_err = &intern_err;
goto error;
}
/* build_lump_rpl duplicates the added text, so free the original */
shm_free( script.s );
}
return 0;
error:
if (script.s)
shm_free(script.s);
return -1;
}
/**
* reply 200 ok with require header
*/
int reply_200(struct sip_msg* msg, str* contact, int expires)
{
str hdr_append;
int len;
hdr_append.s = (char *)pkg_malloc( sizeof(char)*(contact->len+ 70));
if(hdr_append.s == NULL)
{
LM_ERR("no more pkg memory\n");
return -1;
}
hdr_append.len = sprintf(hdr_append.s, "Expires: %d\r\n", expires);
if(hdr_append.len< 0)
{
LM_ERR("unsuccessful sprintf\n");
goto error;
}
strncpy(hdr_append.s+hdr_append.len ,"Contact: <", 10);
hdr_append.len += 10;
strncpy(hdr_append.s+hdr_append.len, contact->s, contact->len);
hdr_append.len+= contact->len;
strncpy(hdr_append.s+hdr_append.len, ">", 1);
hdr_append.len += 1;
strncpy(hdr_append.s+hdr_append.len, CRLF, CRLF_LEN);
hdr_append.len += CRLF_LEN;
len = sprintf(hdr_append.s+ hdr_append.len, "Require: eventlist\r\n");
if(len < 0)
{
LM_ERR("unsuccessful sprintf\n");
goto error;
}
hdr_append.len+= len;
hdr_append.s[hdr_append.len]= '\0';
if (add_lump_rpl( msg, hdr_append.s, hdr_append.len, LUMP_RPL_HDR)==0 )
{
LM_ERR("unable to add lump_rl\n");
goto error;
}
if(slb.freply(msg, 200, &su_200_rpl) < 0)
{
LM_ERR("while sending reply\n");
goto error;
}
pkg_free(hdr_append.s);
return 0;
error:
pkg_free(hdr_append.s);
return -1;
}
static inline int do_script_download(struct sip_msg *msg)
{
str username = {0,0};
str domain = {0,0};
str script = {0,0};
/* get the destination user name */
if (get_dest_user( msg, &username, &domain)!=0)
goto error;
/* get the user's xml script from the database */
if (get_user_script( &username, cpl_env.use_domain?&domain:0,
&script, &cpl_xml_col)==-1)
goto error;
/* add a lump with content-type hdr */
if (add_lump_rpl( msg, CONTENT_TYPE_HDR, CONTENT_TYPE_HDR_LEN,
LUMP_RPL_HDR)==0) {
LM_ERR("cannot build hdr lump\n");
cpl_err = &intern_err;
goto error;
}
if (script.s!=0) {
/* user has a script -> add a body lump */
if ( add_lump_rpl( msg, script.s, script.len, LUMP_RPL_BODY)==0) {
LM_ERR("cannot build body lump\n");
cpl_err = &intern_err;
goto error;
}
/* build_lump_rpl duplicates the added text, so free the original */
shm_free( script.s );
}
return 0;
error:
if (script.s)
shm_free(script.s);
return -1;
}
/*
* Create a response with given code and reason phrase
* Optionally add new headers specified in _hdr
*/
int send_resp(struct sip_msg* m, int code, str* reason,
char* hdr, int hdr_len)
{
/* Add new headers if there are any */
if ((hdr) && (hdr_len)) {
if (add_lump_rpl( m, hdr, hdr_len, LUMP_RPL_HDR)==0) {
LM_ERR("unable to append hdr\n");
return -1;
}
}
return sigb.reply(m, code, reason, NULL);
}
/*
* Create a response with given code and reason phrase
* Optionally add new headers specified in _hdr
*/
int send_resp(struct sip_msg* _m, int _code, char* _reason,
char* _hdr, int _hdr_len)
{
/* Add new headers if there are any */
if ((_hdr) && (_hdr_len)) {
if (add_lump_rpl( _m, _hdr, _hdr_len, LUMP_RPL_HDR)==0) {
LOG(L_ERR,"ERROR:auth:send_resp: unable to append hdr\n");
return -1;
}
}
return sl_reply(_m, (char*)(long)_code, _reason);
}
/*
* Create a response with given code and reason phrase
* Optionally add new headers specified in _hdr
*/
int send_resp(struct sip_msg* _m, int _code, str* _reason,
char* _hdr, int _hdr_len)
{
/* Add new headers if there are any */
if ((_hdr) && (_hdr_len)) {
if (add_lump_rpl( _m, _hdr, _hdr_len, LUMP_RPL_HDR)==0) {
LM_ERR("unable to append hdr\n");
return -1;
}
}
return sigb.reply(_m, _code, _reason, NULL);
}
/*
* Create a response with given code and reason phrase
* Optionally add new headers specified in _hdr
*/
int send_resp(struct sip_msg* m, int code, char* reason,
char* hdr, int hdr_len)
{
/* Add new headers if there are any */
if ((hdr) && (hdr_len)) {
if (add_lump_rpl( m, hdr, hdr_len, LUMP_RPL_HDR)==0) {
LOG(L_ERR,"ERROR:auth_diameter:send_resp: unable to append hdr\n");
return -1;
}
}
return sl_reply(m, (char*)(long)code, reason);
}
static int add_unsupported(struct sip_msg* _m, str* _p) {
char* buf;
buf = (char*) pkg_malloc(UNSUPPORTED_LEN + _p->len + CRLF_LEN);
if (!buf) {
LM_ERR("no pkg memory left\n");
return -1;
}
memcpy(buf, UNSUPPORTED, UNSUPPORTED_LEN);
memcpy(buf + UNSUPPORTED_LEN, _p->s, _p->len);
memcpy(buf + UNSUPPORTED_LEN + _p->len, CRLF, CRLF_LEN);
add_lump_rpl(_m, buf, UNSUPPORTED_LEN + _p->len + CRLF_LEN,
LUMP_RPL_HDR | LUMP_RPL_NODUP);
return 0;
}
static int add_service_route(struct sip_msg* _m, str* _uri) {
char* buf;
buf = (char*) pkg_malloc(SERVICEROUTE_START_LEN + _uri->len + SERVICEROUTE_END_LEN);
if (!buf) {
LM_ERR("no pkg memory left\n");
return -1;
}
memcpy(buf, SERVICEROUTE_START, SERVICEROUTE_START_LEN);
memcpy(buf + SERVICEROUTE_START_LEN, _uri->s, _uri->len);
memcpy(buf + SERVICEROUTE_START_LEN + _uri->len, SERVICEROUTE_END, SERVICEROUTE_END_LEN);
add_lump_rpl(_m, buf, SERVICEROUTE_START_LEN + _uri->len + SERVICEROUTE_END_LEN, LUMP_RPL_HDR | LUMP_RPL_NODUP);
return 0;
}
static int add_path(struct sip_msg* _m, str* _p) {
char* buf;
buf = (char*) pkg_malloc(PATH_LEN + _p->len + CRLF_LEN);
if (!buf) {
LM_ERR("no pkg memory left\n");
return -1;
}
memcpy(buf, PATH, PATH_LEN);
memcpy(buf + PATH_LEN, _p->s, _p->len);
memcpy(buf + PATH_LEN + _p->len, CRLF, CRLF_LEN);
add_lump_rpl(_m, buf, PATH_LEN + _p->len + CRLF_LEN,
LUMP_RPL_HDR | LUMP_RPL_NODUP);
return 0;
}
static void add_etag_to_rpl(struct sip_msg *_m, str *etag)
{
char *tmp;
tmp = (char*)pkg_malloc(32 + etag->len);
if (!tmp) {
LOG(L_ERR, "Can't allocate package memory for SIP-ETag header to the response\n");
return;
}
sprintf(tmp, "SIP-ETag: %.*s\r\n", etag->len, etag->s);
if (!add_lump_rpl(_m, tmp, strlen(tmp), LUMP_RPL_HDR)) {
LOG(L_ERR, "Can't add SIP-ETag header to the response\n");
/* return -1; */
}
pkg_free(tmp);
}
static int add_retry_after(struct sip_msg* _m) {
char* buf, *ra_s;
int ra_len;
ra_s = int2str(cfg_get(registrar, registrar_cfg, retry_after), &ra_len);
buf = (char*) pkg_malloc(RETRY_AFTER_LEN + ra_len + CRLF_LEN);
if (!buf) {
LM_ERR("no pkg memory left\n");
return -1;
}
memcpy(buf, RETRY_AFTER, RETRY_AFTER_LEN);
memcpy(buf + RETRY_AFTER_LEN, ra_s, ra_len);
memcpy(buf + RETRY_AFTER_LEN + ra_len, CRLF, CRLF_LEN);
add_lump_rpl(_m, buf, RETRY_AFTER_LEN + ra_len + CRLF_LEN,
LUMP_RPL_HDR | LUMP_RPL_NODUP);
return 0;
}
static int pl_drop(struct sip_msg * msg, unsigned int low, unsigned int high)
{
str hdr;
int ret;
LM_DBG("(%d, %d)\n", low, high);
if (slb.freply != 0) {
if (low != 0 && high != 0) {
hdr.s = (char *)pkg_malloc(64);
if (hdr.s == 0) {
LM_ERR("Can't allocate memory for Retry-After header\n");
return 0;
}
hdr.len = 0;
if (! hdr.s) {
LM_ERR("no memory for hdr\n");
return 0;
}
if (high == low) {
hdr.len = snprintf(hdr.s, 63, "Retry-After: %d\r\n", low);
} else {
hdr.len = snprintf(hdr.s, 63, "Retry-After: %d\r\n",
low + kam_rand() % (high - low + 1));
}
if (add_lump_rpl(msg, hdr.s, hdr.len, LUMP_RPL_HDR)==0) {
LM_ERR("Can't add header\n");
pkg_free(hdr.s);
return 0;
}
ret = slb.freply(msg, pl_drop_code, &pl_drop_reason);
pkg_free(hdr.s);
} else {
ret = slb.freply(msg, pl_drop_code, &pl_drop_reason);
}
} else {
LM_ERR("Can't send reply\n");
return 0;
}
return ret;
}
static int auth_send_reply(struct sip_msg *msg, int code, char *reason,
char *hdr, int hdr_len)
{
str reason_str;
/* Add new headers if there are any */
if ((hdr!=NULL) && (hdr_len>0)) {
if (add_lump_rpl(msg, hdr, hdr_len, LUMP_RPL_HDR)==0) {
LM_ERR("failed to append hdr to reply\n");
return -1;
}
}
reason_str.s = reason;
reason_str.len = strlen(reason);
return force_stateless_reply ?
slb.sreply(msg, code, &reason_str) :
slb.freply(msg, code, &reason_str);
}
/**
* reply 200 ok with require header
*/
int reply_200(struct sip_msg* msg, str* contact, int expires)
{
str hdr_append;
hdr_append.s = (char *)pkg_malloc( sizeof(char)*(contact->len+70));
if(hdr_append.s == NULL)
{
LM_ERR("no more pkg memory\n");
return -1;
}
hdr_append.len = snprintf(hdr_append.s, contact->len+70,
"Expires: %d" CRLF
"Contact: <%.*s>" CRLF
"Require: eventlist" CRLF,
expires,
contact->len, contact->s
);
if(hdr_append.len<0 || hdr_append.len>=contact->len+70)
{
LM_ERR("unsuccessful snprintf\n");
goto error;
}
if (add_lump_rpl( msg, hdr_append.s, hdr_append.len, LUMP_RPL_HDR)==0 )
{
LM_ERR("unable to add lump_rl\n");
goto error;
}
if(slb.freply(msg, 200, &su_200_rpl) < 0)
{
LM_ERR("while sending reply\n");
goto error;
}
pkg_free(hdr_append.s);
return 0;
error:
pkg_free(hdr_append.s);
return -1;
}
int reply_489(struct sip_msg * msg)
{
str hdr_append;
char buffer[256];
str* ev_list;
hdr_append.s = buffer;
hdr_append.s[0]='\0';
hdr_append.len = sprintf(hdr_append.s, "Allow-Events: ");
if(hdr_append.len < 0)
{
LM_ERR("unsuccessful sprintf\n");
return -1;
}
if(pres_get_ev_list(&ev_list)< 0)
{
LM_ERR("while getting ev_list\n");
return -1;
}
memcpy(hdr_append.s+ hdr_append.len, ev_list->s, ev_list->len);
hdr_append.len+= ev_list->len;
pkg_free(ev_list->s);
pkg_free(ev_list);
memcpy(hdr_append.s+ hdr_append.len, CRLF, CRLF_LEN);
hdr_append.len+= CRLF_LEN;
hdr_append.s[hdr_append.len]= '\0';
if (add_lump_rpl( msg, hdr_append.s, hdr_append.len, LUMP_RPL_HDR)==0 )
{
LM_ERR("unable to add lump_rl\n");
return -1;
}
if (rls_sigb.reply(msg, 489, &pu_489_rpl, 0) == -1)
{
LM_ERR("failed to send reply\n");
return -1;
}
return 0;
}
