cellular-infrastructure
/
osmo-msc
mirror of https://gerrit.osmocom.org/osmo-msc
9
0
Fork 0
Code Issues Releases Wiki Activity

increase the use of 'struct value_string' in abis_nm and gsm_data

This commit is contained in:
Harald Welte 2010-03-25 11:45:30 +08:00
parent bb7bc1155f
commit 92b1fe4c2d
2 changed files with 183 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

295
openbsc/src/abis_nm.c
View File

@ -114,125 +114,117 @@ static const enum abis_nm_msgtype nacks[] = {
NM_MT_BS11_DELETE_OBJ_NACK, NM_MT_BS11_DELETE_OBJ_NACK,
}; };
static const char *nack_names[0xff] = { static const struct value_string nack_names[] = {
[NM_MT_LOAD_INIT_NACK] = "SOFTWARE LOAD INIT", { NM_MT_LOAD_INIT_NACK, "SOFTWARE LOAD INIT" },
[NM_MT_LOAD_END_NACK] = "SOFTWARE LOAD END", { NM_MT_LOAD_END_NACK, "SOFTWARE LOAD END" },
[NM_MT_SW_ACT_REQ_NACK] = "SOFTWARE ACTIVATE REQUEST", { NM_MT_SW_ACT_REQ_NACK, "SOFTWARE ACTIVATE REQUEST" },
[NM_MT_ACTIVATE_SW_NACK] = "ACTIVATE SOFTWARE", { NM_MT_ACTIVATE_SW_NACK, "ACTIVATE SOFTWARE" },
[NM_MT_ESTABLISH_TEI_NACK] = "ESTABLISH TEI", { NM_MT_ESTABLISH_TEI_NACK, "ESTABLISH TEI" },
[NM_MT_CONN_TERR_SIGN_NACK] = "CONNECT TERRESTRIAL SIGNALLING", { NM_MT_CONN_TERR_SIGN_NACK, "CONNECT TERRESTRIAL SIGNALLING" },
[NM_MT_DISC_TERR_SIGN_NACK] = "DISCONNECT TERRESTRIAL SIGNALLING", { NM_MT_DISC_TERR_SIGN_NACK, "DISCONNECT TERRESTRIAL SIGNALLING" },
[NM_MT_CONN_TERR_TRAF_NACK] = "CONNECT TERRESTRIAL TRAFFIC", { NM_MT_CONN_TERR_TRAF_NACK, "CONNECT TERRESTRIAL TRAFFIC" },
[NM_MT_DISC_TERR_TRAF_NACK] = "DISCONNECT TERRESTRIAL TRAFFIC", { NM_MT_DISC_TERR_TRAF_NACK, "DISCONNECT TERRESTRIAL TRAFFIC" },
[NM_MT_CONN_MDROP_LINK_NACK] = "CONNECT MULTI-DROP LINK", { NM_MT_CONN_MDROP_LINK_NACK, "CONNECT MULTI-DROP LINK" },
[NM_MT_DISC_MDROP_LINK_NACK] = "DISCONNECT MULTI-DROP LINK", { NM_MT_DISC_MDROP_LINK_NACK, "DISCONNECT MULTI-DROP LINK" },
[NM_MT_SET_BTS_ATTR_NACK] = "SET BTS ATTRIBUTE", { NM_MT_SET_BTS_ATTR_NACK, "SET BTS ATTRIBUTE" },
[NM_MT_SET_RADIO_ATTR_NACK] = "SET RADIO ATTRIBUTE", { NM_MT_SET_RADIO_ATTR_NACK, "SET RADIO ATTRIBUTE" },
[NM_MT_SET_CHAN_ATTR_NACK] = "SET CHANNEL ATTRIBUTE", { NM_MT_SET_CHAN_ATTR_NACK, "SET CHANNEL ATTRIBUTE" },
[NM_MT_PERF_TEST_NACK] = "PERFORM TEST", { NM_MT_PERF_TEST_NACK, "PERFORM TEST" },
[NM_MT_SEND_TEST_REP_NACK] = "SEND TEST REPORT", { NM_MT_SEND_TEST_REP_NACK, "SEND TEST REPORT" },
[NM_MT_STOP_TEST_NACK] = "STOP TEST", { NM_MT_STOP_TEST_NACK, "STOP TEST" },
[NM_MT_STOP_EVENT_REP_NACK] = "STOP EVENT REPORT", { NM_MT_STOP_EVENT_REP_NACK, "STOP EVENT REPORT" },
[NM_MT_REST_EVENT_REP_NACK] = "RESET EVENT REPORT", { NM_MT_REST_EVENT_REP_NACK, "RESET EVENT REPORT" },
[NM_MT_CHG_ADM_STATE_NACK] = "CHANGE ADMINISTRATIVE STATE", { NM_MT_CHG_ADM_STATE_NACK, "CHANGE ADMINISTRATIVE STATE" },
[NM_MT_CHG_ADM_STATE_REQ_NACK] = "CHANGE ADMINISTRATIVE STATE REQUEST", { NM_MT_CHG_ADM_STATE_REQ_NACK,
[NM_MT_REP_OUTST_ALARMS_NACK] = "REPORT OUTSTANDING ALARMS", "CHANGE ADMINISTRATIVE STATE REQUEST" },
[NM_MT_CHANGEOVER_NACK] = "CHANGEOVER", { NM_MT_REP_OUTST_ALARMS_NACK, "REPORT OUTSTANDING ALARMS" },
[NM_MT_OPSTART_NACK] = "OPSTART", { NM_MT_CHANGEOVER_NACK, "CHANGEOVER" },
[NM_MT_REINIT_NACK] = "REINIT", { NM_MT_OPSTART_NACK, "OPSTART" },
[NM_MT_SET_SITE_OUT_NACK] = "SET SITE OUTPUT", { NM_MT_REINIT_NACK, "REINIT" },
[NM_MT_CHG_HW_CONF_NACK] = "CHANGE HARDWARE CONFIGURATION", { NM_MT_SET_SITE_OUT_NACK, "SET SITE OUTPUT" },
[NM_MT_GET_ATTR_NACK] = "GET ATTRIBUTE", { NM_MT_CHG_HW_CONF_NACK, "CHANGE HARDWARE CONFIGURATION" },
[NM_MT_SET_ALARM_THRES_NACK] = "SET ALARM THRESHOLD", { NM_MT_GET_ATTR_NACK, "GET ATTRIBUTE" },
[NM_MT_BS11_BEGIN_DB_TX_NACK] = "BS11 BEGIN DATABASE TRANSMISSION", { NM_MT_SET_ALARM_THRES_NACK, "SET ALARM THRESHOLD" },
[NM_MT_BS11_END_DB_TX_NACK] = "BS11 END DATABASE TRANSMISSION", { NM_MT_BS11_BEGIN_DB_TX_NACK, "BS11 BEGIN DATABASE TRANSMISSION" },
[NM_MT_BS11_CREATE_OBJ_NACK] = "BS11 CREATE OBJECT", { NM_MT_BS11_END_DB_TX_NACK, "BS11 END DATABASE TRANSMISSION" },
[NM_MT_BS11_DELETE_OBJ_NACK] = "BS11 DELETE OBJECT", { NM_MT_BS11_CREATE_OBJ_NACK, "BS11 CREATE OBJECT" },
{ NM_MT_BS11_DELETE_OBJ_NACK, "BS11 DELETE OBJECT" },
{ 0, NULL }
}; };
/* Chapter 9.4.36 */ /* Chapter 9.4.36 */
static const char *nack_cause_names[] = { static const struct value_string nack_cause_names[] = {
/* General Nack Causes */ /* General Nack Causes */
[NM_NACK_INCORR_STRUCT] = "Incorrect message structure", { NM_NACK_INCORR_STRUCT, "Incorrect message structure" },
[NM_NACK_MSGTYPE_INVAL] = "Invalid message type value", { NM_NACK_MSGTYPE_INVAL, "Invalid message type value" },
[NM_NACK_OBJCLASS_INVAL] = "Invalid Object class value", { NM_NACK_OBJCLASS_INVAL, "Invalid Object class value" },
[NM_NACK_OBJCLASS_NOTSUPP] = "Object class not supported", { NM_NACK_OBJCLASS_NOTSUPP, "Object class not supported" },
[NM_NACK_BTSNR_UNKN] = "BTS no. unknown", { NM_NACK_BTSNR_UNKN, "BTS no. unknown" },
[NM_NACK_TRXNR_UNKN] = "Baseband Transceiver no. unknown", { NM_NACK_TRXNR_UNKN, "Baseband Transceiver no. unknown" },
[NM_NACK_OBJINST_UNKN] = "Object Instance unknown", { NM_NACK_OBJINST_UNKN, "Object Instance unknown" },
[NM_NACK_ATTRID_INVAL] = "Invalid attribute identifier value", { NM_NACK_ATTRID_INVAL, "Invalid attribute identifier value" },
[NM_NACK_ATTRID_NOTSUPP] = "Attribute identifier not supported", { NM_NACK_ATTRID_NOTSUPP, "Attribute identifier not supported" },
[NM_NACK_PARAM_RANGE] = "Parameter value outside permitted range", { NM_NACK_PARAM_RANGE, "Parameter value outside permitted range" },
[NM_NACK_ATTRLIST_INCONSISTENT] = "Inconsistency in attribute list", { NM_NACK_ATTRLIST_INCONSISTENT,"Inconsistency in attribute list" },
[NM_NACK_SPEC_IMPL_NOTSUPP] = "Specified implementation not supported", { NM_NACK_SPEC_IMPL_NOTSUPP, "Specified implementation not supported" },
[NM_NACK_CANT_PERFORM] = "Message cannot be performed", { NM_NACK_CANT_PERFORM, "Message cannot be performed" },
/* Specific Nack Causes */ /* Specific Nack Causes */
[NM_NACK_RES_NOTIMPL] = "Resource not implemented", { NM_NACK_RES_NOTIMPL, "Resource not implemented" },
[NM_NACK_RES_NOTAVAIL] = "Resource not available", { NM_NACK_RES_NOTAVAIL, "Resource not available" },
[NM_NACK_FREQ_NOTAVAIL] = "Frequency not available", { NM_NACK_FREQ_NOTAVAIL, "Frequency not available" },
[NM_NACK_TEST_NOTSUPP] = "Test not supported", { NM_NACK_TEST_NOTSUPP, "Test not supported" },
[NM_NACK_CAPACITY_RESTR] = "Capacity restrictions", { NM_NACK_CAPACITY_RESTR, "Capacity restrictions" },
[NM_NACK_PHYSCFG_NOTPERFORM] = "Physical configuration cannot be performed", { NM_NACK_PHYSCFG_NOTPERFORM, "Physical configuration cannot be performed" },
[NM_NACK_TEST_NOTINIT] = "Test not initiated", { NM_NACK_TEST_NOTINIT, "Test not initiated" },
[NM_NACK_PHYSCFG_NOTRESTORE] = "Physical configuration cannot be restored", { NM_NACK_PHYSCFG_NOTRESTORE, "Physical configuration cannot be restored" },
[NM_NACK_TEST_NOSUCH] = "No such test", { NM_NACK_TEST_NOSUCH, "No such test" },
[NM_NACK_TEST_NOSTOP] = "Test cannot be stopped", { NM_NACK_TEST_NOSTOP, "Test cannot be stopped" },
[NM_NACK_MSGINCONSIST_PHYSCFG] = "Message inconsistent with physical configuration", { NM_NACK_MSGINCONSIST_PHYSCFG, "Message inconsistent with physical configuration" },
[NM_NACK_FILE_INCOMPLETE] = "Complete file notreceived", { NM_NACK_FILE_INCOMPLETE, "Complete file notreceived" },
[NM_NACK_FILE_NOTAVAIL] = "File not available at destination", { NM_NACK_FILE_NOTAVAIL, "File not available at destination" },
[NM_NACK_FILE_NOTACTIVATE] = "File cannot be activate", { NM_NACK_FILE_NOTACTIVATE, "File cannot be activate" },
[NM_NACK_REQ_NOT_GRANT] = "Request not granted", { NM_NACK_REQ_NOT_GRANT, "Request not granted" },
[NM_NACK_WAIT] = "Wait", { NM_NACK_WAIT, "Wait" },
[NM_NACK_NOTH_REPORT_EXIST] = "Nothing reportable existing", { NM_NACK_NOTH_REPORT_EXIST, "Nothing reportable existing" },
[NM_NACK_MEAS_NOTSUPP] = "Measurement not supported", { NM_NACK_MEAS_NOTSUPP, "Measurement not supported" },
[NM_NACK_MEAS_NOTSTART] = "Measurement not started", { NM_NACK_MEAS_NOTSTART, "Measurement not started" },
{ 0, NULL }
}; };
static char namebuf[255];
static const char *nack_cause_name(u_int8_t cause) static const char *nack_cause_name(u_int8_t cause)
{ {
if (cause < ARRAY_SIZE(nack_cause_names) && nack_cause_names[cause]) return get_value_string(nack_cause_names, cause);
return nack_cause_names[cause];
snprintf(namebuf, sizeof(namebuf), "0x%02x\n", cause);
return namebuf;
} }
/* Chapter 9.4.16: Event Type */ /* Chapter 9.4.16: Event Type */
static const char *event_type_names[] = { static const struct value_string event_type_names[] = {
[NM_EVT_COMM_FAIL] = "communication failure", { NM_EVT_COMM_FAIL, "communication failure" },
[NM_EVT_QOS_FAIL] = "quality of service failure", { NM_EVT_QOS_FAIL, "quality of service failure" },
[NM_EVT_PROC_FAIL] = "processing failure", { NM_EVT_PROC_FAIL, "processing failure" },
[NM_EVT_EQUIP_FAIL] = "equipment failure", { NM_EVT_EQUIP_FAIL, "equipment failure" },
[NM_EVT_ENV_FAIL] = "environment failure", { NM_EVT_ENV_FAIL, "environment failure" },
{ 0, NULL }
}; };
static const char *event_type_name(u_int8_t cause) static const char *event_type_name(u_int8_t cause)
{ {
if (cause < ARRAY_SIZE(event_type_names) && event_type_names[cause]) return get_value_string(event_type_names, cause);
return event_type_names[cause];
snprintf(namebuf, sizeof(namebuf), "0x%02x\n", cause);
return namebuf;
} }
/* Chapter 9.4.63: Perceived Severity */ /* Chapter 9.4.63: Perceived Severity */
static const char *severity_names[] = { static const struct value_string severity_names[] = {
[NM_SEVER_CEASED] = "failure ceased", { NM_SEVER_CEASED, "failure ceased" },
[NM_SEVER_CRITICAL] = "critical failure", { NM_SEVER_CRITICAL, "critical failure" },
[NM_SEVER_MAJOR] = "major failure", { NM_SEVER_MAJOR, "major failure" },
[NM_SEVER_MINOR] = "minor failure", { NM_SEVER_MINOR, "minor failure" },
[NM_SEVER_WARNING] = "warning level failure", { NM_SEVER_WARNING, "warning level failure" },
[NM_SEVER_INDETERMINATE] = "indeterminate failure", { NM_SEVER_INDETERMINATE, "indeterminate failure" },
{ 0, NULL }
}; };
static const char *severity_name(u_int8_t cause) static const char *severity_name(u_int8_t cause)
{ {
if (cause < ARRAY_SIZE(severity_names) && severity_names[cause]) return get_value_string(severity_names, cause);
return severity_names[cause];
snprintf(namebuf, sizeof(namebuf), "0x%02x\n", cause);
return namebuf;
} }
/* Attributes that the BSC can set, not only get, according to Section 9.4 */ /* Attributes that the BSC can set, not only get, according to Section 9.4 */
@ -427,46 +419,30 @@ int abis_nm_sendmsg(struct gsm_bts *bts, struct msgb *msg)
static int abis_nm_rcvmsg_sw(struct msgb *mb); static int abis_nm_rcvmsg_sw(struct msgb *mb);
static struct value_string obj_class_names[] = {
{ NM_OC_SITE_MANAGER, "SITE MANAGER" },
{ NM_OC_BTS, "BTS" },
{ NM_OC_RADIO_CARRIER, "RADIO CARRIER" },
{ NM_OC_BASEB_TRANSC, "BASEBAND TRANSCEIVER" },
{ NM_OC_CHANNEL, "CHANNEL" },
{ NM_OC_BS11_ADJC, "ADJC" },
{ NM_OC_BS11_HANDOVER, "HANDOVER" },
{ NM_OC_BS11_PWR_CTRL, "POWER CONTROL" },
{ NM_OC_BS11_BTSE, "BTSE" },
{ NM_OC_BS11_RACK, "RACK" },
{ NM_OC_BS11_TEST, "TEST" },
{ NM_OC_BS11_ENVABTSE, "ENVABTSE" },
{ NM_OC_BS11_BPORT, "BPORT" },
{ NM_OC_GPRS_NSE, "GPRS NSE" },
{ NM_OC_GPRS_CELL, "GPRS CELL" },
{ NM_OC_GPRS_NSVC, "GPRS NSVC" },
{ NM_OC_BS11, "SIEMENSHW" },
{ 0, NULL }
};
static const char *obj_class_name(u_int8_t oc) static const char *obj_class_name(u_int8_t oc)
{ {
switch (oc) { return get_value_string(obj_class_names, oc);
case NM_OC_SITE_MANAGER:
return "SITE MANAGER";
case NM_OC_BTS:
return "BTS";
case NM_OC_RADIO_CARRIER:
return "RADIO CARRIER";
case NM_OC_BASEB_TRANSC:
return "BASEBAND TRANSCEIVER";
case NM_OC_CHANNEL:
return "CHANNEL";
case NM_OC_BS11_ADJC:
return "ADJC";
case NM_OC_BS11_HANDOVER:
return "HANDOVER";
case NM_OC_BS11_PWR_CTRL:
return "POWER CONTROL";
case NM_OC_BS11_BTSE:
return "BTSE";
case NM_OC_BS11_RACK:
return "RACK";
case NM_OC_BS11_TEST:
return "TEST";
case NM_OC_BS11_ENVABTSE:
return "ENVABTSE";
case NM_OC_BS11_BPORT:
return "BPORT";
case NM_OC_GPRS_NSE:
return "GPRS NSE";
case NM_OC_GPRS_CELL:
return "GPRS CELL";
case NM_OC_GPRS_NSVC:
return "GPRS NSVC";
case NM_OC_BS11:
return "SIEMENSHW";
}
return "UNKNOWN";
} }
const char *nm_opstate_name(u_int8_t os) const char *nm_opstate_name(u_int8_t os)
@ -484,24 +460,22 @@ const char *nm_opstate_name(u_int8_t os)
} }
/* Chapter 9.4.7 */ /* Chapter 9.4.7 */
static const char *avail_names[] = { static const struct value_string avail_names[] = {
"In test", { 0, "In test" },
"Failed", { 1, "Failed" },
"Power off", { 2, "Power off" },
"Off line", { 3, "Off line" },
"<not used>", /* Not used */
"Dependency", { 5, "Dependency" },
"Degraded", { 6, "Degraded" },
"Not installed", { 7, "Not installed" },
{ 0xff, "OK" },
{ 0, NULL }
}; };
const char *nm_avail_name(u_int8_t avail) const char *nm_avail_name(u_int8_t avail)
{ {
if (avail == 0xff) return get_value_string(avail_names, avail);
return "OK";
if (avail >= ARRAY_SIZE(avail_names))
return "UNKNOWN";
return avail_names[avail];
} }
static struct value_string test_names[] = { static struct value_string test_names[] = {
@ -960,11 +934,7 @@ static int abis_nm_rcvmsg_fom(struct msgb *mb)
debugp_foh(foh); debugp_foh(foh);
if (nack_names[mt]) DEBUGPC(DNM, "%s NACK ", get_value_string(nack_names, mt));
DEBUGPC(DNM, "%s NACK ", nack_names[mt]);
/* FIXME: NACK cause */
else
DEBUGPC(DNM, "NACK 0x%02x ", mt);
abis_nm_tlv_parse(&tp, mb->trx->bts, foh->data, oh->length-sizeof(*foh)); abis_nm_tlv_parse(&tp, mb->trx->bts, foh->data, oh->length-sizeof(*foh));
if (TLVP_PRESENT(&tp, NM_ATT_NACK_CAUSES)) if (TLVP_PRESENT(&tp, NM_ATT_NACK_CAUSES))
@ -2894,21 +2864,18 @@ void gsm_trx_lock_rf(struct gsm_bts_trx *trx, int locked)
new_state); new_state);
} }
static const char *ipacc_testres_names[] = { static const struct value_string ipacc_testres_names[] = {
[NM_IPACC_TESTRES_SUCCESS] = "SUCCESS", { NM_IPACC_TESTRES_SUCCESS, "SUCCESS" },
[NM_IPACC_TESTRES_TIMEOUT] = "TIMEOUT", { NM_IPACC_TESTRES_TIMEOUT, "TIMEOUT" },
[NM_IPACC_TESTRES_NO_CHANS] = "NO CHANNELS", { NM_IPACC_TESTRES_NO_CHANS, "NO CHANNELS" },
[NM_IPACC_TESTRES_PARTIAL] = "PARTIAL", { NM_IPACC_TESTRES_PARTIAL, "PARTIAL" },
[NM_IPACC_TESTRES_STOPPED] = "STOPPED", { NM_IPACC_TESTRES_STOPPED, "STOPPED" },
{ 0, NULL }
}; };
const char *ipacc_testres_name(u_int8_t res) const char *ipacc_testres_name(u_int8_t res)
{ {
if (res < ARRAY_SIZE(ipacc_testres_names) && return get_value_string(ipacc_testres_names, res);
ipacc_testres_names[res])
return ipacc_testres_names[res];
return "unknown";
} }
void ipac_parse_cgi(struct cell_global_id *cid, const u_int8_t *buf) void ipac_parse_cgi(struct cell_global_id *cid, const u_int8_t *buf)

135
openbsc/src/gsm_data.c
View File

@ -45,52 +45,41 @@ void set_ts_e1link(struct gsm_bts_trx_ts *ts, u_int8_t e1_nr,
ts->e1_link.e1_ts_ss = e1_ts_ss; ts->e1_link.e1_ts_ss = e1_ts_ss;
} }
static const char *pchan_names[] = { static const struct value_string pchan_names[] = {
[GSM_PCHAN_NONE] = "NONE", { GSM_PCHAN_NONE, "NONE" },
[GSM_PCHAN_CCCH] = "CCCH", { GSM_PCHAN_CCCH, "CCCH" },
[GSM_PCHAN_CCCH_SDCCH4] = "CCCH+SDCCH4", { GSM_PCHAN_CCCH_SDCCH4,"CCCH+SDCCH4" },
[GSM_PCHAN_TCH_F] = "TCH/F", { GSM_PCHAN_TCH_F, "TCH/F" },
[GSM_PCHAN_TCH_H] = "TCH/H", { GSM_PCHAN_TCH_H, "TCH/H" },
[GSM_PCHAN_SDCCH8_SACCH8C] = "SDCCH8", { GSM_PCHAN_SDCCH8_SACCH8C, "SDCCH8" },
[GSM_PCHAN_PDCH] = "PDCH", { GSM_PCHAN_PDCH, "PDCH" },
[GSM_PCHAN_TCH_F_PDCH] = "TCH/F_PDCH", { GSM_PCHAN_TCH_F_PDCH, "TCH/F_PDCH" },
[GSM_PCHAN_UNKNOWN] = "UNKNOWN", { GSM_PCHAN_UNKNOWN, "UNKNOWN" },
{ 0, NULL }
}; };
const char *gsm_pchan_name(enum gsm_phys_chan_config c) const char *gsm_pchan_name(enum gsm_phys_chan_config c)
{ {
if (c >= ARRAY_SIZE(pchan_names)) return get_value_string(pchan_names, c);
return "INVALID";
return pchan_names[c];
} }
enum gsm_phys_chan_config gsm_pchan_parse(const char *name) enum gsm_phys_chan_config gsm_pchan_parse(const char *name)
{ {
int i; return get_string_value(pchan_names, name);
for (i = 0; i < ARRAY_SIZE(pchan_names); i++) {
if (!strcasecmp(name, pchan_names[i]))
return i;
}
return -1;
} }
static const char *lchan_names[] = { static const struct value_string lchant_names[] = {
[GSM_LCHAN_NONE] = "NONE", { GSM_LCHAN_NONE, "NONE" },
[GSM_LCHAN_SDCCH] = "SDCCH", { GSM_LCHAN_SDCCH, "SDCCH" },
[GSM_LCHAN_TCH_F] = "TCH/F", { GSM_LCHAN_TCH_F, "TCH/F" },
[GSM_LCHAN_TCH_H] = "TCH/H", { GSM_LCHAN_TCH_H, "TCH/H" },
[GSM_LCHAN_UNKNOWN] = "UNKNOWN", { GSM_LCHAN_UNKNOWN, "UNKNOWN" },
{ 0, NULL }
}; };
const char *gsm_lchant_name(enum gsm_chan_t c) const char *gsm_lchant_name(enum gsm_chan_t c)
{ {
if (c >= ARRAY_SIZE(lchan_names)) return get_value_string(lchant_names, c);
return "INVALID";
return lchan_names[c];
} }
static const struct value_string lchan_s_names[] = { static const struct value_string lchan_s_names[] = {
@ -99,7 +88,7 @@ static const struct value_string lchan_s_names[] = {
{ LCHAN_S_ACTIVE, "ACTIVE" }, { LCHAN_S_ACTIVE, "ACTIVE" },
{ LCHAN_S_INACTIVE, "INACTIVE" }, { LCHAN_S_INACTIVE, "INACTIVE" },
{ LCHAN_S_REL_REQ, "RELEASE REQUESTED" }, { LCHAN_S_REL_REQ, "RELEASE REQUESTED" },
{ 0, NULL }, { 0, NULL }
}; };
const char *gsm_lchans_name(enum gsm_lchan_state s) const char *gsm_lchans_name(enum gsm_lchan_state s)
@ -107,20 +96,18 @@ const char *gsm_lchans_name(enum gsm_lchan_state s)
return get_value_string(lchan_s_names, s); return get_value_string(lchan_s_names, s);
} }
static const char *chreq_names[] = { static const struct value_string chreq_names[] = {
[GSM_CHREQ_REASON_EMERG] = "EMERGENCY", { GSM_CHREQ_REASON_EMERG, "EMERGENCY" },
[GSM_CHREQ_REASON_PAG] = "PAGING", { GSM_CHREQ_REASON_PAG, "PAGING" },
[GSM_CHREQ_REASON_CALL] = "CALL", { GSM_CHREQ_REASON_CALL, "CALL" },
[GSM_CHREQ_REASON_LOCATION_UPD] = "LOCATION_UPDATE", { GSM_CHREQ_REASON_LOCATION_UPD,"LOCATION_UPDATE" },
[GSM_CHREQ_REASON_OTHER] = "OTHER", { GSM_CHREQ_REASON_OTHER, "OTHER" },
{ 0, NULL }
}; };
const char *gsm_chreq_name(enum gsm_chreq_reason_t c) const char *gsm_chreq_name(enum gsm_chreq_reason_t c)
{ {
if (c >= ARRAY_SIZE(chreq_names)) return get_value_string(chreq_names, c);
return "INVALID";
return chreq_names[c];
} }
static struct gsm_bts_model *bts_model_find(enum gsm_bts_type type) static struct gsm_bts_model *bts_model_find(enum gsm_bts_type type)
@ -377,27 +364,21 @@ char *gsm_lchan_name(struct gsm_lchan *lchan)
return ts2str; return ts2str;
} }
static const char *bts_types[] = { static const struct value_string bts_types[] = {
[GSM_BTS_TYPE_UNKNOWN] = "unknown", { GSM_BTS_TYPE_UNKNOWN, "unknown" },
[GSM_BTS_TYPE_BS11] = "bs11", { GSM_BTS_TYPE_BS11, "bs11" },
[GSM_BTS_TYPE_NANOBTS] = "nanobts", { GSM_BTS_TYPE_NANOBTS, "nanobts" },
{ 0, NULL }
}; };
enum gsm_bts_type parse_btstype(const char *arg) enum gsm_bts_type parse_btstype(const char *arg)
{ {
int i; return get_string_value(bts_types, arg);
for (i = 0; i < ARRAY_SIZE(bts_types); i++) {
if (!strcmp(arg, bts_types[i]))
return i;
}
return GSM_BTS_TYPE_BS11; /* Default: BS11 */
} }
const char *btstype2str(enum gsm_bts_type type) const char *btstype2str(enum gsm_bts_type type)
{ {
if (type > ARRAY_SIZE(bts_types)) return get_value_string(bts_types, type);
return "undefined";
return bts_types[type];
} }
struct gsm_bts_trx *gsm_bts_trx_by_nr(struct gsm_bts *bts, int nr) struct gsm_bts_trx *gsm_bts_trx_by_nr(struct gsm_bts *bts, int nr)
@ -438,27 +419,21 @@ struct gsm_bts *gsm_bts_by_lac(struct gsm_network *net, unsigned int lac,
return NULL; return NULL;
} }
static const char *gsm_auth_policy_names[] = { static const struct value_string auth_policy_names[] = {
[GSM_AUTH_POLICY_CLOSED] = "closed", { GSM_AUTH_POLICY_CLOSED, "closed" },
[GSM_AUTH_POLICY_ACCEPT_ALL] = "accept-all", { GSM_AUTH_POLICY_ACCEPT_ALL, "accept-all" },
[GSM_AUTH_POLICY_TOKEN] = "token", { GSM_AUTH_POLICY_TOKEN, "token" },
{ 0, NULL }
}; };
enum gsm_auth_policy gsm_auth_policy_parse(const char *arg) enum gsm_auth_policy gsm_auth_policy_parse(const char *arg)
{ {
int i; return get_string_value(auth_policy_names, arg);
for (i = 0; i < ARRAY_SIZE(gsm_auth_policy_names); i++) {
if (!strcmp(arg, gsm_auth_policy_names[i]))
return i;
}
return GSM_AUTH_POLICY_CLOSED;
} }
const char *gsm_auth_policy_name(enum gsm_auth_policy policy) const char *gsm_auth_policy_name(enum gsm_auth_policy policy)
{ {
if (policy > ARRAY_SIZE(gsm_auth_policy_names)) return get_value_string(auth_policy_names, policy);
return "undefined";
return gsm_auth_policy_names[policy];
} }
/* this should not be here but in gsm_04_08... but that creates /* this should not be here but in gsm_04_08... but that creates
@ -505,28 +480,22 @@ int gsm48_ra_id_by_bts(u_int8_t *buf, struct gsm_bts *bts)
return gsm48_construct_ra(buf, &raid); return gsm48_construct_ra(buf, &raid);
} }
static const char *rrlp_mode_names[] = { static const struct value_string rrlp_mode_names[] = {
[RRLP_MODE_NONE] = "none", { RRLP_MODE_NONE, "none" },
[RRLP_MODE_MS_BASED] = "ms-based", { RRLP_MODE_MS_BASED, "ms-based" },
[RRLP_MODE_MS_PREF] = "ms-preferred", { RRLP_MODE_MS_PREF, "ms-preferred" },
[RRLP_MODE_ASS_PREF] = "ass-preferred", { RRLP_MODE_ASS_PREF, "ass-preferred" },
{ 0, NULL }
}; };
enum rrlp_mode rrlp_mode_parse(const char *arg) enum rrlp_mode rrlp_mode_parse(const char *arg)
{ {
int i; return get_string_value(rrlp_mode_names, arg);
for (i = 0; i < ARRAY_SIZE(rrlp_mode_names); i++) {
if (!strcmp(arg, rrlp_mode_names[i]))
return i;
}
return RRLP_MODE_NONE;
} }
const char *rrlp_mode_name(enum rrlp_mode mode) const char *rrlp_mode_name(enum rrlp_mode mode)
{ {
if (mode > ARRAY_SIZE(rrlp_mode_names)) return get_value_string(rrlp_mode_names, mode);
return "none";
return rrlp_mode_names[mode];
} }
struct gsm_meas_rep *lchan_next_meas_rep(struct gsm_lchan *lchan) struct gsm_meas_rep *lchan_next_meas_rep(struct gsm_lchan *lchan)