/*
* 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);
}
/*
* 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);
}
/*
* 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;
}
/**
* Send a 422 Session Interval Too Small.
* @param msg - the msg to respond to
* @param str1 - not used
* @param str2 - not used
* @returns
*/
int S_422_session_expires(struct sip_msg* msg, char* str1, char* str2)
{
str hdr = {pkg_malloc(32), 0};
if (!hdr.s) {
LOG(L_ERR, "ERR:"M_NAME":S_422_session_expires(): no memory for hdr\n");
goto error;
}
hdr.len = snprintf(hdr.s, 31, "Min-SE: %d\r\n", scscf_min_se);
if (!cscf_add_header_rpl(msg, &hdr)) {
LOG(L_ERR, "ERR:"M_NAME":S_422_session_expires(): Can't add header\n");
goto error;
}
return sl_reply(msg, (char *)&fp_422, (char *)&fp_se_small);
error:
if (hdr.s) pkg_free(hdr.s);
return CSCF_RETURN_FALSE;
}
static int rl_drop(struct sip_msg * msg, int low, int high)
{
str hdr = {pkg_malloc(64), 0};
int ret;
LOG(L_DBG, "rl_drop(%d, %d sl_reply = %p)\n", low, high, sl_reply);
if (! hdr.s) {
LOG(L_ERR, "rl_drop: no memory for hdr\n");
return 0;
}
hdr.len = snprintf(hdr.s, 63, "Retry-After: %d\r\n",
low + rand() % (high - low + 1));
if (add_lump_rpl(msg, hdr.s, hdr.len, LUMP_RPL_HDR)==0) {
LOG(L_ERR, "Can't add header\n");
return 0;
}
ret = sl_reply(msg, (char *)&fp_503, (char *)&fp_server_busy);
pkg_free(hdr.s);
return ret;
}
/*
* Authorize digest credentials
*/
static inline int authorize(struct sip_msg* _m, str* _realm, char* _table,
hdr_types_t _hftype)
{
char ha1[256];
int res;
struct hdr_field* h;
auth_body_t* cred;
auth_result_t ret;
str domain;
db_res_t* result;
domain = *_realm;
ret = auth_api.pre_auth(_m, &domain, _hftype, &h);
switch(ret) {
case ERROR: return 0;
case NOT_AUTHORIZED: return -1;
case DO_AUTHORIZATION: break;
case AUTHORIZED: return 1;
}
cred = (auth_body_t*)h->parsed;
res = get_ha1(&cred->digest.username, &domain, _table, ha1, &result);
if (res < 0) {
/* Error while accessing the database */
if (sl_reply(_m, (char*)500, MESSAGE_500) == -1) {
LOG(L_ERR, "authorize(): Error while sending 500 reply\n");
}
return 0;
}
if (res > 0) {
/* Username not found in the database */
auth_dbf.free_result(auth_db_handle, result);
return -1;
}
/* Recalculate response, it must be same to authorize successfully */
if (!check_response(&(cred->digest),&_m->first_line.u.request.method,ha1)) {
ret = auth_api.post_auth(_m, h);
switch(ret) {
case ERROR:
auth_dbf.free_result(auth_db_handle, result);
return 1;
case NOT_AUTHORIZED:
auth_dbf.free_result(auth_db_handle, result);
return -1;
case AUTHORIZED:
generate_avps(result);
auth_dbf.free_result(auth_db_handle, result);
return 1;
default:
auth_dbf.free_result(auth_db_handle, result);
return -1;
}
}
auth_dbf.free_result(auth_db_handle, result);
return -1;
}
