/*ARGSUSED*/
static void
print_evlog(smbios_hdl_t *shp, id_t id, FILE *fp)
{
smbios_evlog_t ev;
uint32_t i;
(void) smbios_info_eventlog(shp, &ev);
oprintf(fp, " Log Area Size: %lu bytes\n", (ulong_t)ev.smbev_size);
oprintf(fp, " Header Offset: %lu\n", (ulong_t)ev.smbev_hdr);
oprintf(fp, " Data Offset: %lu\n", (ulong_t)ev.smbev_data);
desc_printf(smbios_evlog_method_desc(ev.smbev_method),
fp, " Data Access Method: %u", ev.smbev_method);
flag_printf(fp, "Log Flags",
ev.smbev_flags, sizeof (ev.smbev_flags) * NBBY,
smbios_evlog_flag_name, smbios_evlog_flag_desc);
desc_printf(smbios_evlog_format_desc(ev.smbev_format),
fp, " Log Header Format: %u", ev.smbev_format);
oprintf(fp, " Update Token: 0x%x\n", ev.smbev_token);
oprintf(fp, " Data Access Address: ");
switch (ev.smbev_method) {
case SMB_EVM_1x1i_1x1d:
case SMB_EVM_2x1i_1x1d:
case SMB_EVM_1x2i_1x1d:
oprintf(fp, "Index Address 0x%x, Data Address 0x%x\n",
ev.smbev_addr.eva_io.evi_iaddr,
ev.smbev_addr.eva_io.evi_daddr);
break;
case SMB_EVM_GPNV:
oprintf(fp, "0x%x\n", ev.smbev_addr.eva_gpnv);
break;
default:
oprintf(fp, "0x%x\n", ev.smbev_addr.eva_addr);
}
oprintf(fp, " Type Descriptors:\n");
for (i = 0; i < ev.smbev_typec; i++) {
oprintf(fp, " %u: Log Type 0x%x, Data Type 0x%x\n", i,
ev.smbev_typev[i].smbevt_ltype,
ev.smbev_typev[i].smbevt_dtype);
}
}
static void
print_hwsec(smbios_hdl_t *shp, FILE *fp)
{
smbios_hwsec_t h;
(void) smbios_info_hwsec(shp, &h);
desc_printf(smbios_hwsec_desc(h.smbh_pwr_ps),
fp, " Power-On Password Status: %u", h.smbh_pwr_ps);
desc_printf(smbios_hwsec_desc(h.smbh_kbd_ps),
fp, " Keyboard Password Status: %u", h.smbh_kbd_ps);
desc_printf(smbios_hwsec_desc(h.smbh_adm_ps),
fp, " Administrator Password Status: %u", h.smbh_adm_ps);
desc_printf(smbios_hwsec_desc(h.smbh_pan_ps),
fp, " Front Panel Reset Status: %u", h.smbh_pan_ps);
}
static void
print_bboard(smbios_hdl_t *shp, id_t id, FILE *fp)
{
smbios_bboard_t b;
int chdl_cnt;
(void) smbios_info_bboard(shp, id, &b);
oprintf(fp, " Chassis: %u\n", (uint_t)b.smbb_chassis);
flag_printf(fp, "Flags", b.smbb_flags, sizeof (b.smbb_flags) * NBBY,
smbios_bboard_flag_name, smbios_bboard_flag_desc);
desc_printf(smbios_bboard_type_desc(b.smbb_type),
fp, " Board Type: 0x%x", b.smbb_type);
chdl_cnt = b.smbb_contn;
if (chdl_cnt != 0) {
id_t *chdl;
uint16_t hdl;
int i, n, cnt;
chdl = alloca(chdl_cnt * sizeof (id_t));
cnt = smbios_info_contains(shp, id, chdl_cnt, chdl);
if (cnt > SMB_CONT_MAX)
return;
n = MIN(chdl_cnt, cnt);
oprintf(fp, "\n");
for (i = 0; i < n; i++) {
hdl = (uint16_t)chdl[i];
oprintf(fp, " Contained Handle: %u\n", hdl);
}
}
}
static void
print_port(smbios_hdl_t *shp, id_t id, FILE *fp)
{
smbios_port_t p;
(void) smbios_info_port(shp, id, &p);
oprintf(fp, " Internal Reference Designator: %s\n", p.smbo_iref);
oprintf(fp, " External Reference Designator: %s\n", p.smbo_eref);
desc_printf(smbios_port_conn_desc(p.smbo_itype),
fp, " Internal Connector Type: %u", p.smbo_itype);
desc_printf(smbios_port_conn_desc(p.smbo_etype),
fp, " External Connector Type: %u", p.smbo_etype);
desc_printf(smbios_port_type_desc(p.smbo_ptype),
fp, " Port Type: %u", p.smbo_ptype);
}
static void
flag_printf(FILE *fp, const char *s, uint_t flags, size_t bits,
const char *(*flag_name)(uint_t), const char *(*flag_desc)(uint_t))
{
size_t i;
oprintf(fp, " %s: 0x%x\n", s, flags);
for (i = 0; i < bits; i++) {
uint_t f = 1 << i;
const char *n;
if (!(flags & f))
continue;
if ((n = flag_name(f)) != NULL)
desc_printf(flag_desc(f), fp, "\t%s", n);
else
desc_printf(flag_desc(f), fp, "\t0x%x", f);
}
}
static void
print_memarray(smbios_hdl_t *shp, id_t id, FILE *fp)
{
smbios_memarray_t ma;
(void) smbios_info_memarray(shp, id, &ma);
desc_printf(smbios_memarray_loc_desc(ma.smbma_location),
fp, " Location: %u", ma.smbma_location);
desc_printf(smbios_memarray_use_desc(ma.smbma_use),
fp, " Use: %u", ma.smbma_use);
desc_printf(smbios_memarray_ecc_desc(ma.smbma_ecc),
fp, " ECC: %u", ma.smbma_ecc);
oprintf(fp, " Number of Slots/Sockets: %u\n", ma.smbma_ndevs);
id_printf(fp, " Memory Error Data: ", ma.smbma_err);
oprintf(fp, " Max Capacity: %llu bytes\n",
(u_longlong_t)ma.smbma_size);
}
static void
print_slot(smbios_hdl_t *shp, id_t id, FILE *fp)
{
smbios_slot_t s;
smbios_entry_t e;
(void) smbios_info_slot(shp, id, &s);
(void) smbios_info_smbios(shp, &e);
oprintf(fp, " Reference Designator: %s\n", s.smbl_name);
oprintf(fp, " Slot ID: 0x%x\n", s.smbl_id);
desc_printf(smbios_slot_type_desc(s.smbl_type),
fp, " Type: 0x%x", s.smbl_type);
desc_printf(smbios_slot_width_desc(s.smbl_width),
fp, " Width: 0x%x", s.smbl_width);
desc_printf(smbios_slot_usage_desc(s.smbl_usage),
fp, " Usage: 0x%x", s.smbl_usage);
desc_printf(smbios_slot_length_desc(s.smbl_length),
fp, " Length: 0x%x", s.smbl_length);
flag_printf(fp, "Slot Characteristics 1",
s.smbl_ch1, sizeof (s.smbl_ch1) * NBBY,
smbios_slot_ch1_name, smbios_slot_ch1_desc);
flag_printf(fp, "Slot Characteristics 2",
s.smbl_ch2, sizeof (s.smbl_ch2) * NBBY,
smbios_slot_ch2_name, smbios_slot_ch2_desc);
if (check_oem(shp) != 0 && (e.smbe_major < 2 || e.smbe_minor < 6))
return;
oprintf(fp, " Segment Group: %u\n", s.smbl_sg);
oprintf(fp, " Bus Number: %u\n", s.smbl_bus);
oprintf(fp, " Device/Function Number: %u\n", s.smbl_df);
}
static void
print_chassis(smbios_hdl_t *shp, id_t id, FILE *fp)
{
smbios_chassis_t c;
int elem_cnt;
(void) smbios_info_chassis(shp, id, &c);
oprintf(fp, " OEM Data: 0x%x\n", c.smbc_oemdata);
oprintf(fp, " SKU number: %s\n",
c.smbc_sku == NULL ? "<unknown>" : c.smbc_sku);
oprintf(fp, " Lock Present: %s\n", c.smbc_lock ? "Y" : "N");
desc_printf(smbios_chassis_type_desc(c.smbc_type),
fp, " Chassis Type: 0x%x", c.smbc_type);
desc_printf(smbios_chassis_state_desc(c.smbc_bustate),
fp, " Boot-Up State: 0x%x", c.smbc_bustate);
desc_printf(smbios_chassis_state_desc(c.smbc_psstate),
fp, " Power Supply State: 0x%x", c.smbc_psstate);
desc_printf(smbios_chassis_state_desc(c.smbc_thstate),
fp, " Thermal State: 0x%x", c.smbc_thstate);
oprintf(fp, " Chassis Height: %uu\n", c.smbc_uheight);
oprintf(fp, " Power Cords: %u\n", c.smbc_cords);
elem_cnt = c.smbc_elems;
oprintf(fp, " Element Records: %u\n", elem_cnt);
if (elem_cnt > 0) {
id_t *elems;
uint8_t type;
int i, n, cnt;
elems = alloca(c.smbc_elems * sizeof (id_t));
cnt = smbios_info_contains(shp, id, elem_cnt, elems);
if (cnt > SMB_CONT_MAX)
return;
n = MIN(elem_cnt, cnt);
oprintf(fp, "\n");
for (i = 0; i < n; i++) {
type = (uint8_t)elems[i];
if (type & 0x80) {
/* SMBIOS structrure Type */
desc_printf(smbios_type_name(type & 0x7f), fp,
" Contained SMBIOS structure Type: %u",
type & 0x80);
} else {
/* SMBIOS Base Board Type */
desc_printf(smbios_bboard_type_desc(type), fp,
" Contained SMBIOS Base Board Type: 0x%x",
type);
}
}
}
}
static void
print_boot(smbios_hdl_t *shp, FILE *fp)
{
smbios_boot_t b;
(void) smbios_info_boot(shp, &b);
desc_printf(smbios_boot_desc(b.smbt_status),
fp, " Boot Status Code: 0x%x", b.smbt_status);
if (b.smbt_size != 0) {
oprintf(fp, " Boot Data (%lu bytes):\n", (ulong_t)b.smbt_size);
print_bytes(b.smbt_data, b.smbt_size, fp);
}
}
static void
print_ipmi(smbios_hdl_t *shp, FILE *fp)
{
smbios_ipmi_t i;
(void) smbios_info_ipmi(shp, &i);
desc_printf(smbios_ipmi_type_desc(i.smbip_type),
fp, " Type: %u", i.smbip_type);
oprintf(fp, " BMC IPMI Version: %u.%u\n",
i.smbip_vers.smbv_major, i.smbip_vers.smbv_minor);
oprintf(fp, " i2c Bus Slave Address: 0x%x\n", i.smbip_i2c);
oprintf(fp, " NV Storage Device Bus ID: 0x%x\n", i.smbip_bus);
oprintf(fp, " BMC Base Address: 0x%llx\n", (u_longlong_t)i.smbip_addr);
oprintf(fp, " Interrupt Number: %u\n", i.smbip_intr);
oprintf(fp, " Register Spacing: %u\n", i.smbip_regspacing);
flag_printf(fp, "Flags", i.smbip_flags, sizeof (i.smbip_flags) * NBBY,
smbios_ipmi_flag_name, smbios_ipmi_flag_desc);
}
static void
print_system(smbios_hdl_t *shp, FILE *fp)
{
smbios_system_t s;
uint_t i;
(void) smbios_info_system(shp, &s);
oprintf(fp, " UUID: ");
for (i = 0; i < s.smbs_uuidlen; i++) {
oprintf(fp, "%02x", s.smbs_uuid[i]);
if (i == 3 || i == 5 || i == 7 || i == 9)
oprintf(fp, "-");
}
oprintf(fp, "\n");
desc_printf(smbios_system_wakeup_desc(s.smbs_wakeup),
fp, " Wake-Up Event: 0x%x", s.smbs_wakeup);
oprintf(fp, " SKU Number: %s\n", s.smbs_sku);
oprintf(fp, " Family: %s\n", s.smbs_family);
}
static void
print_cache(smbios_hdl_t *shp, id_t id, FILE *fp)
{
smbios_cache_t c;
(void) smbios_info_cache(shp, id, &c);
oprintf(fp, " Level: %u\n", c.smba_level);
oprintf(fp, " Maximum Installed Size: %u bytes\n", c.smba_maxsize);
if (c.smba_size != 0)
oprintf(fp, " Installed Size: %u bytes\n", c.smba_size);
else
oprintf(fp, " Installed Size: Not Installed\n");
if (c.smba_speed != 0)
oprintf(fp, " Speed: %uns\n", c.smba_speed);
else
oprintf(fp, " Speed: Unknown\n");
flag_printf(fp, "Supported SRAM Types",
c.smba_stype, sizeof (c.smba_stype) * NBBY,
smbios_cache_ctype_name, smbios_cache_ctype_desc);
desc_printf(smbios_cache_ctype_desc(c.smba_ctype),
fp, " Current SRAM Type: 0x%x", c.smba_ctype);
desc_printf(smbios_cache_ecc_desc(c.smba_etype),
fp, " Error Correction Type: %u", c.smba_etype);
desc_printf(smbios_cache_logical_desc(c.smba_ltype),
fp, " Logical Cache Type: %u", c.smba_ltype);
desc_printf(smbios_cache_assoc_desc(c.smba_assoc),
fp, " Associativity: %u", c.smba_assoc);
desc_printf(smbios_cache_mode_desc(c.smba_mode),
fp, " Mode: %u", c.smba_mode);
desc_printf(smbios_cache_loc_desc(c.smba_location),
fp, " Location: %u", c.smba_location);
flag_printf(fp, "Flags", c.smba_flags, sizeof (c.smba_flags) * NBBY,
smbios_cache_flag_name, smbios_cache_flag_desc);
}
int _script_builtin_function(char *var, char *fn, char *args)
{
int ret = 0;
struct timespec ts;
struct timespec tse;
if (_perf_measure)
ts = utils_get_time( TIME_CURRENT );
if (strcmp(fn, "set_all_variables_overwritable") == 0) {
if (args != NULL) {
int var = get_boolean(args);
if ((var == 0) || (var == 1))
variable_allow_overwrite(NULL, var);
else
desc_printf(gIO, gFd, "Invalid value for %s(): %s\n",
fn, args);
}
}
else
if (strcmp(fn, "get_all_variables_overwritable") == 0) {
if (var != NULL) {
char tmp[4] = { 0 };
snprintf(tmp, sizeof(tmp), "%d", variable_get_overwrite(NULL));
variable_add(var, tmp, TYPE_QSCRIPT, -1, TYPE_INT);
}
else
desc_printf(gIO, gFd, "All variables overwritable: %s\n",
(variable_get_overwrite(NULL) == 1) ? "true" : "false");
}
else
if (strcmp(fn, "set_variable_overwritable") == 0) {
tTokenizer t;
t = tokenize(args, ",");
if (t.numTokens == 2)
variable_allow_overwrite(trim(t.tokens[0]), get_boolean(t.tokens[1]));
else
desc_printf(gIO, gFd, "Syntax: set_variable_overwritable(variable, true|false)\n");
free_tokens(t);
}
else
if (strcmp(fn, "get_variable_overwritable") == 0) {
char tmp[4] = { 0 };
if ((args != NULL) && (strlen(args) > 0))
{
snprintf(tmp, sizeof(tmp), "%d", variable_get_overwrite(args));
if (var != NULL)
variable_add(var, tmp, TYPE_QSCRIPT, -1, TYPE_INT);
else
desc_printf(gIO, gFd, "Variable %s overwritable: %s\n",
args, (strcmp(tmp, "1") == 0) ? "true" :
((strcmp(tmp, "0") == 0) ? "false" : "not found"));
}
else
desc_printf(gIO, gFd, "Variable name is missing\n");
}
else
if (strcmp(fn, "enable_perf") == 0) {
int enable = get_boolean(args);
if ((enable == 0) || (enable == 1)) {
DPRINTF("%sabling performance measuring\n", enable ? "En" : "Dis");
_perf_measure = enable;
}
else
DPRINTF("Incorrect setting for performace measuring: %d\n", enable);
if (_perf_measure)
ts = utils_get_time( TIME_CURRENT );
}
else
if (strcmp(fn, "del") == 0) {
variable_set_deleted(args, 1);
}
else
if (strcmp(fn, "get") == 0) {
char *val = variable_get_element_as_string(args, "get");
if (val != NULL) {
DPRINTF("%s: Processing internal 'get' function for arguments: %s\n", __FUNCTION__, args);
DPRINTF("%s: Variable %s processed to %s\n", __FUNCTION__, var, val);
if (var != NULL)
variable_add(var, val, TYPE_QSCRIPT, -1, gettype(val));
}
}
else
if (strcmp(fn, "dumpvars") == NULL) {
desc_variable_dump(gIO, gFd, args);
}
else
if (strcmp(fn, "post") == 0) {
char *val = variable_get_element_as_string(args, "post");
if (val != NULL) {
DPRINTF("%s: Processing internal 'post' function for arguments: %s\n", __FUNCTION__, args);
DPRINTF("%s: Variable %s processed to %s\n", __FUNCTION__, var, val);
if (var != NULL)
variable_add(var, val, TYPE_QSCRIPT, -1, gettype(val));
}
}
else
if (strcmp(fn, "cookie") == 0) {
char *val = variable_get_element_as_string(args, "cookie");
if (val != NULL) {
DPRINTF("%s: Processing internal 'cookie' function for arguments: %s\n", __FUNCTION__, args);
DPRINTF("%s: Variable %s processed to %s\n", __FUNCTION__, var, val);
if (var != NULL)
variable_add(var, val, TYPE_QSCRIPT, -1, gettype(val));
}
}
else
if (strcmp(fn, "sleep") == 0) {
int num = atoi(args);
DPRINTF("%s: Sleeping for %d seconds...\n", __FUNCTION__, num);
sleep(num);
}
else
if (strcmp(fn, "dumptype") == 0) {
char *str = variable_get_type_string(args, "any");
desc_printf(gIO, gFd, "%s\n", str ? str : "<null>");
str = utils_free("scripting.dumptype.str", str);
}
else
if (strcmp(fn, "print") == 0) {
if (args != NULL) {
if ((args[0] == '"') || (args[0] == '\'')) {
*args++;
args[strlen(args) - 1] = 0;
args = replace(args, "\\n", "\n");
desc_printf(gIO, gFd, "%s", args);
}
else {
char *var = variable_get_element_as_string(args, NULL);
desc_printf(gIO, gFd, "%s", var ? var : "");
var = utils_free("scripting.print.var", var);
}
}
}
else
if (strcmp(fn, "printf") == 0) {
if ((args != NULL) && (strlen(args) > 0)) {
int i;
tTokenizer t;
*args++;
t = tokenize(args, "\"");
if (t.numTokens == 1) {
char *instr = NULL;
instr = strdup(t.tokens[0]);
while (strstr(instr, "\\n") != NULL)
instr = replace(instr, "\\n", "\n");
desc_printf(gIO, gFd, "%s", instr);
instr = utils_free("scripting.printf.instr", instr);
}
else
if (t.numTokens == 2) {
tTokenizer t2;
char *instr = NULL;
char *vars = NULL;
instr = strdup( t.tokens[0] );
vars = strdup( t.tokens[1] + 1 );
t2 = tokenize(vars, ",");
for (i = 0; i < t2.numTokens; i++) {
DPRINTF("%s: Replacing variable %s\n", __FUNCTION__, trim(t2.tokens[i]));
char *tmp = variable_get_element_as_string(trim(t2.tokens[i]), NULL);
if (tmp != NULL)
instr = replace(instr, "%s", tmp);
else {
instr = replace(instr, "%s", "NULL");
DPRINTF("%s: Variable \"%s\" not found\n", __FUNCTION__, trim(t2.tokens[i]));
}
}
while (strstr(instr, "\\n") != NULL)
instr = replace(instr, "\\n", "\n");
desc_printf(gIO, gFd, "%s", instr);
free_tokens(t2);
}
else {
free_tokens(t);
ret = -EINVAL;
goto cleanup;
}
free_tokens(t);
}
else {
desc_printf(gIO, gFd, "Invalid syntax for printf()\n");
ret = -EINVAL;
goto cleanup;
}
}
else
if (strcmp(fn, "idb_dump_query_set") == 0) {
idb_results_show( gIO, gFd, idb_get_last_select_data() );
}
else
if (strcmp(fn, "idb_query") == 0) {
char *filename = NULL;
char *query = NULL;
tTokenizer t;
int i;
t = tokenize(args, "\"");
if (t.numTokens > 1) {
int num = 0;
for (i = 0; i < t.numTokens; i++) {
if (strcmp(trim(t.tokens[i]), ",") != 0) {
if (num == 0)
filename = strdup(t.tokens[i]);
else
if (num == 1)
query = strdup(t.tokens[i]);
num++;
}
}
}
free_tokens(t);
if (((filename == NULL) || (query == NULL)) && (args[0] == '@')) {
*args++;
DPRINTF("Reading query file '%s'\n", args);
if (access(args, R_OK) == 0) {
FILE *fp = NULL;
char buf[BUFSIZE];
fp = fopen(args, "r");
if (fp != NULL) {
int num = 0;
while (!feof(fp)) {
memset(buf, 0, sizeof(buf));
fgets(buf, sizeof(buf), fp);
if ((strlen(buf) > 0)
&& (buf[strlen(buf) - 1] == '\n'))
buf[strlen(buf) - 1] = 0;
if (strlen(buf) > 0) {
num++;
int ret = idb_query(buf);
desc_printf(gIO, gFd, "Query '%s' returned with code %d\n",
buf, ret);
}
}
desc_printf(gIO, gFd, "%d queries processed\n", num);
fclose(fp);
}
else
desc_printf(gIO, gFd, "Error: Cannot open file %s for reading\n",
args);
}
else
desc_printf(gIO, gFd, "Error: Cannot access file %s\n", t.tokens[1]);
}
else
if ((filename != NULL) && (query != NULL)) {
char tmp[4096] = { 0 };
snprintf(tmp, sizeof(tmp), "INIT %s", filename);
ret = 0;
if (idb_query(tmp) != 0) {
DPRINTF("Error while trying to initialize file '%s'\n", filename);
ret = -EIO;
}
if (idb_query(query) != 0) {
DPRINTF("Error while running query '%s'\n", query);
ret = -EIO;
}
else
if ((strncmp(query, "SELECT", 6) == 0) || (strcmp(query, "SHOW TABLES") == 0))
idb_results_show( gIO, gFd, idb_get_last_select_data() );
idb_query("COMMIT");
idb_query("CLOSE");
}
}
else {
ret = -EINVAL;
goto cleanup;
}
cleanup:
if (_perf_measure) {
tse = utils_get_time( TIME_CURRENT );
desc_printf(gIO, gFd, "\nPERF: Function %s() was running for %.3f microseconds (%.3f ms)\n",
fn, get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.);
}
return ret;
}
int script_process_line(char *buf)
{
int ret = -ENOTSUP;
struct timespec ts = { .tv_sec = 0, .tv_nsec = 0 };
struct timespec tse;
if (_perf_measure)
ts = utils_get_time( TIME_CURRENT );
/* Skip if it's a one line comment (more to be implemented) */
if (is_comment(buf) == 1) {
DPRINTF("%s: Found comment, skipping\n", __FUNCTION__);
ret = 0;
goto cleanup;
}
else
if (strcmp(buf, "else {") == 0) {
/* Reverse the condition */
if ((_script_in_condition_and_met == 1)
|| (_script_in_condition_and_met == -10))
_script_in_condition_and_met = 0;
else
if ((_script_in_condition_and_met == 0)
|| (_script_in_condition_and_met == -20))
_script_in_condition_and_met = 1;
else
if (_script_in_condition_and_met != -1) {
DPRINTF("%s: Invalid state for else statement\n", __FUNCTION__);
ret = -EINVAL;
goto cleanup;
}
ret = 0;
goto cleanup;
}
else
if (strcmp(buf, "}") == 0) {
_script_in_condition_and_met = (_script_in_condition_and_met == 1) ? -10 : -20;
ret = 0;
goto cleanup;
}
if (_script_in_condition_and_met < -1)
_script_in_condition_and_met = 1;
if (_script_in_condition_and_met == 0) {
ret = 0;
goto cleanup;
}
/* Comparison with no ternary operator support... yet */
if (regex_match("if \\(([^(]*)([^)]*)\\)", buf)) {
if (regex_match("if \\(([^(]*) == ([^)]*)\\) {", buf)) {
char **matches = NULL;
int i, num_matches;
matches = (char **)utils_alloc( "scripting.script_process_line.matches", sizeof(char *) );
_regex_match("if \\(([^(]*) == ([^)]*)\\) {", buf, matches, &num_matches);
if (num_matches >= 2)
_script_in_condition_and_met = (valcmp(matches[0], matches[1]) == 0) ? 1 : 0;
for (i = 0; i < num_matches; i++)
matches[i] = utils_free("scripting.condition.matches[]", matches[i]);
matches = utils_free("scripting.condition.matches", matches);
}
}
else
/* Definition */
if (strncmp(buf, "define ", 7) == 0) {
tTokenizer t;
t = tokenize(buf + 7, " ");
if (t.numTokens != 2) {
ret = -EINVAL;
goto cleanup;
}
if (variable_create(trim(t.tokens[0]), trim(t.tokens[1])) != 1) {
ret = -EIO;
goto cleanup;
}
}
else
/* Operators */
if ((strstr(buf, "+=") != NULL) || (strstr(buf, "-=") != NULL) ||
(strstr(buf, "%=") != NULL) || (strstr(buf, "*=") != NULL) ||
(strstr(buf, "/=") != NULL)) {
tTokenizer t;
char *var;
char *val;
int op, vtype;
t = tokenize(buf, "=");
if (t.numTokens != 2) {
ret = -EINVAL;
goto cleanup;
}
var = trim(strdup(t.tokens[0]));
val = trim(strdup(t.tokens[1]));
op = var[ strlen(var) - 1];
var[ strlen(var) - 1] = 0;
var = trim(var);
if (val[strlen(val) - 1] == ';')
val[strlen(val) - 1] = 0;
val = trim(val);
vtype = variable_get_type(var, NULL);
if ((vtype == TYPE_INT) || (vtype == TYPE_LONG)) {
char tmp[32] = { 0 };
long value = atol(variable_get_element_as_string(var, NULL));
if (op == '+')
value += atol(val);
else
if (op == '-')
value -= atol(val);
else
if (op == '*')
value *= atol(val);
else
if (op == '%')
value %= atol(val);
else
if (op == '/')
value /= atol(val);
snprintf(tmp, sizeof(tmp), "%ld", value);
variable_set_deleted(var, 1);
variable_add(var, tmp, TYPE_QSCRIPT, -1, vtype);
ret = 0;
}
else
ret = -EINVAL;
var = utils_free("scripting.operators.var", var);
val = utils_free("scripting.operators.val", val);
free_tokens(t);
return ret;
}
else
/* Assignment */
if (is_assignment(buf)) {
tTokenizer t;
t = tokenize(buf, "=");
char *val = strdup( trim(t.tokens[1]) );
if (val[strlen(val) - 1] == ';') {
val[strlen(val) - 1] = 0;
if (is_numeric(val) || is_string(val)) {
if (is_string(val)) {
*val++;
val[strlen(val) - 1] = 0;
}
if (variable_add(trim(t.tokens[0]), val, TYPE_QSCRIPT, -1, gettype(val)) < 0) {
desc_printf(gIO, gFd, "Cannot set new value to variable %s\n", trim(t.tokens[0]));
ret = -EEXIST;
}
else
ret = 0;
}
else
if (regex_match("([^(]*)([^)]*)", val)) {
tTokenizer t2;
char *args = NULL;
char *fn;
t2 = tokenize(val, "(");
if (t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] != ')') {
ret = -EINVAL;
goto cleanup;
}
t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] = 0;
fn = strdup(t2.tokens[0]);
/* We need to make sure parenthesis won't break script line */
if (t2.numTokens > 1) {
int i;
char argstmp[8192] = { 0 };
for (i = 1; i < t2.numTokens; i++) {
strcat(argstmp, t2.tokens[i]);
if (i < t2.numTokens - 1)
strcat(argstmp, "(");
}
args = strdup(argstmp);
}
if (args != NULL) {
char args2[1024] = { 0 };
snprintf(args2, sizeof(args2), "%s", args + 1);
args2[ strlen(args2) - 1] = 0;
args = utils_free("scripting.function-call.args", args);
args = strdup( args2 );
}
free_tokens(t2);
if (_script_builtin_function(trim(t.tokens[0]), fn, args) != 0)
DPRINTF("Function %s doesn't seem to be builtin, we should try user-defined function\n", fn);
DPRINTF("%s: Should be a function with return value\n", __FUNCTION__);
args = utils_free("scripting.function-call.args", args);
fn = utils_free("scripting.function-call.fn", fn);
ret = 0;
}
else
ret = -EINVAL;
}
free_tokens(t);
}
else
if (regex_match("([^(]*)([^)]*)", buf)) {
tTokenizer t2;
char *args = NULL;
char *fn;
t2 = tokenize(buf, "(");
if (t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] != ';') {
ret = -EINVAL;
goto cleanup;
}
t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] = 0;
fn = strdup(t2.tokens[0]);
/* We need to make sure parenthesis won't break script line */
if (t2.numTokens > 1) {
int i;
char argstmp[8192] = { 0 };
for (i = 1; i < t2.numTokens; i++) {
strcat(argstmp, t2.tokens[i]);
if (i < t2.numTokens - 1)
strcat(argstmp, "(");
}
args = strdup(argstmp);
}
if (args != NULL) {
if (args[strlen(args) - 1] == ')')
args[strlen(args) - 1] = 0;
}
free_tokens(t2);
if (_script_builtin_function(NULL, fn, args) != 0)
DPRINTF("Function %s doesn't seem to be builtin, we should try user-defined function\n", fn);
args = utils_free("scripting.function-call.args", args);
fn = utils_free("scripting.function-call.fn", fn);
ret = 0;
}
else
DPRINTF("%s: Not implemented yet\n", __FUNCTION__);
cleanup:
if ((_perf_measure) && ((ts.tv_nsec > 0) && (ts.tv_sec > 0)) && (_script_in_condition_and_met > 0)) {
tse = utils_get_time( TIME_CURRENT );
desc_printf(gIO, gFd, "PERF: Line \"%s\" was being processed for %.3f microseconds (%.3f ms)\n\n",
buf, get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.);
}
return ret;
}
int run_script(char *filename)
{
FILE *fp;
int opened = 0;
char buf[4096] = { 0 };
struct timespec ts = utils_get_time( TIME_CURRENT );
struct timespec tse;
if (access(filename, R_OK) != 0)
return -ENOENT;
_script_in_condition_and_met = -1;
fp = fopen(filename, "r");
if (fp == NULL)
return -EPERM;
if (gHttpHandler)
http_host_header(gIO, gFd, HTTP_CODE_OK, gHost, "text/html", NULL, myRealm, 0);
while (!feof(fp)) {
memset(buf, 0, sizeof(buf));
fgets(buf, sizeof(buf), fp);
if ((strlen(buf) > 1) && (buf[strlen(buf) - 1] == '\n'))
buf[strlen(buf) - 1] = 0;
if ((strlen(buf) > 1) && (buf[0] != '\n')) {
if (strcmp(buf, "<$") == 0)
opened = 1;
if (strcmp(buf, "$>") == 0)
opened = 0;
if ((opened) && (strcmp(buf, "<$") != 0))
script_process_line(trim(buf));
}
}
fclose(fp);
idb_free_last_select_data();
if (_perf_measure) {
tse = utils_get_time( TIME_CURRENT );
desc_printf(gIO, gFd, "PERF: File \"%s\" has been processed in %.3f microseconds (%.3f ms)\n\n",
basename(filename), get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.);
}
variable_dump();
variable_free_all();
return 0;
}
static void
print_memdevice(smbios_hdl_t *shp, id_t id, FILE *fp)
{
smbios_memdevice_t md;
(void) smbios_info_memdevice(shp, id, &md);
id_printf(fp, " Physical Memory Array: ", md.smbmd_array);
id_printf(fp, " Memory Error Data: ", md.smbmd_error);
if (md.smbmd_twidth != -1u)
oprintf(fp, " Total Width: %u bits\n", md.smbmd_twidth);
else
oprintf(fp, " Total Width: Unknown\n");
if (md.smbmd_dwidth != -1u)
oprintf(fp, " Data Width: %u bits\n", md.smbmd_dwidth);
else
oprintf(fp, " Data Width: Unknown\n");
switch (md.smbmd_size) {
case -1ull:
oprintf(fp, " Size: Unknown\n");
break;
case 0:
oprintf(fp, " Size: Not Populated\n");
break;
default:
oprintf(fp, " Size: %llu bytes\n",
(u_longlong_t)md.smbmd_size);
}
desc_printf(smbios_memdevice_form_desc(md.smbmd_form),
fp, " Form Factor: %u", md.smbmd_form);
if (md.smbmd_set == 0)
oprintf(fp, " Set: None\n");
else if (md.smbmd_set == (uint8_t)-1u)
oprintf(fp, " Set: Unknown\n");
else
oprintf(fp, " Set: %u\n", md.smbmd_set);
if (md.smbmd_rank != 0) {
desc_printf(smbios_memdevice_rank_desc(md.smbmd_rank),
fp, " Rank: %u", md.smbmd_rank);
} else {
oprintf(fp, " Rank: Unknown\n");
}
desc_printf(smbios_memdevice_type_desc(md.smbmd_type),
fp, " Memory Type: %u", md.smbmd_type);
flag_printf(fp, "Flags", md.smbmd_flags, sizeof (md.smbmd_flags) * NBBY,
smbios_memdevice_flag_name, smbios_memdevice_flag_desc);
if (md.smbmd_speed != 0)
oprintf(fp, " Speed: %u MHz\n", md.smbmd_speed);
else
oprintf(fp, " Speed: Unknown\n");
if (md.smbmd_clkspeed != 0)
oprintf(fp, " Configured Speed: %u MHz\n", md.smbmd_clkspeed);
else
oprintf(fp, " Configured Speed: Unknown\n");
oprintf(fp, " Device Locator: %s\n", md.smbmd_dloc);
oprintf(fp, " Bank Locator: %s\n", md.smbmd_bloc);
if (md.smbmd_minvolt != 0) {
oprintf(fp, " Minimum Voltage: %.2fV\n",
md.smbmd_minvolt / 1000.0);
} else {
oprintf(fp, " Minimum Voltage: Unknown\n");
}
if (md.smbmd_maxvolt != 0) {
oprintf(fp, " Maximum Voltage: %.2fV\n",
md.smbmd_maxvolt / 1000.0);
} else {
oprintf(fp, " Maximum Voltage: Unknown\n");
}
if (md.smbmd_confvolt != 0) {
oprintf(fp, " Configured Voltage: %.2fV\n",
md.smbmd_confvolt / 1000.0);
} else {
oprintf(fp, " Configured Voltage: Unknown\n");
}
}
static void
print_processor(smbios_hdl_t *shp, id_t id, FILE *fp)
{
smbios_processor_t p;
uint_t status;
(void) smbios_info_processor(shp, id, &p);
status = SMB_PRSTATUS_STATUS(p.smbp_status);
desc_printf(smbios_processor_family_desc(p.smbp_family),
fp, " Family: %u", p.smbp_family);
if (p.smbp_family2 != 0)
desc_printf(smbios_processor_family_desc(p.smbp_family2),
fp, " Family Ext: %u", p.smbp_family2);
oprintf(fp, " CPUID: 0x%llx\n", (u_longlong_t)p.smbp_cpuid);
desc_printf(smbios_processor_type_desc(p.smbp_type),
fp, " Type: %u", p.smbp_type);
desc_printf(smbios_processor_upgrade_desc(p.smbp_upgrade),
fp, " Socket Upgrade: %u", p.smbp_upgrade);
oprintf(fp, " Socket Status: %s\n",
SMB_PRSTATUS_PRESENT(p.smbp_status) ?
"Populated" : "Not Populated");
desc_printf(smbios_processor_status_desc(status),
fp, " Processor Status: %u", status);
if (SMB_PRV_LEGACY(p.smbp_voltage)) {
oprintf(fp, " Supported Voltages:");
switch (p.smbp_voltage) {
case SMB_PRV_5V:
oprintf(fp, " 5.0V");
break;
case SMB_PRV_33V:
oprintf(fp, " 3.3V");
break;
case SMB_PRV_29V:
oprintf(fp, " 2.9V");
break;
}
oprintf(fp, "\n");
} else {
oprintf(fp, " Supported Voltages: %.1fV\n",
(float)SMB_PRV_VOLTAGE(p.smbp_voltage) / 10);
}
if (p.smbp_corecount != 0) {
if (p.smbp_corecount != 0xff || p.smbp_corecount2 == 0)
oprintf(fp, " Core Count: %u\n", p.smbp_corecount);
else
oprintf(fp, " Core Count: %u\n", p.smbp_corecount2);
} else {
oprintf(fp, " Core Count: Unknown\n");
}
if (p.smbp_coresenabled != 0) {
if (p.smbp_coresenabled != 0xff || p.smbp_coresenabled2 == 0) {
oprintf(fp, " Cores Enabled: %u\n",
p.smbp_coresenabled);
} else {
oprintf(fp, " Cores Enabled: %u\n",
p.smbp_coresenabled2);
}
} else {
oprintf(fp, " Cores Enabled: Unknown\n");
}
if (p.smbp_threadcount != 0) {
if (p.smbp_threadcount != 0xff || p.smbp_threadcount2 == 0) {
oprintf(fp, " Thread Count: %u\n",
p.smbp_threadcount);
} else {
oprintf(fp, " Thread Count: %u\n",
p.smbp_threadcount2);
}
} else {
oprintf(fp, " Thread Count: Unknown\n");
}
if (p.smbp_cflags) {
flag_printf(fp, "Processor Characteristics",
p.smbp_cflags, sizeof (p.smbp_cflags) * NBBY,
smbios_processor_core_flag_name,
smbios_processor_core_flag_desc);
}
if (p.smbp_clkspeed != 0)
oprintf(fp, " External Clock Speed: %uMHz\n", p.smbp_clkspeed);
else
oprintf(fp, " External Clock Speed: Unknown\n");
if (p.smbp_maxspeed != 0)
oprintf(fp, " Maximum Speed: %uMHz\n", p.smbp_maxspeed);
else
oprintf(fp, " Maximum Speed: Unknown\n");
if (p.smbp_curspeed != 0)
oprintf(fp, " Current Speed: %uMHz\n", p.smbp_curspeed);
else
oprintf(fp, " Current Speed: Unknown\n");
id_printf(fp, " L1 Cache: ", p.smbp_l1cache);
id_printf(fp, " L2 Cache: ", p.smbp_l2cache);
id_printf(fp, " L3 Cache: ", p.smbp_l3cache);
}
