/*
* Module initialization function
*/
static int mod_init(void)
{
DBG("auth_gsm - Initializing\n");
if ((rh=rc_read_config(radius_config)) == NULL) {
LOG(L_ERR, "auth_gsm: Error opening radius configuration file \n");
return -1;
}
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {
LOG(L_ERR, "auth_gsm: Error opening radius dictionary file \n");
return -2;
}
sl_reply = find_export("sl_send_reply", 2, 0);
if (!sl_reply)
{
LOG(L_ERR, "auth_gsm:mod_init: This module requires sl module\n");
return -2;
}
pre_auth_func = (pre_auth_f)find_export("pre_auth", 0, 0);
post_auth_func = (post_auth_f)find_export("post_auth", 0, 0);
if (!(pre_auth_func && post_auth_func)) {
LOG(L_ERR, "auth_gsm:mod_init: This module requires auth module\n");
return -3;
}
return 0;
}
static int load_module(void)
{
struct ast_config *cfg;
int res;
const char *tmp;
if ((cfg = ast_config_load(cdr_config))) {
ast_set2_flag(&global_flags, ast_true(ast_variable_retrieve(cfg, "radius", "usegmtime")), RADIUS_FLAG_USEGMTIME);
ast_set2_flag(&global_flags, ast_true(ast_variable_retrieve(cfg, "radius", "loguniqueid")), RADIUS_FLAG_LOGUNIQUEID);
ast_set2_flag(&global_flags, ast_true(ast_variable_retrieve(cfg, "radius", "loguserfield")), RADIUS_FLAG_LOGUSERFIELD);
if ((tmp = ast_variable_retrieve(cfg, "radius", "radiuscfg")))
ast_copy_string(radiuscfg, tmp, sizeof(radiuscfg));
ast_config_destroy(cfg);
} else
return AST_MODULE_LOAD_DECLINE;
/* start logging */
rc_openlog("asterisk");
/* read radiusclient-ng config file */
if (!(rh = rc_read_config(radiuscfg))) {
ast_log(LOG_NOTICE, "Cannot load radiusclient-ng configuration file %s.\n", radiuscfg);
return AST_MODULE_LOAD_DECLINE;
}
/* read radiusclient-ng dictionaries */
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary"))) {
ast_log(LOG_NOTICE, "Cannot load radiusclient-ng dictionary file.\n");
return AST_MODULE_LOAD_DECLINE;
}
res = ast_cdr_register(name, desc, radius_log);
return AST_MODULE_LOAD_SUCCESS;
}
static int mod_init(void)
{
DBG("uri_radius - initializing\n");
memset(attrs, 0, sizeof(attrs));
memset(attrs, 0, sizeof(vals));
attrs[A_SERVICE_TYPE].n = "Service-Type";
attrs[A_USER_NAME].n = "User-Name";
vals[V_CALL_CHECK].n = "Call-Check";
attrs[A_SIP_AVP].n = "SIP-AVP";
if ((rh = rc_read_config(radius_config)) == NULL) {
LOG(L_ERR, "uri_radius: Error opening configuration file \n");
return -1;
}
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {
LOG(L_ERR, "uri_radius: Error opening dictionary file \n");
return -2;
}
INIT_AV(rh, attrs, A_MAX, vals, "uri_radius", -3, -4);
if (service_type != -1)
vals[V_CALL_CHECK].v = service_type;
return 0;
}
/*
Radius implementation for the init_prot callback
For Radius, initialization consists of:
- the url is parsed and a configuration structure is obtained
- the rest field from the configuration structure is, for the radius
module, a string for the path of the radius configuration file
- obtain the connection handle
- initialize the dictionary
For Radius, the aaa_conn is actually the rc_handle resulted by reading
the Radius configuration file.
*/
aaa_conn* rad_init_prot(str* aaa_url) {
rc_handle *rh;
aaa_prot_config cfg;
if (!aaa_url) {
LM_ERR("null aaa url \n");
return NULL;
}
if (aaa_parse_url(aaa_url, &cfg)) {
LM_ERR("aaa parse url error\n");
return NULL;
}
if (!(rh = rc_read_config((char*)(cfg.rest)))) {
LM_ERR("failed to open radius config file: %s\n", (char*)(cfg.rest));
return NULL;
}
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary"))) {
LM_ERR("failed to read radius dictionary\n");
return NULL;
}
return rh;
}
static void radius_global_init(void *pool, void *additional)
{
radius_cfg_st *config = additional;
if (config == NULL)
goto fail;
rh = rc_read_config(config->config);
if (rh == NULL) {
goto fail;
}
if (config->nas_identifier) {
strlcpy(nas_identifier, config->nas_identifier, sizeof(nas_identifier));
} else {
nas_identifier[0] = 0;
}
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {
fprintf(stderr, "error reading the radius dictionary\n");
exit(1);
}
return;
fail:
fprintf(stderr, "radius initialization error\n");
exit(1);
}
static int load_module(void)
{
struct ast_config *cfg;
struct ast_flags config_flags = { 0 };
const char *tmp;
if ((cfg = ast_config_load(cel_config, config_flags))) {
ast_set2_flag(&global_flags, ast_true(ast_variable_retrieve(cfg, "radius", "usegmtime")), RADIUS_FLAG_USEGMTIME);
if ((tmp = ast_variable_retrieve(cfg, "radius", "radiuscfg"))) {
ast_copy_string(radiuscfg, tmp, sizeof(radiuscfg));
}
ast_config_destroy(cfg);
} else {
return AST_MODULE_LOAD_DECLINE;
}
/*
* start logging
*
* NOTE: Yes this causes a slight memory leak if the module is
* unloaded. However, it is better than a crash if cdr_radius
* and cel_radius are both loaded.
*/
tmp = ast_strdup("asterisk");
if (tmp) {
rc_openlog((char *) tmp);
}
/* read radiusclient-ng config file */
if (!(rh = rc_read_config(radiuscfg))) {
ast_log(LOG_NOTICE, "Cannot load radiusclient-ng configuration file %s.\n", radiuscfg);
return AST_MODULE_LOAD_DECLINE;
}
/* read radiusclient-ng dictionaries */
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary"))) {
ast_log(LOG_NOTICE, "Cannot load radiusclient-ng dictionary file.\n");
rc_destroy(rh);
rh = NULL;
return AST_MODULE_LOAD_DECLINE;
}
event_sub = ast_event_subscribe(AST_EVENT_CEL, radius_log, "CEL Radius Logging", NULL, AST_EVENT_IE_END);
if (!event_sub) {
rc_destroy(rh);
rh = NULL;
return AST_MODULE_LOAD_DECLINE;
} else {
return AST_MODULE_LOAD_SUCCESS;
}
}
static int load_module(void)
{
struct ast_config *cfg;
struct ast_flags config_flags = { 0 };
const char *tmp;
if ((cfg = ast_config_load(cdr_config, config_flags)) && cfg != CONFIG_STATUS_FILEINVALID) {
ast_set2_flag(&global_flags, ast_true(ast_variable_retrieve(cfg, "radius", "usegmtime")), RADIUS_FLAG_USEGMTIME);
ast_set2_flag(&global_flags, ast_true(ast_variable_retrieve(cfg, "radius", "loguniqueid")), RADIUS_FLAG_LOGUNIQUEID);
ast_set2_flag(&global_flags, ast_true(ast_variable_retrieve(cfg, "radius", "loguserfield")), RADIUS_FLAG_LOGUSERFIELD);
if ((tmp = ast_variable_retrieve(cfg, "radius", "radiuscfg")))
ast_copy_string(radiuscfg, tmp, sizeof(radiuscfg));
ast_config_destroy(cfg);
} else
return AST_MODULE_LOAD_DECLINE;
/*
* start logging
*
* NOTE: Yes this causes a slight memory leak if the module is
* unloaded. However, it is better than a crash if cdr_radius
* and cel_radius are both loaded.
*/
tmp = ast_strdup("asterisk");
if (tmp) {
rc_openlog((char *) tmp);
}
/* read radiusclient-ng config file */
if (!(rh = rc_read_config(radiuscfg))) {
ast_log(LOG_NOTICE, "Cannot load radiusclient-ng configuration file %s.\n", radiuscfg);
return AST_MODULE_LOAD_DECLINE;
}
/* read radiusclient-ng dictionaries */
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary"))) {
ast_log(LOG_NOTICE, "Cannot load radiusclient-ng dictionary file.\n");
rc_destroy(rh);
rh = NULL;
return AST_MODULE_LOAD_DECLINE;
}
if (ast_cdr_register(name, desc, radius_log)) {
rc_destroy(rh);
rh = NULL;
return AST_MODULE_LOAD_DECLINE;
} else {
return AST_MODULE_LOAD_SUCCESS;
}
}
switch_status_t mod_xml_radius_new_handle(rc_handle **new_handle, switch_xml_t xml) {
switch_xml_t server, param;
*new_handle = rc_new();
if ( *new_handle == NULL ) {
goto err;
}
*new_handle = rc_config_init(*new_handle);
if ( *new_handle == NULL ) {
goto err;
}
if (rc_add_config(*new_handle, "auth_order", "radius", "mod_radius_cdr.c", 0) != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error adding auth_order\n");
goto err;
}
if ((server = switch_xml_child(xml, "connection")) == NULL ) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not find 'connection' section in config file.\n");
goto err;
}
for (param = switch_xml_child(server, "param"); param; param = param->next) {
char *var = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value");
if ( GLOBAL_DEBUG ) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Attempting to add param '%s' with value '%s' \n", var, val);
}
if (strncmp(var, "dictionary", 10) == 0) {
rc_read_dictionary(*new_handle, val);
} else if (rc_add_config(*new_handle, var, val, "mod_xml_radius", 0) != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error adding param '%s' with value '%s' \n", var, val);
goto err;
}
}
return SWITCH_STATUS_SUCCESS;
err:
if ( *new_handle ) {
rc_destroy( *new_handle );
*new_handle = NULL;
}
return SWITCH_STATUS_GENERR;
}
int init_acc_rad(acc_extra_t *leg_info, char *rad_cfg, int srv_type)
{
int n;
memset(rd_attrs, 0, sizeof(rd_attrs));
memset(rd_vals, 0, sizeof(rd_vals));
rd_attrs[RA_ACCT_STATUS_TYPE].n = "Acct-Status-Type";
rd_attrs[RA_SERVICE_TYPE].n = "Service-Type";
rd_attrs[RA_SIP_RESPONSE_CODE].n = "Sip-Response-Code";
rd_attrs[RA_SIP_METHOD].n = "Sip-Method";
rd_attrs[RA_TIME_STAMP].n = "Event-Timestamp";
n = RA_STATIC_MAX;
/* caution: keep these aligned to core acc output */
rd_attrs[n++].n = "Sip-From-Tag";
rd_attrs[n++].n = "Sip-To-Tag";
rd_attrs[n++].n = "Acct-Session-Id";
rd_vals[RV_STATUS_START].n = "Start";
rd_vals[RV_STATUS_STOP].n = "Stop";
rd_vals[RV_STATUS_ALIVE].n = "Alive";
rd_vals[RV_STATUS_FAILED].n = "Failed";
rd_vals[RV_SIP_SESSION].n = "Sip-Session";
/* add and count the extras as attributes */
n += extra2attrs( rad_extra, rd_attrs, n);
/* add and count the legs as attributes */
n += extra2attrs( leg_info, rd_attrs, n);
/* read config */
if ((rh = rc_read_config(rad_cfg)) == NULL) {
LM_ERR("failed to open radius config file: %s\n", rad_cfg );
return -1;
}
/* read dictionary */
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary"))!=0) {
LM_ERR("failed to read radius dictionary\n");
return -1;
}
INIT_AV(rh, rd_attrs, n, rd_vals, RV_STATIC_MAX, "acc", -1, -1);
if (srv_type != -1)
rd_vals[RV_SIP_SESSION].v = srv_type;
return 0;
}
int init_radius_handle(void) {
int i;
DICT_ATTR *da;
char name[256];
map_list *mp;
if (!config_file) {
LM_ERR("radius configuration file not set\n");
return -1;
}
if ( syslog_name!=NULL && syslog_name[0]!=0 )
rc_openlog(syslog_name);
if (!(rh = rc_read_config(config_file))) {
LM_ERR("failed to open radius config file: %s\n", config_file);
return -1;
}
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary"))) {
LM_ERR("failed to read radius dictionary\n");
return -1;
}
attr = rc_dict_findattr(rh, "SIP-AVP");
/* initialize values for the attributes in sets */
for (i = 0; i < set_size; i++) {
mp = sets[i]->parsed;
while (mp) {
sprintf(name,"%.*s", mp->name.len, mp->name.s);
da = rc_dict_findattr(rh, name);
if (!da) {
LM_ERR("attribute not found %s\n", name);
return -1;
} else
mp->value = da->value;
mp = mp->next;
}
}
return 0;
}
static int mod_init(void)
{
DICT_VENDOR *vend;
memset(attrs, 0, sizeof(attrs));
memset(vals, 0, sizeof(vals));
attrs[A_USER_NAME].n = "User-Name";
attrs[A_SER_SERVICE_TYPE].n = "SER-Service-Type";
attrs[A_SER_ATTR].n = "SER-Attr";
attrs[A_SER_DID].n = "SER-DID";
attrs[A_SER_URI_SCHEME].n = "SER-Uri-Scheme";
vals[V_GET_URI_ATTRS].n = "Get-URI-Attrs";
vals[V_GET_USER_ATTRS].n = "Get-User-Attrs";
/* open log */
rc_openlog("ser");
/* read config */
if ((rh = rc_read_config(radius_config)) == NULL) {
LOG(L_ERR, "avp_radius: Error opening radius config file: %s\n",
radius_config);
return -1;
}
/* read dictionary */
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {
LOG(L_ERR, "avp_radius: Error reading radius dictionary\n");
return -1;
}
vend = rc_dict_findvend(rh, "iptelorg");
if (vend == NULL) {
ERR("RADIUS dictionary is missing required vendor 'iptelorg'\n");
return -1;
}
INIT_AV(rh, attrs, vals, "avp", -1, -1);
return 0;
}
static int mod_init(void)
{
DBG("avp_radius - Initializing\n");
memset(attrs, 0, sizeof(attrs));
memset(attrs, 0, sizeof(vals));
attrs[A_SERVICE_TYPE].n = "Service-Type";
attrs[A_USER_NAME].n = "User-Name";
attrs[A_SIP_AVP].n = "SIP-AVP";
vals[V_SIP_CALLER_AVPS].n = "SIP-Caller-AVPs";
vals[V_SIP_CALLEE_AVPS].n = "SIP-Callee-AVPs";
/* read config */
if ((rh = rc_read_config(radius_config)) == NULL) {
LOG(L_ERR, "ERROR:avp_radius:init: Error opening radius "
"config file: %s\n", radius_config);
return -1;
}
/* read dictionary */
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {
LOG(L_ERR, "ERROR:avp_radius:init: Error reading radius dictionary\n");
return -1;
}
INIT_AV(rh, attrs, A_MAX, vals, "avp", -1, -1);
if (caller_service_type != -1) {
vals[V_SIP_CALLER_AVPS].v = caller_service_type;
}
if (callee_service_type != -1) {
vals[V_SIP_CALLEE_AVPS].v = callee_service_type;
}
return 0;
}
int pmip_mn_to_hnp_cache_init(void)
{
dbg ("\n");
memset(g_mn_hn_map, 0, sizeof(mnid_hnp_t) * MAX_MOBILES);
rc_openlog("pmip_radius_client");
if ((g_rh = rc_read_config(conf.RadiusClientConfigFile)) == NULL) {
dbg ("ERROR INIT CLIENT RADIUS\n");
return ERROR_RC;
} else {
dbg ("RADIUS client radius read config file OK\n");
}
if (rc_read_dictionary(g_rh, rc_conf_str(g_rh, "dictionary")) != 0) {
dbg ("ERROR INIT CLIENT RADIUS DICTIONNARY\n");
return ERROR_RC;
} else {
dbg ("client radius read dictionnary file OK\n");
}
g_default_realm = rc_conf_str(g_rh, "default_realm");
return 0;
}
static int mod_init(void)
{
LM_INFO("initializing...\n");
memset(attrs, 0, sizeof(attrs));
memset(vals, 0, sizeof(vals));
attrs[A_SERVICE_TYPE].n = "Service-Type";
attrs[A_USER_NAME].n = "User-Name";
attrs[A_SIP_AVP].n = "SIP-AVP";
vals[V_SIP_CALLER_AVPS].n = "SIP-Caller-AVPs";
vals[V_SIP_CALLEE_AVPS].n = "SIP-Callee-AVPs";
/* read config */
if ((rh = rc_read_config(radius_config)) == NULL) {
LM_ERR("failed to open radius config file: %s\n", radius_config);
return -1;
}
/* read dictionary */
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {
LM_ERR("failed to read radius dictionary\n");
return -1;
}
INIT_AV(rh, attrs, A_MAX, vals, V_MAX, "avp", -1, -1);
if (caller_service_type != -1) {
vals[V_SIP_CALLER_AVPS].v = caller_service_type;
}
if (callee_service_type != -1) {
vals[V_SIP_CALLEE_AVPS].v = callee_service_type;
}
return 0;
}
int rc_read_dictionary (char *filename)
{
FILE *dictfd;
char dummystr[AUTH_ID_LEN];
char namestr[AUTH_ID_LEN];
char valstr[AUTH_ID_LEN];
char attrstr[AUTH_ID_LEN];
char typestr[AUTH_ID_LEN];
char vendorstr[AUTH_ID_LEN];
int line_no;
DICT_ATTR *attr;
DICT_VALUE *dval;
VENDOR_DICT *vdict;
char buffer[256];
int value;
int type;
int n;
int retcode;
if ((dictfd = fopen (filename, "r")) == (FILE *) NULL)
{
errorlog( "rc_read_dictionary: couldn't open dictionary %s: %s",
filename, strerror(errno));
return (-1);
}
line_no = 0;
retcode = 0;
while (fgets (buffer, sizeof (buffer), dictfd) != (char *) NULL)
{
line_no++;
/* Skip empty space */
if (*buffer == '#' || *buffer == '\0' || *buffer == '\n')
{
continue;
}
if (strncmp (buffer, "VENDOR", 6) == 0) {
/* Read the VENDOR line */
if (sscanf(buffer, "%s%s%d", dummystr, namestr, &value) != 3) {
errorlog("rc_read_dictionary: invalid vendor on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
/* Validate entry */
if (strlen (namestr) > NAME_LENGTH) {
errorlog("rc_read_dictionary: invalid name length on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
/* Create new vendor entry */
vdict = (VENDOR_DICT *) malloc (sizeof (VENDOR_DICT));
if (!vdict) {
novm("rc_read_dictionary");
retcode = -1;
break;
}
strcpy(vdict->vendorname, namestr);
vdict->vendorcode = value;
vdict->attributes = NULL;
vdict->next = vendor_dictionaries;
vendor_dictionaries = vdict;
}
else if (strncmp (buffer, "ATTRIBUTE", 9) == 0)
{
/* Read the ATTRIBUTE line. It is one of:
* ATTRIBUTE attr_name attr_val type OR
* ATTRIBUTE attr_name attr_val type vendor */
vendorstr[0] = 0;
n = sscanf(buffer, "%s%s%s%s%s", dummystr, namestr, valstr, typestr, vendorstr);
if (n != 4 && n != 5)
{
errorlog("rc_read_dictionary: invalid attribute on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
/*
* Validate all entries
*/
if (strlen (namestr) > NAME_LENGTH)
{
errorlog("rc_read_dictionary: invalid name length on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
if (strlen (vendorstr) > NAME_LENGTH)
{
errorlog("rc_read_dictionary: invalid name length on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
if (!isdigit (*valstr))
{
errorlog("rc_read_dictionary: invalid value on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
value = atoi (valstr);
if (strcmp (typestr, "string") == 0)
{
type = PW_TYPE_STRING;
}
else if (strcmp (typestr, "integer") == 0)
{
type = PW_TYPE_INTEGER;
}
else if (strcmp (typestr, "ipaddr") == 0)
{
type = PW_TYPE_IPADDR;
}
else if (strcmp (typestr, "date") == 0)
{
type = PW_TYPE_DATE;
}
else
{
errorlog("rc_read_dictionary: invalid type on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
/* Search for vendor if supplied */
if (*vendorstr) {
vdict = rc_dict_findvendor(vendorstr);
if (!vdict) {
errorlog("rc_read_dictionary: unknown vendor on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
} else {
vdict = NULL;
}
/* Create a new attribute for the list */
if ((attr =
(DICT_ATTR *) malloc (sizeof (DICT_ATTR)))
== (DICT_ATTR *) NULL)
{
novm("rc_read_dictionary");
retcode = -1;
break;
}
strcpy (attr->name, namestr);
if (vdict) {
attr->vendorcode = vdict->vendorcode;
} else {
attr->vendorcode = VENDOR_NONE;
}
attr->value = value;
attr->type = type;
/* Insert it into the list */
if (vdict) {
attr->next = vdict->attributes;
vdict->attributes = attr;
} else {
attr->next = dictionary_attributes;
dictionary_attributes = attr;
}
}
else if (strncmp (buffer, "VALUE", 5) == 0)
{
/* Read the VALUE line */
if (sscanf (buffer, "%s%s%s%s", dummystr, attrstr,
namestr, valstr) != 4)
{
errorlog("rc_read_dictionary: invalid value entry on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
/*
* Validate all entries
*/
if (strlen (attrstr) > NAME_LENGTH)
{
errorlog("rc_read_dictionary: invalid attribute length on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
if (strlen (namestr) > NAME_LENGTH)
{
errorlog("rc_read_dictionary: invalid name length on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
if (!isdigit (*valstr))
{
errorlog("rc_read_dictionary: invalid value on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
value = atoi (valstr);
/* Create a new VALUE entry for the list */
if ((dval =
(DICT_VALUE *) malloc (sizeof (DICT_VALUE)))
== (DICT_VALUE *) NULL)
{
novm("rc_read_dictionary");
retcode = -1;
break;
}
strcpy (dval->attrname, attrstr);
strcpy (dval->name, namestr);
dval->value = value;
/* Insert it into the list */
dval->next = dictionary_values;
dictionary_values = dval;
}
else if (strncmp (buffer, "INCLUDE", 7) == 0)
{
/* Read the INCLUDE line */
if (sscanf (buffer, "%s%s", dummystr, namestr) != 2)
{
errorlog("rc_read_dictionary: invalid include entry on line %d of dictionary %s",
line_no, filename);
retcode = -1;
break;
}
if (rc_read_dictionary(namestr) == -1)
{
retcode = -1;
break;
}
}
}
fclose (dictfd);
return retcode;
}
/** Read the global config file
*
* This function will load the provided configuration file, and
* any other files such as the dictionary.
*
* Note: To preserve compatibility with libraries of the same API
* which don't load the dictionary care is taken not to reload the
* same filename twice even if instructed to.
*
* @param filename a name of a file.
* @return new rc_handle on success, NULL when failure.
*/
rc_handle *rc_read_config(char const *filename)
{
FILE *configfd;
char buffer[512], *p;
OPTION *option;
int line;
size_t pos;
rc_handle *rh;
srandom((unsigned int)(time(NULL)+getpid()));
rh = rc_new();
if (rh == NULL)
return NULL;
rh->config_options = malloc(sizeof(config_options_default));
if (rh->config_options == NULL) {
rc_log(LOG_CRIT, "rc_read_config: out of memory");
rc_destroy(rh);
return NULL;
}
memcpy(rh->config_options, &config_options_default, sizeof(config_options_default));
if ((configfd = fopen(filename,"r")) == NULL)
{
rc_log(LOG_ERR,"rc_read_config: can't open %s: %s", filename, strerror(errno));
rc_destroy(rh);
return NULL;
}
line = 0;
while ((fgets(buffer, sizeof(buffer), configfd) != NULL))
{
line++;
p = buffer;
if ((*p == '\n') || (*p == '#') || (*p == '\0'))
continue;
p[strlen(p)-1] = '\0';
if ((pos = strcspn(p, "\t ")) == 0) {
rc_log(LOG_ERR, "%s: line %d: bogus format: %s", filename, line, p);
fclose(configfd);
rc_destroy(rh);
return NULL;
}
p[pos] = '\0';
if ((option = find_option(rh, p, OT_ANY)) == NULL) {
rc_log(LOG_ERR, "%s: line %d: unrecognized keyword: %s", filename, line, p);
fclose(configfd);
rc_destroy(rh);
return NULL;
}
if (option->status != ST_UNDEF) {
rc_log(LOG_ERR, "%s: line %d: duplicate option line: %s", filename, line, p);
fclose(configfd);
rc_destroy(rh);
return NULL;
}
p += pos+1;
while (isspace(*p))
p++;
pos = strlen(p) - 1;
while(pos != 0 && isspace(p[pos]))
pos--;
p[pos + 1] = '\0';
switch (option->type) {
case OT_STR:
if (set_option_str(filename, line, option, p) < 0) {
fclose(configfd);
rc_destroy(rh);
return NULL;
}
break;
case OT_INT:
if (set_option_int(filename, line, option, p) < 0) {
fclose(configfd);
rc_destroy(rh);
return NULL;
}
break;
case OT_SRV:
if (set_option_srv(filename, line, option, p) < 0) {
fclose(configfd);
rc_destroy(rh);
return NULL;
}
break;
case OT_AUO:
if (set_option_auo(filename, line, option, p) < 0) {
fclose(configfd);
rc_destroy(rh);
return NULL;
}
break;
default:
rc_log(LOG_CRIT, "rc_read_config: impossible case branch!");
abort();
}
}
fclose(configfd);
if (rc_test_config(rh, filename) == -1) {
rc_destroy(rh);
return NULL;
}
{
int clientdebug = rc_conf_int_2(rh, "clientdebug", FALSE);
if(clientdebug > 0) {
radcli_debug = clientdebug;
}
}
p = rc_conf_str(rh, "dictionary");
if (p != NULL) {
if (rc_read_dictionary(rh, p) != 0) {
rc_log(LOG_CRIT, "could not load dictionary");
rc_destroy(rh);
return NULL;
}
} else {
rc_log(LOG_INFO, "rc_read_config: no dictionary was specified");
}
return rh;
}
static int load_module(void)
{
struct ast_config *cfg;
struct ast_flags config_flags = { 0 };
const char *tmp;
if ((cfg = ast_config_load(cel_config, config_flags))) {
ast_set2_flag(&global_flags, ast_true(ast_variable_retrieve(cfg, "radius", "usegmtime")), RADIUS_FLAG_USEGMTIME);
if ((tmp = ast_variable_retrieve(cfg, "radius", "radiuscfg"))) {
ast_copy_string(radiuscfg, tmp, sizeof(radiuscfg));
}
ast_config_destroy(cfg);
} else {
return AST_MODULE_LOAD_DECLINE;
}
/* create dir /var/lib/cdr if it does not exist. add by liucl */
if (access(cdr_directory,F_OK) == -1){
ast_log(LOG_DEBUG,"cdr_directory %s is not exist, I will create it.\n",cdr_directory);
if(ast_mkdir(cdr_directory, 0755) == -1) {
ast_log(LOG_ERROR,"Failed to create %s\n", cdr_directory);
}else{
ast_log(LOG_DEBUG,"Create directory %s is OK\n",cdr_directory);
}
}
/* liucl add end*/
/*
* start logging
*
* NOTE: Yes this causes a slight memory leak if the module is
* unloaded. However, it is better than a crash if cdr_radius
* and cel_radius are both loaded.
*/
tmp = ast_strdup("asterisk");
if (tmp) {
rc_openlog((char *) tmp);
}
/* read radiusclient-ng config file */
if (!(rh = rc_read_config(radiuscfg))) {
ast_log(LOG_NOTICE, "Cannot load radiusclient-ng configuration file %s.\n", radiuscfg);
return AST_MODULE_LOAD_DECLINE;
}
/* read radiusclient-ng dictionaries */
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary"))) {
ast_log(LOG_NOTICE, "Cannot load radiusclient-ng dictionary file.\n");
rc_destroy(rh);
rh = NULL;
return AST_MODULE_LOAD_DECLINE;
}
if (ast_cel_backend_register(RADIUS_BACKEND_NAME, radius_log)) {
rc_destroy(rh);
rh = NULL;
return AST_MODULE_LOAD_DECLINE;
} else {
/*
* * Create a independent thread to monitoring /var/lib/cdr.
* * If there is file in the directory, then send it to radius.
* * add by liucl
* */
start_monitor();
return AST_MODULE_LOAD_SUCCESS;
}
}
int main (int argc, char **argv)
{
int result = ERROR_RC;
int c,i;
char *p, msg[4096];
SERVER *srv;
char *path_radiusclient_conf = RC_CONFIG_FILE;
rc_handle *rh;
extern int optind;
pname = (pname = strrchr(argv[0],'/'))?pname+1:argv[0];
rc_openlog(pname);
while ((c = getopt(argc,argv,"hVf:")) > 0)
{
switch(c) {
case 'f':
path_radiusclient_conf = optarg;
break;
case 'V':
version();
break;
case 'h':
usage();
break;
default:
exit(ERROR_RC);
break;
}
}
argc -= optind;
argv += optind;
if ((rh = rc_read_config(path_radiusclient_conf)) == NULL)
exit(ERROR_RC);
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0)
exit (ERROR_RC);
if (argc > 0) {
for (i = 0; i < argc; i++) {
if ((p = strchr(argv[i], ':')) == NULL) {
result = rc_check(rh, argv[i],rc_getport(AUTH), msg);
} else if (!strcmp(p+1, "auth")) {
*p = '\0';
result = rc_check(rh, argv[i],rc_getport(AUTH), msg);
} else if (!strcmp(p+1, "acct")) {
*p = '\0';
result = rc_check(rh, argv[i],rc_getport(ACCT), msg);
} else {
*p = '\0';
result = rc_check(rh, argv[i], atoi(p+1), msg);
}
if (result == OK_RC)
fputs(msg, stdout);
else
printf(SC_STATUS_FAILED);
}
} else {
srv = rc_conf_srv(rh, "authserver");
for(i=0; i<srv->max ; i++)
{
result = rc_check(rh, srv->name[i], srv->port[i], msg);
fputs(msg, stdout);
}
srv = rc_conf_srv(rh, "acctserver");
for(i=0; i<srv->max ; i++)
{
result = rc_check(rh, srv->name[i], srv->port[i], msg);
fputs(msg, stdout);
}
}
}
int main(int argc, char **argv)
{
int i, nas_port, ch, acct, server, ecount, firstline, theend;
void *rh;
size_t len;
VALUE_PAIR *send;
char *rc_conf, *cp;
char lbuf[4096];
rc_conf = "";
nas_port = 5060;
acct = 0;
server = 0;
while ((ch = getopt(argc, argv, "af:p:s")) != -1) {
switch (ch) {
case 'f':
rc_conf = optarg;
break;
case 'p':
nas_port = atoi(optarg);
break;
case 'a':
acct = 1;
break;
case 's':
server = 1;
break;
}
}
argc -= optind;
argv += optind;
if ((argc == 0 && server == 0) || (argc != 0 && server != 0))
exit(1);
if ((rh = rc_read_config(rc_conf)) == NULL) {
fprintf(stderr, "tls-restart: error opening radius configuration file\n");
exit(1);
}
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {
fprintf(stderr, "tls-restart: error reading radius dictionary\n");
exit(2);
}
if (server == 0) {
send = NULL;
for (i = 0; i < argc; i++) {
if (rc_avpair_parse(rh, argv[i], &send) < 0) {
fprintf(stderr, "%s: can't parse AV pair\n",
argv[i]);
exit(3);
}
}
exit(process(rh, send, acct, nas_port));
}
while (1 == 1) {
send = NULL;
ecount = 0;
firstline = 1;
acct = 0;
do {
len = 0;
cp = rc_fgetln(stdin, &len);
theend = 1;
if (cp != NULL && len > 0) {
if (firstline != 0) {
if (len >= 4
&& memcmp(cp, "ACCT", 4) == 0)
acct = 1;
firstline = 0;
theend = 0;
continue;
}
for (i = 0; i < len; i++) {
if (!isspace(cp[i])) {
theend = 0;
break;
}
}
if (theend == 0) {
memcpy(lbuf, cp, len);
lbuf[len] = '\0';
if (rc_avpair_parse(rh, lbuf, &send) < 0) {
fprintf(stderr,
"%s: can't parse AV pair\n",
lbuf);
ecount++;
}
}
}
} while (theend == 0);
if (send != NULL && ecount == 0)
printf("%d\n\n", process(rh, send, acct, nas_port));
else
printf("%d\n\n", -1);
fflush(stdout);
if (send != NULL)
rc_avpair_free(send);
if (cp == NULL || len == 0)
break;
}
exit(0);
}
static int mod_init(void)
{
int n;
LM_INFO("initializing...\n");
/* read config */
if ((rh = rc_read_config(radius_config)) == NULL) {
LM_ERR("failed to open radius config file: %s\n", radius_config);
return -1;
}
/* read dictionary */
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {
LM_ERR("failed to read radius dictionary\n");
return -1;
}
/* init the extra engine */
init_extra_engine();
/* parse extra attributes (if any) */
if (caller_extra_str &&
(caller_extra=parse_extra_str(caller_extra_str)) == 0 ) {
LM_ERR("failed to parse caller_extra parameter\n");
return -1;
}
if (callee_extra_str &&
(callee_extra=parse_extra_str(callee_extra_str)) == 0 ) {
LM_ERR("failed to parse callee_extra parameter\n");
return -1;
}
if (group_extra_str &&
(group_extra=parse_extra_str(group_extra_str)) == 0 ) {
LM_ERR("failed to parse group_extra parameter\n");
return -1;
}
if (uri_extra_str &&
(uri_extra=parse_extra_str(uri_extra_str)) == 0 ) {
LM_ERR("failed to parse uri_extra parameter\n");
return -1;
}
SET_STATIC(caller_attrs);
n += extra2attrs(caller_extra, caller_attrs, n);
memset(caller_vals, 0, sizeof(caller_vals));
caller_vals[RV_SIP_CALLER_AVPS].n = "SIP-Caller-AVPs";
INIT_AV(rh, caller_attrs, n, caller_vals, RV_STATIC_MAX, "misc_radius",
-1, -1);
if (caller_service_type != -1) {
caller_vals[RV_SIP_CALLER_AVPS].v = caller_service_type;
}
SET_STATIC(callee_attrs);
n += extra2attrs(callee_extra, callee_attrs, n);
memset(callee_vals, 0, sizeof(callee_vals));
callee_vals[EV_SIP_CALLEE_AVPS].n = "SIP-Callee-AVPs";
INIT_AV(rh, callee_attrs, n, callee_vals, EV_STATIC_MAX, "misc_radius",
-1, -1);
if (callee_service_type != -1) {
callee_vals[EV_SIP_CALLEE_AVPS].v = callee_service_type;
}
SET_STATIC(group_attrs);
n += extra2attrs(group_extra, group_attrs, n);
memset(group_vals, 0, sizeof(group_vals));
group_vals[GV_GROUP_CHECK].n = "Group-Check";
INIT_AV(rh, group_attrs, n, group_vals, RV_STATIC_MAX, "misc_radius",
-1, -1);
if (group_service_type != -1) {
group_vals[GV_GROUP_CHECK].v = group_service_type;
}
SET_STATIC(uri_attrs);
n += extra2attrs(uri_extra, uri_attrs, n);
memset(uri_vals, 0, sizeof(uri_vals));
uri_vals[UV_CALL_CHECK].n = "Call-Check";
INIT_AV(rh, uri_attrs, n, uri_vals, UV_STATIC_MAX, "misc_radius",
-1, -1);
if (uri_service_type != -1) {
uri_vals[UV_CALL_CHECK].v = uri_service_type;
}
return 0;
}
static rc_handle *my_radius_init(void)
{
int i = 0;
rc_handle *rad_config;
rad_config = rc_new();
if (rad_config == NULL) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "[mod_radius_cdr] Error initializing rc_handle!\n");
return NULL;
}
rad_config = rc_config_init(rad_config);
if (rad_config == NULL) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "error initializing radius config!\n");
rc_destroy(rad_config);
return NULL;
}
/* Some hardcoded ( for now ) defaults needed to initialize radius */
if (rc_add_config(rad_config, "auth_order", "radius", "mod_radius_cdr.c", 0) != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "setting auth_order = radius failed\n");
rc_destroy(rad_config);
return NULL;
}
if (rc_add_config(rad_config, "seqfile", my_seqfile, "mod_radius_cdr.c", 0) != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "setting seqfile = %s failed\n", my_seqfile);
rc_destroy(rad_config);
return NULL;
}
/* Add the module configs to initialize rad_config */
for (i = 0; i < SERVER_MAX && my_servers[i][0] != '\0'; i++) {
if (rc_add_config(rad_config, "acctserver", my_servers[i], cf, 0) != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "setting acctserver = %s failed\n", my_servers[i]);
rc_destroy(rad_config);
return NULL;
}
}
if (rc_add_config(rad_config, "dictionary", my_dictionary, cf, 0) != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed setting dictionary = %s failed\n", my_dictionary);
rc_destroy(rad_config);
return NULL;
}
if (rc_add_config(rad_config, "radius_deadtime", my_deadtime, cf, 0) != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "setting radius_deadtime = %s failed\n", my_deadtime);
rc_destroy(rad_config);
return NULL;
}
if (rc_add_config(rad_config, "radius_timeout", my_timeout, cf, 0) != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "setting radius_timeout = %s failed\n", my_timeout);
rc_destroy(rad_config);
return NULL;
}
if (rc_add_config(rad_config, "radius_retries", my_retries, cf, 0) != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "setting radius_retries = %s failed\n", my_retries);
rc_destroy(rad_config);
return NULL;
}
/* Read the dictionary file(s) */
if (rc_read_dictionary(rad_config, rc_conf_str(rad_config, "dictionary")) != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "reading dictionary file(s): %s\n", my_dictionary);
rc_destroy(rad_config);
return NULL;
}
return rad_config;
}
/*
* Module initialization function
*/
static int mod_init(void)
{
DICT_VENDOR *vend;
bind_auth_s_t bind_auth;
int n;
if ((rh = rc_read_config(radius_config)) == NULL) {
LM_ERR("failed to open configuration file \n");
return -1;
}
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {
LM_ERR("failed to open dictionary file \n");
return -2;
}
bind_auth = (bind_auth_s_t)find_export("bind_auth_s", 0, 0);
if (!bind_auth) {
LM_ERR("unable to find bind_auth function. Check if you load the auth module.\n");
return -1;
}
if (bind_auth(&auth_api) < 0) {
LM_ERR("cannot bind to auth module\n");
return -4;
}
/* init the extra engine */
init_extra_engine();
/* parse extra attributes (if any) */
if (auth_extra_str &&
(auth_extra=parse_extra_str(auth_extra_str)) == 0 ) {
LM_ERR("failed to parse auth_extra parameter\n");
return -1;
}
memset(attrs, 0, sizeof(attrs));
attrs[A_SERVICE_TYPE].n = "Service-Type";
attrs[A_SIP_URI_USER].n = "Sip-URI-User";
attrs[A_DIGEST_RESPONSE].n = "Digest-Response";
attrs[A_DIGEST_ALGORITHM].n = "Digest-Algorithm";
attrs[A_DIGEST_BODY_DIGEST].n = "Digest-Body-Digest";
attrs[A_DIGEST_CNONCE].n = "Digest-CNonce";
attrs[A_DIGEST_NONCE_COUNT].n = "Digest-Nonce-Count";
attrs[A_DIGEST_QOP].n = "Digest-QOP";
attrs[A_DIGEST_METHOD].n = "Digest-Method";
attrs[A_DIGEST_URI].n = "Digest-URI";
attrs[A_DIGEST_NONCE].n = "Digest-Nonce";
attrs[A_DIGEST_REALM].n = "Digest-Realm";
attrs[A_DIGEST_USER_NAME].n = "Digest-User-Name";
attrs[A_USER_NAME].n = "User-Name";
attrs[A_SIP_AVP].n = "SIP-AVP";
vend = rc_dict_findvend(rh, "Cisco");
if (vend == NULL) {
LM_DBG("no `Cisco' vendor in Radius dictionary\n");
} else {
attrs[A_CISCO_AVPAIR].n = "Cisco-AVPair";
}
n = A_MAX;
n += extra2attrs(auth_extra, attrs, n);
memset(vals, 0, sizeof(vals));
vals[V_SIP_SESSION].n = "Sip-Session";
INIT_AV(rh, attrs, n, vals, V_MAX, "auth_radius", -5, -6);
if (service_type != -1) {
vals[V_SIP_SESSION].v = service_type;
}
return 0;
}
static int mod_init(void)
{
DICT_VENDOR *vend;
load_tm_f load_tm;
/* import the TM auto-loading function */
if ( !(load_tm=(load_tm_f)find_export("load_tm", NO_SCRIPT, 0))) {
LOG(L_ERR, "ERROR:acc:mod_init: can't import load_tm\n");
return -1;
}
/* let the auto-loading function load all TM stuff */
if (load_tm( &tmb )==-1) return -1;
if (verify_fmt(log_fmt)==-1) return -1;
/* register callbacks*/
/* listen for all incoming requests */
if (tmb.register_tmcb( 0, 0, TMCB_REQUEST_IN, on_req, 0, 0) <= 0) {
LOG(L_ERR,"ERROR:acc:mod_init: cannot register TMCB_REQUEST_IN "
"callback\n");
return -1;
}
memset(attrs, 0, sizeof(attrs));
memset(vals, 0, sizeof(vals));
attrs[A_USER_NAME].n = "User-Name";
attrs[A_SERVICE_TYPE].n = "Service-Type";
attrs[A_CALLED_STATION_ID].n = "Called-Station-Id";
attrs[A_CALLING_STATION_ID].n = "Calling-Station-Id";
attrs[A_ACCT_STATUS_TYPE].n = "Acct-Status-Type";
attrs[A_ACCT_SESSION_ID].n = "Acct-Session-Id";
attrs[A_SIP_METHOD].n = "Sip-Method";
attrs[A_SIP_RESPONSE_CODE].n = "Sip-Response-Code";
attrs[A_SIP_CSEQ].n = "Sip-CSeq";
attrs[A_SIP_TO_TAG].n = "Sip-To-Tag";
attrs[A_SIP_FROM_TAG].n = "Sip-From-Tag";
attrs[A_SIP_TRANSLATED_REQUEST_ID].n = "Sip-Translated-Request-Id";
attrs[A_SIP_SOURCE_IP_ADDRESS].n = "Sip-Source-IP-Address";
attrs[A_SIP_SOURCE_PORT].n = "Sip-Source-Port";
attrs[A_SER_ATTR].n = "SER-Attr";
attrs[A_SER_FROM].n = "SER-From";
attrs[A_SER_FLAGS].n = "SER-Flags";
attrs[A_SER_ORIGINAL_REQUEST_ID].n = "SER-Original-Request-Id";
attrs[A_SER_TO].n = "SER-To";
attrs[A_SER_DIGEST_USERNAME].n = "SER-Digest-Username";
attrs[A_SER_DIGEST_REALM].n = "SER-Digest-Realm";
attrs[A_SER_REQUEST_TIMESTAMP].n = "SER-Request-Timestamp";
attrs[A_SER_TO_DID].n = "SER-To-DID";
attrs[A_SER_FROM_UID].n = "SER-From-UID";
attrs[A_SER_FROM_DID].n = "SER-From-DID";
attrs[A_SER_TO_UID].n = "SER-To-UID";
attrs[A_SER_RESPONSE_TIMESTAMP].n = "SER-Response-Timestamp";
attrs[A_SER_SERVER_ID].n = "SER-Server-ID";
vals[V_START].n = "Start";
vals[V_STOP].n = "Stop";
vals[V_INTERIM_UPDATE].n = "Interim-Update";
vals[V_FAILED].n = "Failed";
vals[V_SIP_SESSION].n = "Sip-Session";
/* open log */
rc_openlog("ser");
/* read config */
if ((rh = rc_read_config(radius_config)) == NULL) {
LOG(L_ERR, "ERROR:acc:mod_init: Error opening radius config file: %s\n",
radius_config);
return -1;
}
/* read dictionary */
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {
LOG(L_ERR, "ERROR:acc:mod_init: Error reading radius dictionary\n");
return -1;
}
vend = rc_dict_findvend(rh, "iptelorg");
if (vend == NULL) {
ERR("RADIUS dictionary is missing required vendor 'iptelorg'\n");
return -1;
}
INIT_AV(rh, attrs, vals, "acc", -1, -1);
if (service_type != -1) {
vals[V_SIP_SESSION].v = service_type;
}
if (parse_attrs(&avps, &avps_n, attrs_param) < 0) {
ERR("Error while parsing 'attrs' module parameter\n");
return -1;
}
return 0;
}
int
auth_call_radius(const uschar *s, uschar **errptr)
{
uschar *user;
const uschar *radius_args = s;
int result;
int sep = 0;
#ifdef RADIUS_LIB_RADLIB
struct rad_handle *h;
#else
#ifdef RADIUS_LIB_RADIUSCLIENTNEW
rc_handle *h;
#endif
VALUE_PAIR *send = NULL;
VALUE_PAIR *received;
unsigned int service = PW_AUTHENTICATE_ONLY;
char msg[4096];
#endif
user = string_nextinlist(&radius_args, &sep, big_buffer, big_buffer_size);
if (user == NULL) user = US"";
DEBUG(D_auth) debug_printf("Running RADIUS authentication for user \"%s\" "
"and \"%s\"\n", user, radius_args);
*errptr = NULL;
/* Authenticate using the radiusclient library */
#ifndef RADIUS_LIB_RADLIB
rc_openlog("exim");
#ifdef RADIUS_LIB_RADIUSCLIENT
if (rc_read_config(RADIUS_CONFIG_FILE) != 0)
*errptr = string_sprintf("RADIUS: can't open %s", RADIUS_CONFIG_FILE);
else if (rc_read_dictionary(rc_conf_str("dictionary")) != 0)
*errptr = string_sprintf("RADIUS: can't read dictionary");
else if (rc_avpair_add(&send, PW_USER_NAME, user, 0) == NULL)
*errptr = string_sprintf("RADIUS: add user name failed\n");
else if (rc_avpair_add(&send, PW_USER_PASSWORD, CS radius_args, 0) == NULL)
*errptr = string_sprintf("RADIUS: add password failed\n");
else if (rc_avpair_add(&send, PW_SERVICE_TYPE, &service, 0) == NULL)
*errptr = string_sprintf("RADIUS: add service type failed\n");
#else /* RADIUS_LIB_RADIUSCLIENT unset => RADIUS_LIB_RADIUSCLIENT2 */
if ((h = rc_read_config(RADIUS_CONFIG_FILE)) == NULL)
*errptr = string_sprintf("RADIUS: can't open %s", RADIUS_CONFIG_FILE);
else if (rc_read_dictionary(h, rc_conf_str(h, "dictionary")) != 0)
*errptr = string_sprintf("RADIUS: can't read dictionary");
else if (rc_avpair_add(h, &send, PW_USER_NAME, user, Ustrlen(user), 0) == NULL)
*errptr = string_sprintf("RADIUS: add user name failed\n");
else if (rc_avpair_add(h, &send, PW_USER_PASSWORD, CS radius_args,
Ustrlen(radius_args), 0) == NULL)
*errptr = string_sprintf("RADIUS: add password failed\n");
else if (rc_avpair_add(h, &send, PW_SERVICE_TYPE, &service, 0, 0) == NULL)
*errptr = string_sprintf("RADIUS: add service type failed\n");
#endif /* RADIUS_LIB_RADIUSCLIENT */
if (*errptr != NULL)
{
DEBUG(D_auth) debug_printf("%s\n", *errptr);
return ERROR;
}
#ifdef RADIUS_LIB_RADIUSCLIENT
result = rc_auth(0, send, &received, msg);
#else
result = rc_auth(h, 0, send, &received, msg);
#endif
DEBUG(D_auth) debug_printf("RADIUS code returned %d\n", result);
switch (result)
{
case OK_RC:
return OK;
case REJECT_RC:
case ERROR_RC:
return FAIL;
case TIMEOUT_RC:
*errptr = US"RADIUS: timed out";
return ERROR;
default:
case BADRESP_RC:
*errptr = string_sprintf("RADIUS: unexpected response (%d)", result);
return ERROR;
}
#else /* RADIUS_LIB_RADLIB is set */
/* Authenticate using the libradius library */
h = rad_auth_open();
if (h == NULL)
{
*errptr = string_sprintf("RADIUS: can't initialise libradius");
return ERROR;
}
if (rad_config(h, RADIUS_CONFIG_FILE) != 0 ||
rad_create_request(h, RAD_ACCESS_REQUEST) != 0 ||
rad_put_string(h, RAD_USER_NAME, CS user) != 0 ||
rad_put_string(h, RAD_USER_PASSWORD, CS radius_args) != 0 ||
rad_put_int(h, RAD_SERVICE_TYPE, RAD_AUTHENTICATE_ONLY) != 0 ||
rad_put_string(h, RAD_NAS_IDENTIFIER, CS primary_hostname) != 0)
{
*errptr = string_sprintf("RADIUS: %s", rad_strerror(h));
result = ERROR;
}
else
{
result = rad_send_request(h);
switch(result)
{
case RAD_ACCESS_ACCEPT:
result = OK;
break;
case RAD_ACCESS_REJECT:
result = FAIL;
break;
case -1:
*errptr = string_sprintf("RADIUS: %s", rad_strerror(h));
result = ERROR;
break;
default:
*errptr = string_sprintf("RADIUS: unexpected response (%d)", result);
result= ERROR;
break;
}
}
if (*errptr != NULL) DEBUG(D_auth) debug_printf("%s\n", *errptr);
rad_close(h);
return result;
#endif /* RADIUS_LIB_RADLIB */
}
int rc_read_dictionary (rc_handle *rh, const char *filename)
{
FILE *dictfd;
char dummystr[AUTH_ID_LEN];
char namestr[AUTH_ID_LEN];
char valstr[AUTH_ID_LEN];
char attrstr[AUTH_ID_LEN];
char typestr[AUTH_ID_LEN];
char optstr[AUTH_ID_LEN];
char *cp, *ifilename;
int line_no;
DICT_ATTR *attr;
DICT_VALUE *dval;
DICT_VENDOR *dvend;
char buffer[256];
int value;
int type;
if ((dictfd = fopen (filename, "r")) == NULL) {
rc_log(LOG_ERR, "rc_read_dictionary: couldn't open dictionary %s: %s",
filename, strerror(errno));
return -1;
}
line_no = 0;
while (fgets (buffer, sizeof (buffer), dictfd) != NULL) {
line_no++;
/* Skip empty space */
if (*buffer == '#' || *buffer == '\0' || *buffer == '\n' || \
*buffer == '\r') {
continue;
}
/* Strip out comments */
cp = strchr(buffer, '#');
if (cp != NULL) {
*cp = '\0';
}
if (strncmp (buffer, "ATTRIBUTE", 9) == 0) {
optstr[0] = '\0';
/* Read the ATTRIBUTE line */
if (sscanf (buffer, "%s%s%s%s%s", dummystr, namestr,
valstr, typestr, optstr) < 4) {
rc_log(LOG_ERR, "rc_read_dictionary: invalid attribute on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
/*
* Validate all entries
*/
if (strlen (namestr) > NAME_LENGTH) {
rc_log(LOG_ERR, "rc_read_dictionary: invalid name length on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
if (!isdigit (*valstr)) {
rc_log(LOG_ERR,
"rc_read_dictionary: invalid value on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
value = atoi (valstr);
if (strcmp (typestr, "string") == 0) {
type = PW_TYPE_STRING;
} else if (strcmp (typestr, "integer") == 0) {
type = PW_TYPE_INTEGER;
} else if (strcmp (typestr, "ipaddr") == 0) {
type = PW_TYPE_IPADDR;
} else if (strcmp (typestr, "ipv6addr") == 0) {
type = PW_TYPE_IPV6ADDR;
} else if (strcmp (typestr, "date") == 0) {
type = PW_TYPE_DATE;
} else {
rc_log(LOG_ERR,
"rc_read_dictionary: invalid type on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
dvend = NULL;
if (optstr[0] != '\0') {
char *cp1;
for (cp1 = optstr; cp1 != NULL; cp1 = cp) {
cp = strchr(cp1, ',');
if (cp != NULL) {
*cp = '\0';
cp++;
}
if (strncmp(cp1, "vendor=", 7) == 0)
cp1 += 7;
dvend = rc_dict_findvend(rh, cp1);
if (dvend == NULL) {
rc_log(LOG_ERR,
"rc_read_dictionary: unknown Vendor-Id %s on line %d of dictionary %s",
cp1, line_no, filename);
fclose(dictfd);
return -1;
}
}
}
/* Create a new attribute for the list */
if ((attr = malloc (sizeof (DICT_ATTR))) == NULL) {
rc_log(LOG_CRIT, "rc_read_dictionary: out of memory");
fclose(dictfd);
return -1;
}
strcpy (attr->name, namestr);
attr->value = value;
attr->type = type;
if (dvend != NULL)
attr->value |= (dvend->vendorpec << 16);
//rc_log(LOG_ERR, "rc_read_dictionary: ADD ATTRIBUTE Name %s Value %d Type %d",attr->name, attr->value, attr->type);
/* Insert it into the list */
attr->next = rh->dictionary_attributes;
rh->dictionary_attributes = attr;
} else if (strncmp (buffer, "VALUE", 5) == 0) {
/* Read the VALUE line */
if (sscanf (buffer, "%s%s%s%s", dummystr, attrstr,
namestr, valstr) != 4) {
rc_log(LOG_ERR,
"rc_read_dictionary: invalid value entry on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
/*
* Validate all entries
*/
if (strlen (attrstr) > NAME_LENGTH) {
rc_log(LOG_ERR,
"rc_read_dictionary: invalid attribute length on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
if (strlen (namestr) > NAME_LENGTH) {
rc_log(LOG_ERR,
"rc_read_dictionary: invalid name length on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
if (!isdigit (*valstr)) {
rc_log(LOG_ERR,
"rc_read_dictionary: invalid value on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
value = atoi (valstr);
/* Create a new VALUE entry for the list */
if ((dval = malloc (sizeof (DICT_VALUE))) == NULL) {
rc_log(LOG_CRIT, "rc_read_dictionary: out of memory");
fclose(dictfd);
return -1;
}
strcpy (dval->attrname, attrstr);
strcpy (dval->name, namestr);
dval->value = value;
//rc_log(LOG_ERR, "rc_read_dictionary: ADD VALUE Name %s Value %s Type %d",dval->attrname, dval->name, dval->value);
/* Insert it into the list */
dval->next = rh->dictionary_values;
rh->dictionary_values = dval;
} else if (strncmp (buffer, "$INCLUDE", 8) == 0) {
/* Read the $INCLUDE line */
if (sscanf (buffer, "%s%s", dummystr, namestr) != 2) {
rc_log(LOG_ERR,
"rc_read_dictionary: invalid include entry on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
ifilename = namestr;
/* Append directory if necessary */
if (namestr[0] != '/') {
cp = strrchr(filename, '/');
if (cp != NULL) {
ifilename = alloca(AUTH_ID_LEN);
*cp = '\0';
sprintf(ifilename, "%s/%s", filename, namestr);
*cp = '/';
}
}
if (rc_read_dictionary(rh, ifilename) < 0) {
fclose(dictfd);
return -1;
}
} else if (strncmp (buffer, "VENDOR", 6) == 0) {
/* Read the VALUE line */
if (sscanf (buffer, "%s%s%s", dummystr, attrstr, valstr) != 3) {
rc_log(LOG_ERR,
"rc_read_dictionary: invalid Vendor-Id on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
/* Validate all entries */
if (strlen (attrstr) > NAME_LENGTH) {
rc_log(LOG_ERR,
"rc_read_dictionary: invalid attribute length on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
if (!isdigit (*valstr)) {
rc_log(LOG_ERR,
"rc_read_dictionary: invalid Vendor-Id on line %d of dictionary %s",
line_no, filename);
fclose(dictfd);
return -1;
}
value = atoi (valstr);
/* Create a new VENDOR entry for the list */
dvend = malloc(sizeof(DICT_VENDOR));
if (dvend == NULL) {
rc_log(LOG_CRIT, "rc_read_dictionary: out of memory");
fclose(dictfd);
return -1;
}
strcpy (dvend->vendorname, attrstr);
dvend->vendorpec = value;
/* Insert it into the list */
dvend->next = rh->dictionary_vendors;
rh->dictionary_vendors = dvend;
}
}
fclose (dictfd);
return 0;
}
int
main (int argc, char **argv)
{
int result = ERROR_RC;
VALUE_PAIR *send = NULL;
UINT4 client_port;
int c;
VALUE_PAIR *vp;
DICT_VALUE *dval;
char *username, *service, *fproto, *type;
char *path_radiusclient_conf = RC_CONFIG_FILE;
char *ttyn = NULL;
rc_handle *rh;
extern char *optarg;
pname = (pname = strrchr(argv[0],'/'))?pname+1:argv[0];
rc_openlog(pname);
while ((c = getopt(argc,argv,"f:i:hV")) > 0)
{
switch(c)
{
case 'f':
path_radiusclient_conf = optarg;
break;
case 'i':
ttyn = optarg;
break;
case 'V':
version();
break;
case 'h':
usage();
break;
default:
exit(ERROR_RC);
break;
}
}
if ((rh = rc_read_config(path_radiusclient_conf)) == NULL)
exit(ERROR_RC);
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0)
exit (ERROR_RC);
if (rc_read_mapfile(rh, rc_conf_str(rh, "mapfile")) != 0)
exit (ERROR_RC);
if (ttyn != NULL)
{
client_port = rc_map2id(rh, ttyn);
}
else
{
/* we take stdout here, because stdin is usually connected
* to our input file
*/
if ((ttyn = ttyname(1)) != NULL)
{
client_port = rc_map2id(rh, ttyn);
}
else
{
client_port = 0;
}
}
if ((send = rc_avpair_readin(rh, stdin))) {
username = service = type = "(unknown)";
fproto = NULL;
if ((vp = rc_avpair_get(send, PW_ACCT_STATUS_TYPE, 0)) != NULL)
if ((dval = rc_dict_getval(rh, vp->lvalue, vp->name)) != NULL) {
type = dval->name;
}
if ((vp = rc_avpair_get(send, PW_USER_NAME, 0)) != NULL)
username = vp->strvalue;
if ((vp = rc_avpair_get(send, PW_SERVICE_TYPE, 0)) != NULL)
if ((dval = rc_dict_getval(rh, vp->lvalue, vp->name)) != NULL) {
service = dval->name;
}
if (vp && (vp->lvalue == PW_FRAMED) &&
((vp = rc_avpair_get(send, PW_FRAMED_PROTOCOL, 0)) != NULL))
if ((dval = rc_dict_getval(rh, vp->lvalue, vp->name)) != NULL) {
fproto = dval->name;
}
result = rc_acct(rh, client_port, send);
if (result == OK_RC)
{
fprintf(stderr, SC_ACCT_OK);
rc_log(LOG_NOTICE, "accounting OK, type %s, username %s, service %s%s%s",
type, username, service,(fproto)?"/":"", (fproto)?fproto:"");
}
else
{
fprintf(stderr, SC_ACCT_FAILED, result);
rc_log(LOG_NOTICE, "accounting FAILED, type %s, username %s, service %s%s%s",
type, username, service,(fproto)?"/":"", (fproto)?fproto:"");
}
rc_avpair_free(send);
}
exit (result);
}
int
main (int argc, char **argv)
{
char username[128];
char passwd[AUTH_PASS_LEN + 1];
int tries, remaining, c;
UINT4 client_port;
void (*login_func)(char *);
FILE *fp;
char buf[4096];
char tty[1024], *p;
int noissue = 0;
int maxtries = 0;
char *ttyn = NULL;
char *path_radiusclient_conf = RC_CONFIG_FILE;
extern char *optarg;
extern int optind;
pname = (pname = strrchr(argv[0],'/'))?pname+1:argv[0];
rc_openlog(pname);
while ((c = getopt(argc,argv,"f:m:i:nhV")) > 0)
{
switch(c) {
case 'f':
path_radiusclient_conf = optarg;
break;
case 'i':
ttyn = optarg;
break;
case 'n':
noissue = 1;
break;
case 'm':
maxtries = atoi(optarg);
break;
case 'V':
version();
break;
case 'h':
usage();
break;
default:
exit(ERROR_RC);
break;
}
}
if (rc_read_config(path_radiusclient_conf) != 0)
exit(ERROR_RC);
if (rc_read_dictionary(rc_conf_str("dictionary")) != 0)
exit (ERROR_RC);
if (rc_read_mapfile(rc_conf_str("mapfile")) != 0)
exit (ERROR_RC);
if (ttyn != NULL)
{
client_port = rc_map2id(ttyn);
if ((p = strrchr(ttyn, '/')) == NULL)
strncpy(tty, ttyn, sizeof(tty));
else
strncpy(tty, p+1, sizeof(tty));
}
else
{
ttyn = ttyname(0);
if (ttyn)
{
if ((p = strrchr(ttyn, '/')) == NULL)
strncpy(tty, ttyn, sizeof(tty));
else
strncpy(tty, p+1, sizeof(tty));
client_port = rc_map2id(ttyn);
}
else
{
*tty = '\0';
client_port = 0;
}
}
#ifdef SETVBUF_REVERSED
setvbuf(stdout, _IONBF, NULL, 0);
#else
setvbuf(stdout, NULL, _IONBF, 0);
#endif
if ((argc - optind) == 1)
{
strncpy(username,argv[optind], sizeof(username));
}
else
{
*username = '******';
if (!noissue) {
if (rc_conf_str("issue") && ((fp = fopen(rc_conf_str("issue"), "r")) != NULL))
{
while (fgets(buf, sizeof(buf), fp) != NULL)
fputs(subst_placeholders(buf, tty), stdout);
fflush(stdout);
fclose(fp);
} else {
fputs(subst_placeholders(SC_DEFAULT_ISSUE, tty), stdout);
fflush(stdout);
}
}
}
if ((env = rc_new_env(ENV_SIZE)) == NULL)
{
rc_log(LOG_CRIT, "rc_new_env: FATAL: out of memory");
abort();
}
#ifdef SECURITY_DISABLED
if (rc_import_env(env,environ) < 0)
{
rc_log(LOG_CRIT, "rc_import_env: FATAL: not enough space for environment (increase ENV_SIZE)");
abort();
}
#else
rc_add_env(env, "IFS", " ");
rc_add_env(env, "PATH", RC_SECURE_PATH);
#endif
signal(SIGALRM, alarm_handler);
remaining = rc_conf_int("login_timeout");
if (!maxtries)
maxtries = rc_conf_int("login_tries");
tries = 1;
while (tries <= maxtries)
{
alarm(remaining);
while (!*username) {
p = rc_getstr (SC_LOGIN, 1);
if (p)
strncpy(username, p, sizeof(username));
else
exit (ERROR_RC);
}
p = rc_getstr(SC_PASSWORD,0);
if (p)
strncpy (passwd, p, sizeof (passwd));
else
exit (ERROR_RC);
remaining = alarm(0);
login_func = NULL;
if (rc_conf_int("auth_order") & AUTH_LOCAL_FST)
{
login_func = auth_local(username, passwd);
if (!login_func)
if (rc_conf_int("auth_order") & AUTH_RADIUS_SND)
login_func = auth_radius(client_port, username, passwd);
}
else
{
login_func = auth_radius(client_port, username, passwd);
if (!login_func)
if (rc_conf_int("auth_order") & AUTH_LOCAL_SND)
login_func = auth_local(username, passwd);
}
memset(passwd, '\0', sizeof(passwd));
if (login_func != NULL)
if (login_allowed(tty)) {
(*login_func)(username);
} else {
sleep(1);
exit (ERROR_RC);
}
*username = '******';
if ((++tries) <= maxtries) {
alarm(remaining);
sleep(tries * 2);
remaining = alarm(0);
}
}
fprintf(stderr, SC_EXCEEDED);
sleep(1);
exit (ERROR_RC);
}
int radius_auth_test(switch_channel_t *channel, char* username1, char* passwd1, char* auth_result, char* biling_model, char* credit_amount, char* currency, char* preffered_lang)
{
int result;
char username[128];
char passwd[AUTH_PASS_LEN + 1];
VALUE_PAIR *send, *received;
uint32_t service;
char msg[4096], username_realm[256];
char *default_realm;
rc_handle *rh;
strcpy(username, "123");
strcpy(passwd, "123");
if ((rh = rc_read_config(RC_CONFIG_FILE)) == NULL)
return ERROR_RC;
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0)
return ERROR_RC;
default_realm = rc_conf_str(rh, "default_realm");
send = NULL;
/*
* Fill in User-Name
*/
strncpy(username_realm, username, sizeof(username_realm));
/* Append default realm */
if ((strchr(username_realm, '@') == NULL) && default_realm &&
(*default_realm != '\0'))
{
strncat(username_realm, "@", sizeof(username_realm)-strlen(username_realm)-1);
strncat(username_realm, default_realm, sizeof(username_realm)-strlen(username_realm)-1);
}
if (rc_avpair_add(rh, &send, PW_USER_NAME, username_realm, -1, 0) == NULL)
return ERROR_RC;
/*
* Fill in User-Password
*/
if (rc_avpair_add(rh, &send, PW_USER_PASSWORD, passwd, -1, 0) == NULL)
return ERROR_RC;
/*
* Fill in Service-Type
*/
service = PW_AUTHENTICATE_ONLY;
if (rc_avpair_add(rh, &send, PW_SERVICE_TYPE, &service, -1, 0) == NULL)
return ERROR_RC;
result = rc_auth(rh, 0, send, &received, msg);
if (result == OK_RC)
{
fprintf(stderr, "\"%s\" RADIUS Authentication OK\n", username);
}
else
{
fprintf(stderr, "\"%s\" RADIUS Authentication failure (RC=%i)\n", username, result);
}
return result;
}
int radius_auth(switch_channel_t *channel, char* called_number, char* username, char* password , char* auth_result/*, char* biling_model, char* credit_amount, char* currency, char* preffered_lang*/)
{
int result = OK_RC;
VALUE_PAIR *send = NULL;
VALUE_PAIR *received = NULL;
VALUE_PAIR *service_vp;
DICT_ATTR *pda;
CONFIG_VSAS* PCONFIGVSAS = NULL;
char *default_realm = NULL;
rc_handle *rh = NULL;
int attrid =0;
char msg[STR_LENGTH * 10 + 1];
char username_realm[STR_LENGTH + 1];
char value[STR_LENGTH + 1];
int integer;
memset(msg, 0, STR_LENGTH * 10);
memset(username_realm, 0, STR_LENGTH);
send = NULL;
do
{
#if EMBENDED_CONFIG
CONFIG_CLIENT* PCONFIGCLIENT = CONFIGCLIENT;
rh = rc_new();
if (rh == NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ERROR: Failed to allocate initial structure.\n");
result = ERROR_RC;
break;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "allocate initial structure.\n");
/* Initialize the config structure */
rh = rc_config_init(rh);
if (rh == NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"ERROR: Failed to initialze configuration.\n");
result = ERROR_RC;
break;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,"initialzed configuration.\n");
while(PCONFIGCLIENT)
{
//if (rc_add_config(rh, "auth_order", "radius", "config", 0) != 0)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "set %s := %s.\n", PCONFIGCLIENT->name, PCONFIGCLIENT->value);
if (rc_add_config(rh, PCONFIGCLIENT->name, PCONFIGCLIENT->value, "config", 0) != 0)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ERROR: Unable to set %s := %s.\n", PCONFIGCLIENT->name, PCONFIGCLIENT->value);
result = ERROR_RC;
break;
}
PCONFIGCLIENT = PCONFIGCLIENT->pNext;
}
if (result == ERROR_RC)
break;
#else
if ((rh = rc_read_config(!rc_config_file ? RC_CONFIG_FILE : rc_config_file)) == NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error loading radius config file\n");
result = ERROR_RC;
break;
}
#endif
if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error loading radius dictionary\n");
result = ERROR_RC;
break;
}
default_realm = rc_conf_str(rh, "default_realm");
if (default_realm == NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "default_realm is null object.\n");
result = ERROR_RC;
break;
}
strncpy(username_realm, username, sizeof(username_realm));
if ((strchr(username_realm, '@') == NULL) && default_realm &&
(*default_realm != '\0'))
{
strncat(username_realm, "@", sizeof(username_realm)-strlen(username_realm)-1);
strncat(username_realm, default_realm, sizeof(username_realm)-strlen(username_realm)-1);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
"... radius: User-Name: %s\n", username);
if (rc_avpair_add(rh, &send, PW_USER_NAME, username_realm, -1, 0)== NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "An Error occured during rc_avpair_add : username\n");
result = ERROR_RC;
break;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
"... radius: User-Password: %s\n", password);
if (rc_avpair_add(rh, &send, PW_USER_PASSWORD, password, -1, 0) == NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "An Error occured during rc_avpair_add : password\n");
result = ERROR_RC;
break;
}
if (!called_number || strcmp(called_number, "") == 0)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
"... radius: Called-station-Id is empty, ignoring...\n");
}
else
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
"... radius: Called-station-Id: %s\n", called_number);
if (rc_avpair_add(rh, &send, 30, called_number, -1, 0) == NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "An Error occured during rc_avpair_add : Called-station-Id\n");
result = ERROR_RC;
break;
}
}
PCONFIGVSAS = CONFIGVSAS;
while(PCONFIGVSAS)
{
if (PCONFIGVSAS->direction == 1)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Handle attribute: %s\n", PCONFIGVSAS->name );
memset(value, 0, STR_LENGTH);
GetValue(channel, PCONFIGVSAS, value);
if (PCONFIGVSAS->pec != 0)
attrid = PCONFIGVSAS->id | (PCONFIGVSAS->pec << 16);
else
attrid = PCONFIGVSAS->id ;
pda = rc_dict_getattr(rh, attrid);
if (pda == NULL)
{
result = ERROR_RC;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unknown attribute: key:%s, not found in dictionary\n", PCONFIGVSAS->name);
break;
}
if (PCONFIGVSAS->pec != 0 && rc_dict_getvend(rh, PCONFIGVSAS->pec) == NULL)
{
result = ERROR_RC;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unknown vendor specific id: key:%s, id:%dnot found in dictionary\n", PCONFIGVSAS->name, PCONFIGVSAS->pec);
break;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "... dictionary data: id:%d, vendor id:%d, attr type:%d, attr name:%s (%d)\n", PCONFIGVSAS->id, PCONFIGVSAS->pec, pda->type, pda->name, attrid);
switch(pda->type)
{
case PW_TYPE_STRING:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "... radius: key:%s, value:%s (%s) as string\n", PCONFIGVSAS->name, PCONFIGVSAS->value, value);
if (rc_avpair_add(rh, &send, PCONFIGVSAS->id, value, -1, PCONFIGVSAS->pec) == NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "An Error occured during rc_avpair_add : %s\n", PCONFIGVSAS->name);
result = ERROR_RC;
break;
}
break;
//case PW_TYPE_DATE:
case PW_TYPE_INTEGER:
integer = atoi(value);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "... radius: key:%s, value:%s (%d) as integer\n", PCONFIGVSAS->name, PCONFIGVSAS->value, integer);
if (rc_avpair_add(rh, &send, PCONFIGVSAS->id, &integer, -1, PCONFIGVSAS->pec) == NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "An Error occured during rc_avpair_add : %s\n", PCONFIGVSAS->name);
result = ERROR_RC;
break;
}
break;
case PW_TYPE_IPADDR:
integer = rc_get_ipaddr(value);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "... radius: key:%s, value:%s (%d) as ipaddr\n", PCONFIGVSAS->name, PCONFIGVSAS->value, integer);
if (rc_avpair_add(rh, &send, PCONFIGVSAS->id, &integer, -1, PCONFIGVSAS->pec) == NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "An Error occured during rc_avpair_add : %s\n", PCONFIGVSAS->name);
result = ERROR_RC;
break;
}
break;
default:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unknown attribute type: key:%s, type %d\n", PCONFIGVSAS->name, pda->type);
break;
}
}
PCONFIGVSAS = PCONFIGVSAS->pNext;
}
if (result != ERROR_RC)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "sending radius packet ...\n" );
result = rc_auth(rh, 0, send, &received, msg);
if (result == OK_RC)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
"RADIUS Authentication OK\n");
strcpy(auth_result, "OK");
}
else
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
" RADIUS Authentication failure (RC=%d)\n",
result);
strcpy(auth_result, "NOK");
}
PCONFIGVSAS = CONFIGVSAS;
while(PCONFIGVSAS)
{
if (PCONFIGVSAS->direction == 0)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Handle attribute: %s\n", PCONFIGVSAS->name );
if ((service_vp = rc_avpair_get(received, PCONFIGVSAS->id, PCONFIGVSAS->pec)) != NULL)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "\tattribute (%s) found in radius packet\n", PCONFIGVSAS->name);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "\tset variable %s := %s\n", PCONFIGVSAS->value, service_vp->strvalue);
switch_channel_set_variable(channel, PCONFIGVSAS->value, service_vp->strvalue);
}
else
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "\tNo found out attribute id: %d, pec:%d, (%s)\n", PCONFIGVSAS->id, PCONFIGVSAS->pec, PCONFIGVSAS->name );
}
}
PCONFIGVSAS = PCONFIGVSAS->pNext;
}
}
else
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "abort sending radius packet.\n" );
break;
}
} while(1 == 0);
if (result == ERROR_RC)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
"An error occured during RADIUS Authentication(RC=%d)\n",
result);
}
free_radius_auth_value_pair(send, received, rh);
return result;
}
static int mod_init( void )
{
load_tm_f load_tm;
fprintf( stderr, "acc - initializing\n");
/* import the TM auto-loading function */
if ( !(load_tm=(load_tm_f)find_export("load_tm", NO_SCRIPT, 0))) {
LOG(L_ERR, "ERROR: acc: mod_init: can't import load_tm\n");
return -1;
}
/* let the auto-loading function load all TM stuff */
if (load_tm( &tmb )==-1) return -1;
if (verify_fmt(log_fmt)==-1) return -1;
/* register callbacks */
/* report on completed transactions */
if (tmb.register_tmcb( TMCB_RESPONSE_OUT, acc_onreply, 0 /* empty param */ ) <= 0)
return -1;
/* account e2e acks if configured to do so */
if (tmb.register_tmcb( TMCB_E2EACK_IN, acc_onack, 0 /* empty param */ ) <=0 )
return -1;
/* disable silent c-timer for registered calls */
if (tmb.register_tmcb( TMCB_REQUEST_IN, acc_onreq, 0 /* empty param */ ) <=0 )
return -1;
/* report on missed calls */
if (tmb.register_tmcb( TMCB_ON_FAILURE, on_missed, 0 /* empty param */ ) <=0 )
return -1;
/* get incoming replies ready for processing */
if (tmb.register_tmcb( TMCB_RESPONSE_IN, acc_onreply_in, 0 /* empty param */)<=0)
return -1;
#ifdef SQL_ACC
if (bind_dbmod()) {
LOG(L_ERR, "ERROR: acc: init_child bind_db failed..."
"did you load a database module?\n");
return -1;
}
#endif
#ifdef RAD_ACC
/* open log */
rc_openlog("ser");
/* read config */
if (rc_read_config(radius_config)!=0) {
LOG(L_ERR, "ERROR: acc: error opening radius config file: %s\n",
radius_config );
return -1;
}
/* read dictionary */
if (rc_read_dictionary(rc_conf_str("dictionary"))!=0) {
LOG(L_ERR, "ERROR: acc: error reading radius dictionary\n");
return -1;
}
#endif
return 0;
}