/* 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; }