/* 画像を読み込む */
static bool load_images(void)
{
const char *file;
struct image *img;
/* 背景を読み込んでFOレイヤに描画する */
file = get_string_param(RETROSPECT_PARAM_BG_FILE);
img = create_image_from_file(BG_DIR, file);
if (img == NULL) {
log_script_exec_footer();
return false;
}
draw_image_to_fo(img);
destroy_image(img);
/* 前景を読み込んでFIレイヤに描画する */
file = get_string_param(MENU_PARAM_FG_FILE);
img = create_image_from_file(BG_DIR, file);
if (img == NULL) {
log_script_exec_footer();
return false;
}
draw_image_to_fi(img);
destroy_image(img);
return true;
}
/* サムネイルごとの情報をロードする */
static bool load_thumbnail_params(void)
{
int32_t flag_val;
int i;
/* 各サムネイルの情報を取得する */
thumbnail_count = 0;
for(i = 0; i < THUMBNAIL_SIZE; i++) {
/* ラベルを取得する */
thumbnail[i].label = get_string_param(PARAM_LABEL(i));
if (strcmp(thumbnail[i].label, "") == 0)
break; /* すべてのサムネイルを処理した*/
/* 変数の値を求める */
if (!get_variable_by_string(get_string_param(PARAM_FLAG(i)),
&flag_val))
return false;
/* サムネイルを有効にするかを求める */
thumbnail[i].enabled = flag_val != 0;
/* 表示位置を取得する */
thumbnail[i].x = get_int_param(PARAM_X(i));
thumbnail[i].y = get_int_param(PARAM_Y(i));
thumbnail_count++;
}
for(i = thumbnail_count; i < THUMBNAIL_SIZE; i++)
thumbnail[i].enabled = false;
return true;
}
static ret_code_t parmctrl(void)
{
SaHpiResourceIdT resid;
int i;
char buf[10];
SaErrorT rv;
SaHpiParmActionT act;
ret_code_t ret;
ret = ask_rpt(&resid);
if (ret != HPI_SHELL_OK) return(ret);
i = get_string_param("Action (default,save,restore): ", buf, 9);
if (i != 0) {
printf("Invalid action: %s\n", buf);
return(HPI_SHELL_PARM_ERROR);
};
if (strcmp(buf, "default") == 0)
act = SAHPI_DEFAULT_PARM;
else if (strcmp(buf, "save") == 0)
act = SAHPI_SAVE_PARM;
else if (strcmp(buf, "restore") == 0)
act = SAHPI_RESTORE_PARM;
else {
printf("Invalid action: %s\n", buf);
return(HPI_SHELL_PARM_ERROR);
};
rv = saHpiParmControl(Domain->sessionId, resid, act);
if (rv != SA_OK) {
printf("saHpiParmControl error = %s\n", oh_lookup_error(rv));
return HPI_SHELL_CMD_ERROR;
};
return (HPI_SHELL_OK);
}
static ret_code_t set_tag(void)
{
SaHpiResourceIdT resid = 0;
SaHpiTextBufferT tbuf;
int i;
char buf[SAHPI_MAX_TEXT_BUFFER_LENGTH + 1];
SaErrorT rv;
SaHpiRptEntryT rpt_entry;
Rpt_t tmp_rpt;
ret_code_t ret;
ret = ask_rpt(&resid);
if (ret != HPI_SHELL_OK) return(ret);
i = get_string_param("New tag: ", buf, SAHPI_MAX_TEXT_BUFFER_LENGTH);
if (i != 0) {
printf("Invalid tag: %s\n", buf);
return(HPI_SHELL_PARM_ERROR);
};
strcpy(tbuf.Data, buf);
tbuf.DataType = SAHPI_TL_TYPE_TEXT;
tbuf.Language = SAHPI_LANG_ENGLISH;
tbuf.DataLength = i;
rv = saHpiResourceTagSet(Domain->sessionId, resid, &tbuf);
if (rv != SA_OK) {
printf("saHpiResourceTagSet error = %s\n", oh_lookup_error(rv));
return HPI_SHELL_CMD_ERROR;
};
rv = saHpiRptEntryGetByResourceId(Domain->sessionId, resid, &rpt_entry);
make_attrs_rpt(&tmp_rpt, &rpt_entry);
show_Rpt(&tmp_rpt, ui_print);
free_attrs(&(tmp_rpt.Attrutes));
return (HPI_SHELL_OK);
}
ret_code_t ann_block_modeset(void)
{
SaErrorT rv;
SaHpiAnnunciatorModeT mode;
char buf[256];
int res;
res = get_string_param("Mode(auto|user|shared): ", buf, 10);
if (res != 0) {
printf("Invalid mode: %s\n", buf);
return(HPI_SHELL_PARM_ERROR);
};
if (strcmp(buf, "auto") == 0)
mode = SAHPI_ANNUNCIATOR_MODE_AUTO;
else if (strcmp(buf, "user") == 0)
mode = SAHPI_ANNUNCIATOR_MODE_USER;
else if (strcmp(buf, "shared") == 0)
mode = SAHPI_ANNUNCIATOR_MODE_SHARED;
else {
printf("Invalid mode: %s\n", buf);
return(HPI_SHELL_PARM_ERROR);
};
rv = saHpiAnnunciatorModeSet(Domain->sessionId, ann_block_env.rptid,
ann_block_env.rdrnum, mode);
if (rv != SA_OK) {
printf("saHpiAnnunciatorModeSet error %s\n",
oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
return(HPI_SHELL_OK);
}
static int add_inventory_field(SaHpiSessionIdT sessionId, SaHpiResourceIdT rptid, SaHpiIdrIdT rdrnum)
{
SaErrorT rv;
SaHpiIdrFieldT field;
char buf[256];
int res, i;
i = get_int_param("Area Id: ", &res);
if (i != 1) {
printf("Error!!! Invalid Area Id\n");
return(-1);
};
field.AreaId = res;
i = get_string_param("Field type(chass,time,manuf,prodname,prodver,"
"snum,pnum,file,tag,custom): ", buf, 9);
if (i != 0) {
printf("Error!!! Invalid Field type: %s\n", buf);
return(-1);
};
for (i = 0; Field_types[i].name != (char *)NULL; i++)
if (strcmp(Field_types[i].name, buf) == 0) break;
if (Field_types[i].name == (char *)NULL) {
printf("Error!!! Unknown Field type: %s\n", buf);
return(-1);
};
field.Type = Field_types[i].val;
field.ReadOnly = SAHPI_FALSE;
i = get_string_param("Field value: ", buf, 256);
if (i != 0) {
printf("Error!!! Invalid Field value: %s\n", buf);
return(-1);
};
i = strlen(buf);
field.Field.DataType = SAHPI_TL_TYPE_TEXT;
field.Field.Language = SAHPI_LANG_ENGLISH;
field.Field.DataLength = i;
if (i > 0)
strcpy(field.Field.Data, buf);
rv = saHpiIdrFieldAdd(sessionId, rptid, rdrnum, &field);
if (rv != SA_OK) {
printf("ERROR!!! saHpiIdrFieldAdd: %s\n", oh_lookup_error(rv));
return(rv);
};
return(SA_OK);
}
AxisCamPolled() : ROS_Slave(), cam(NULL), frame_id(0)
{
register_source(image = new FlowImage("image"));
register_sink(shutter = new FlowEmpty("shutter"),
ROS_CALLBACK(AxisCamPolled, shutter_cb));
if (!get_string_param(".host", axis_host))
{
printf("axis_host parameter not specified; defaulting to 192.168.0.90\n");
axis_host = "192.168.0.90";
}
printf("axis host set to [%s]\n", axis_host.c_str());
get_int_param(".frame_id", &frame_id);
cam = new AxisCam(axis_host);
}
static ret_code_t get_uri( SaHpiTextBufferT* uri )
{
int i;
i = get_string_param("Source URI: ", (char*)(uri->Data), SAHPI_MAX_TEXT_BUFFER_LENGTH);
if ( i != 0 ) {
printf( "Error!!! Invalid string: %s\n", uri->Data );
return HPI_SHELL_PARM_ERROR ;
}
uri->DataType = SAHPI_TL_TYPE_TEXT;
uri->Language = SAHPI_LANG_ENGLISH;
uri->DataLength = strlen( (char*)(uri->Data) );
return HPI_SHELL_OK;
}
static ret_code_t delete_announ(SaHpiResourceIdT rptid, SaHpiInstrumentIdT rdrnum)
{
SaErrorT rv;
char str[32];
int i, any = 0;
SaHpiSeverityT sev = SAHPI_OK;
SaHpiEntryIdT entryId = 0;
i = get_string_param("EntryId(<Id> | any): ", str, 32);
if (i != 0) return(HPI_SHELL_PARM_ERROR);
if (strcmp(str, "any") == 0) any = 1;
else entryId = atoi(str);
if (any) {
i = get_string_param("Severity(crit|maj|min|info|ok|all): ",
str, 10);
if (i != 0) return(-1);
if (strcmp(str, "crit") == 0) sev = SAHPI_CRITICAL;
else if (strcmp(str, "maj") == 0) sev = SAHPI_MAJOR;
else if (strcmp(str, "min") == 0) sev = SAHPI_MINOR;
else if (strcmp(str, "info") == 0) sev = SAHPI_INFORMATIONAL;
else if (strcmp(str, "ok") == 0) sev = SAHPI_OK;
else if (strcmp(str, "all") == 0) sev = SAHPI_ALL_SEVERITIES;
else {
printf("Invalid severity %s\n", str);
return(HPI_SHELL_PARM_ERROR);
};
entryId = SAHPI_ENTRY_UNSPECIFIED;
};
rv = saHpiAnnunciatorDelete(Domain->sessionId, rptid, rdrnum,
entryId, sev);
if (rv != SA_OK) {
printf("saHpiAnnunciatorDelete error %s\n", oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
return HPI_SHELL_OK;
}
int ConfigImpl::get_int_param(const string& section,const string& param_name, int& value)
{
int rv = 0;
string tmp;
rv = get_string_param(section, param_name, tmp);
if(rv < 0)
{
return -1;
}
value = strtol(tmp.c_str(),0,0);
return 0;
}
int ConfigImpl::get_double_param(const string& section, const string& param_name, double& value)
{
int rv = 0;
string tmp;
rv = get_string_param(section, param_name, tmp);
if(rv < 0)
{
return -1;
}
value = atof(tmp.c_str());
return 0;
}
void Lab2VitMain::finish_utt(double logProb)
{
m_totFrmCnt += m_feats.size1();
m_totLogProb += logProb;
// Output results.
if (m_doAlign)
write_int_vector(m_outStrm, m_labelList, m_idStr);
else
{
cout << " Output:";
for (int labelIdx = 0; labelIdx < (int) m_labelList.size();
++labelIdx)
{
m_outStrm << m_graph.get_word_sym_table().get_str(
m_labelList[labelIdx]) << " ";
cout << " " << m_graph.get_word_sym_table().get_str(
m_labelList[labelIdx]);
}
m_outStrm << "(" << m_idStr << ")" << endl;
cout << endl;
}
string chartFile = get_string_param(m_params, "chart_file");
if (!chartFile.empty())
{
// Output DP chart, for debugging.
ofstream chartStrm(chartFile.c_str());
int frmCnt = m_feats.size1();
int stateCnt = m_graph.get_state_count();
matrix<double> matProbs(frmCnt + 1, stateCnt);
matrix<int> matArcs(frmCnt + 1, stateCnt);
for (int frmIdx = 0; frmIdx <= frmCnt; ++frmIdx)
{
for (int srcIdx = 0; srcIdx < stateCnt; ++srcIdx)
{
matProbs(frmIdx, srcIdx) =
m_chart(frmIdx, srcIdx).get_log_prob();
matArcs(frmIdx, srcIdx) =
m_chart(frmIdx, srcIdx).get_arc_id();
}
}
write_float_matrix(chartStrm, matProbs, m_idStr + "_probs");
write_int_matrix(chartStrm, matArcs, m_idStr + "_arcs");
chartStrm.close();
}
}
Lab2VitMain::Lab2VitMain(const map<string, string>& params) :
m_params(params), m_frontEnd(m_params),
m_gmmSet(get_required_string_param(m_params, "gmm")),
m_audioStrm(get_required_string_param(m_params, "audio_file").c_str()),
m_doAlign(!get_string_param(m_params, "align_file").empty()),
m_outStrm(get_required_string_param(m_params,
!m_doAlign ? "dcd_file" : "align_file").c_str()),
m_acousWgt(get_float_param(m_params, "ac_wgt", 1.0)),
m_totFrmCnt(0), m_totLogProb(0.0)
{
if (!m_doAlign)
m_graph.read(get_required_string_param(m_params, "graph_file"),
get_required_string_param(m_params, "word_syms"));
else
m_graphStrm.open(
get_required_string_param(m_params, "graph_file").c_str());
}
static int set_inventory_field(SaHpiSessionIdT sessionId, SaHpiResourceIdT rptid, SaHpiIdrIdT rdrnum)
{
SaErrorT rv;
SaHpiIdrFieldT field;
char buf[256];
int res, i;
memset(&field, 0, sizeof(SaHpiIdrFieldT));
i = get_int_param("Area Id: ", &res);
if (i != 1) {
printf("Error!!! Invalid Area Id\n");
return(-1);
};
field.AreaId = res;
i = get_int_param("Field Id: ", &res);
if (i != 1) {
printf("Error!!! Invalid Field Id\n");
return(-1);
};
field.FieldId = res;
i = get_string_param("Field type(chass,time,manuf,prodname,prodver,"
"snum,pnum,file,tag,custom): ", buf, 9);
if (i == 0) {
for (i = 0; Field_types[i].name != (char *)NULL; i++)
if (strcmp(Field_types[i].name, buf) == 0) break;
if (Field_types[i].name == (char *)NULL) {
printf("Error!!! Unknown Field type: %s\n", buf);
return(-1);
};
field.Type = Field_types[i].val;
};
i = set_text_buffer(&(field.Field));
if (i != 0) {
printf("Invalid text\n");
return(HPI_SHELL_CMD_ERROR);
};
rv = saHpiIdrFieldSet(sessionId, rptid, rdrnum, &field);
if (rv != SA_OK) {
printf("ERROR!!! saHpiIdrFieldSet: %s\n", oh_lookup_error(rv));
return(rv);
};
return(SA_OK);
}
static ret_code_t set_sever(void)
{
SaHpiResourceIdT resid;
SaHpiSeverityT sev = SAHPI_OK;
int i;
char buf[SEV_BUF_SIZE + 1];
SaErrorT rv;
SaHpiRptEntryT rpt_entry;
Rpt_t tmp_rpt;
ret_code_t ret;
ret = ask_rpt(&resid);
if (ret != HPI_SHELL_OK) return(ret);
i = get_string_param(
"New severity (crit, maj, min, inf, ok, debug, all): ",
buf, SEV_BUF_SIZE);
if (i != 0) {
printf("Invalid sevetity: %s\n", buf);
return(HPI_SHELL_PARM_ERROR);
};
for (i = 0; Sev_array[i].name != (char *)NULL; i++)
if (strcmp(buf, Sev_array[i].name) == 0) {
sev = Sev_array[i].val;
break;
};
if (Sev_array[i].name == (char *)NULL) {
printf("Invalid sevetity type: %s\n", buf);
return(HPI_SHELL_PARM_ERROR);
};
rv = saHpiResourceSeveritySet(Domain->sessionId, resid, sev);
if (rv != SA_OK) {
printf("saHpiResourceSeveritySet error = %s\n",
oh_lookup_error(rv));
return HPI_SHELL_CMD_ERROR;
};
rv = saHpiRptEntryGetByResourceId(Domain->sessionId, resid, &rpt_entry);
make_attrs_rpt(&tmp_rpt, &rpt_entry);
show_Rpt(&tmp_rpt, ui_print);
free_attrs(&(tmp_rpt.Attrutes));
return (HPI_SHELL_OK);
}
static int add_inventory_area(SaHpiSessionIdT sessionId, SaHpiResourceIdT rptid, SaHpiIdrIdT rdrnum)
{
SaHpiEntryIdT entry;
SaErrorT rv;
char buf[10];
int i;
i = get_string_param("Area type (inter,chass,board,prod,oem): ", buf, 9);
if (i != 0) return(-1);
for (i = 0; Area_types[i].name != (char *)NULL; i++)
if (strcmp(Area_types[i].name, buf) == 0) break;
if (Area_types[i].name == (char *)NULL) {
printf("Error!!! Unknown Area type: %s\n", buf);
return(-1);
};
rv = saHpiIdrAreaAdd(sessionId, rptid, rdrnum, Area_types[i].val, &entry);
if (rv != SA_OK) {
printf("ERROR!!! saHpiIdrAreaAdd: %s\n", oh_lookup_error(rv));
return(rv);
};
return(SA_OK);
}
Servo() : ROS_Slave(), mot(NULL), ipdcmot_host("192.168.1.123"),
pos_send_freq(1.0)
{
register_sink(setpos_blocking = new FlowFloat64("setpos_blocking"), ROS_CALLBACK(Servo, setpos_blocking_cb));
register_source(setpos_result = new FlowInt32("setpos_result"));
register_sink(getpos_blocking = new FlowEmpty("getpos_blocking"), ROS_CALLBACK(Servo, getpos_blocking_cb));
register_source(getpos_result = new FlowFloat64("getpos_result"));
register_sink(patrol = new FlowPatrol("patrol"), ROS_CALLBACK(Servo, patrol_cb));
register_source(pos_f = new FlowFloat64("pos"));
register_source(status_f = new FlowString("status"));
register_with_master();
if (!get_string_param(".host", ipdcmot_host))
printf("ipdcmot_host parameter not specified... defaulting to [%s]\n", ipdcmot_host.c_str());
printf("ipdcmot host set to [%s]\n", ipdcmot_host.c_str());
get_double_param(".pos_send_freq", &pos_send_freq);
printf("position send frequency set to %f\n", pos_send_freq);
mot = new IPDCMOT(ipdcmot_host, 75.0);
status_f->data = "ready";
status_f->publish();
}
static ret_code_t wtd_set(void)
{
SaHpiResourceIdT rptid;
SaHpiWatchdogNumT wtdnum;
SaHpiWatchdogT watchdog;
SaHpiWatchdogExpFlagsT flags;
SaErrorT rv;
ret_code_t ret;
int i, res;
char *str, *str1;
char tmp[256];
ret = ask_rpt(&rptid);
if (ret != HPI_SHELL_OK) return(ret);
ret = ask_rdr(rptid, SAHPI_WATCHDOG_RDR, &wtdnum);
if (ret != HPI_SHELL_OK) return(ret);
i = get_string_param("Log(0 | 1): ", tmp, 255);
if (i != 0) {
printf("Invalid Log value: %s\n", tmp);
return(HPI_SHELL_PARM_ERROR);
};
if (tmp[0] == '1') watchdog.Log = SAHPI_TRUE;
else watchdog.Log = SAHPI_FALSE;
i = get_string_param("Running(0 | 1): ", tmp, 255);
if (i != 0) {
printf("Invalid Running value: %s\n", tmp);
return(HPI_SHELL_PARM_ERROR);
};
if (tmp[0] == '1') watchdog.Running = SAHPI_TRUE;
else watchdog.Running = SAHPI_FALSE;
i = get_string_param(
"TimerUse(none|bios_frb2|bios_post|os_load|sms_os|oem): ",
tmp, 255);
if (i != 0) {
printf("Invalid TimerUse value: %s\n", tmp);
return(HPI_SHELL_PARM_ERROR);
};
if (strcmp(tmp, "none") == 0)
watchdog.TimerUse = SAHPI_WTU_NONE;
else if (strcmp(tmp, "bios_frb2") == 0)
watchdog.TimerUse = SAHPI_WTU_BIOS_FRB2;
else if (strcmp(tmp, "bios_post") == 0)
watchdog.TimerUse = SAHPI_WTU_BIOS_POST;
else if (strcmp(tmp, "os_load") == 0)
watchdog.TimerUse = SAHPI_WTU_OS_LOAD;
else if (strcmp(tmp, "sms_os") == 0)
watchdog.TimerUse = SAHPI_WTU_SMS_OS;
else if (strcmp(tmp, "oem") == 0)
watchdog.TimerUse = SAHPI_WTU_OEM;
else {
printf("Invalid TimerUse value: %s\n", tmp);
return(HPI_SHELL_PARM_ERROR);
};
i = get_string_param(
"TimerAction(no|reset|pwr_down|pwr_cycle|int): ",
tmp, 255);
if (i != 0) {
printf("Invalid TimerAction value: %s\n", tmp);
return(HPI_SHELL_PARM_ERROR);
};
if (strcmp(tmp, "no") == 0)
watchdog.TimerAction = SAHPI_WAE_NO_ACTION;
else if (strcmp(tmp, "reset") == 0)
watchdog.TimerAction = SAHPI_WAE_RESET;
else if (strcmp(tmp, "pwr_down") == 0)
watchdog.TimerAction = SAHPI_WAE_POWER_DOWN;
else if (strcmp(tmp, "pwr_cycle") == 0)
watchdog.TimerAction = SAHPI_WAE_POWER_CYCLE;
else if (strcmp(tmp, "int") == 0)
watchdog.TimerAction = SAHPI_WAE_TIMER_INT;
else {
printf("Invalid TimerAction value: %s\n", tmp);
return(HPI_SHELL_PARM_ERROR);
};
i = get_string_param("PretimerInterrupt(no|smi|nmi|mess|oem): ",
tmp, 255);
if (i != 0) {
printf("Invalid PretimerInterrupt value: %s\n", tmp);
return(HPI_SHELL_PARM_ERROR);
};
if (strcmp(tmp, "no") == 0)
watchdog.PretimerInterrupt = SAHPI_WPI_NONE;
else if (strcmp(tmp, "smi") == 0)
watchdog.PretimerInterrupt = SAHPI_WPI_SMI;
else if (strcmp(tmp, "nmi") == 0)
watchdog.PretimerInterrupt = SAHPI_WPI_NMI;
else if (strcmp(tmp, "mess") == 0)
watchdog.PretimerInterrupt = SAHPI_WPI_MESSAGE_INTERRUPT;
else if (strcmp(tmp, "oem") == 0)
watchdog.PretimerInterrupt = SAHPI_WPI_OEM;
else {
printf("Invalid TimerAction value: %s\n", tmp);
return(HPI_SHELL_PARM_ERROR);
};
i = get_int_param("TimeOut: ", &res);
if (i != 1) {
printf("Invalid TimeOut value\n");
return(HPI_SHELL_PARM_ERROR);
};
watchdog.PreTimeoutInterval = res;
i = get_string_param("Flags(\"bios_frb2|bios_post|os_load|sms_os|oem\"): ",
tmp, 255);
if (i != 0) *tmp = 0;
flags = 0;
str = tmp;
while (strlen(str) != 0) {
while (isspace(*str)) str++;
str1 = str;
while ((*str1 != ' ') && (*str1 != 0) && (*str1 != '|')) str1++;
if (*str1 != 0) *str1++ = 0;
else *str1 = 0;
if (strcmp(str, "bios_frb2") == 0)
flags |= SAHPI_WATCHDOG_EXP_BIOS_FRB2;
if (strcmp(str, "bios_post") == 0)
flags |= SAHPI_WATCHDOG_EXP_BIOS_POST;
if (strcmp(str, "os_load") == 0)
flags |= SAHPI_WATCHDOG_EXP_OS_LOAD;
if (strcmp(str, "sms_os") == 0)
flags |= SAHPI_WATCHDOG_EXP_SMS_OS;
if (strcmp(str, "oem") == 0)
flags |= SAHPI_WATCHDOG_EXP_OEM;
str = str1;
};
watchdog.TimerUseExpFlags = flags;
i = get_int_param("InitialCount: ", &res);
if (i != 1) {
printf("Invalid InitialCount value\n");
return(HPI_SHELL_PARM_ERROR);
};
watchdog.InitialCount = res;
rv = saHpiWatchdogTimerSet(Domain->sessionId, rptid, wtdnum, &watchdog);
if (rv != SA_OK) {
printf("ERROR!!! Set Watchdog: ResourceId=%d WatchdogNum=%d: %s\n",
rptid, wtdnum, oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
return HPI_SHELL_OK;
}
static ret_code_t show_rdr(void)
{
Rdr_t tmp_rdr;
SaHpiRdrT rdr_entry;
SaHpiResourceIdT rptid = 0;
SaHpiInstrumentIdT rdrnum;
SaHpiRdrTypeT type;
SaErrorT rv;
int i;
char buf[10], t;
term_def_t *term;
ret_code_t ret;
term = get_next_term();
if (term == NULL) {
if (read_file) return(HPI_SHELL_CMD_ERROR);
i = show_rpt_list(Domain, SHOW_ALL_RPT, rptid, ui_print);
if (i == 0) {
printf("NO rpt!\n");
return(HPI_SHELL_CMD_ERROR);
};
i = get_string_param("RPT (ID | all) ==> ", buf, 9);
if (i != 0) return HPI_SHELL_CMD_ERROR;
if (strncmp(buf, "all", 3) == 0) {
show_rpt_list(Domain, SHOW_ALL_RDR, rptid, ui_print);
return(HPI_SHELL_OK);
};
rptid = (SaHpiResourceIdT)atoi(buf);
} else {
if (strcmp(term->term, "all") == 0) {
show_rpt_list(Domain, SHOW_ALL_RDR, rptid, ui_print);
return(HPI_SHELL_OK);
};
if (isdigit(term->term[0]))
rptid = (SaHpiResourceIdT)atoi(term->term);
else
return HPI_SHELL_PARM_ERROR;
};
term = get_next_term();
if (term == NULL) {
if (read_file) return(HPI_SHELL_CMD_ERROR);
i = get_string_param("RDR Type (s|a|c|w|i|all) ==> ",
buf, 9);
if (i != 0) return HPI_SHELL_PARM_ERROR;
} else {
memset(buf, 0, 10);
strncpy(buf, term->term, 3);
};
if (strncmp(buf, "all", 3) == 0) t = 'n';
else t = *buf;
if (t == 'c') type = SAHPI_CTRL_RDR;
else if (t == 's') type = SAHPI_SENSOR_RDR;
else if (t == 'i') type = SAHPI_INVENTORY_RDR;
else if (t == 'w') type = SAHPI_WATCHDOG_RDR;
else if (t == 'a') type = SAHPI_ANNUNCIATOR_RDR;
else type = SAHPI_NO_RECORD;
ret = ask_rdr(rptid, type, &rdrnum);
if (ret != HPI_SHELL_OK) return(ret);
if (type == SAHPI_NO_RECORD)
rv = find_rdr_by_num(Domain->sessionId, rptid,
rdrnum, type, 0, &rdr_entry);
else
rv = saHpiRdrGetByInstrumentId(Domain->sessionId,
rptid, type, rdrnum, &rdr_entry);
if (rv != SA_OK) {
printf("ERROR!!! Get rdr: ResourceId=%d RdrType=%d"
"RdrNum=%d: %s\n",
rptid, type, rdrnum, oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
make_attrs_rdr(&tmp_rdr, &rdr_entry);
show_Rdr(&tmp_rdr, ui_print);
free_attrs(&(tmp_rdr.Attrutes));
return HPI_SHELL_OK;
}
static ret_code_t settime_evtlog(void)
{
SaHpiResourceIdT rptid = 0;
SaErrorT rv;
SaHpiTimeT newtime;
struct tm new_tm_time;
char buf[READ_BUF_SIZE];
int day_array[] = { 31, 28, 31, 30, 31, 30, 31,
31, 30, 31, 30, 31 };
term_def_t *term;
int i;
rptid = SAHPI_UNSPECIFIED_RESOURCE_ID;
term = get_next_term();
if ((term != NULL) && (isdigit(term->term[0]))) {
if (strchr(term->term, ':') != (char *)NULL) {
unget_term();
rptid = SAHPI_UNSPECIFIED_RESOURCE_ID;
} else
rptid = (SaHpiResourceIdT)atoi(term->term);
} else
rptid = SAHPI_UNSPECIFIED_RESOURCE_ID;
if (rptid == SAHPI_UNSPECIFIED_RESOURCE_ID)
printf("Set date and time for Domain Event Log!\n");
else
printf("Set date and time for Resource %d!\n", rptid);
memset(&new_tm_time, 0, sizeof(struct tm));
i = get_string_param("format: MM:DD:YYYY:hh:mm:ss ==> ",
buf, READ_BUF_SIZE);
if (i != 0) return(HPI_SHELL_PARM_ERROR);
sscanf(buf, "%d:%d:%d:%d:%d:%d",
&new_tm_time.tm_mon, &new_tm_time.tm_mday,
&new_tm_time.tm_year, &new_tm_time.tm_hour,
&new_tm_time.tm_min, &new_tm_time.tm_sec);
if ((new_tm_time.tm_mon < 1) || (new_tm_time.tm_mon > 12)) {
printf("Month out of range: (%d)\n", new_tm_time.tm_mon);
return(HPI_SHELL_PARM_ERROR);
};
new_tm_time.tm_mon--;
if (new_tm_time.tm_year < 1900) {
printf("Year out of range: (%d)\n", new_tm_time.tm_year);
return(HPI_SHELL_PARM_ERROR);
};
if (new_tm_time.tm_mon == 1) {
/* if the given year is a leap year */
if ((((new_tm_time.tm_year % 4) == 0)
&& ((new_tm_time.tm_year % 100) != 0))
|| ((new_tm_time.tm_year % 400) == 0))
day_array[1] = 29;
};
if ((new_tm_time.tm_mday < 1) ||
(new_tm_time.tm_mday > day_array[new_tm_time.tm_mon])) {
printf("Day out of range: (%d)\n", new_tm_time.tm_mday);
return(HPI_SHELL_PARM_ERROR);
};
new_tm_time.tm_year -= 1900;
if ((new_tm_time.tm_hour < 0) || (new_tm_time.tm_hour > 24)) {
printf("Hours out of range: (%d)\n", new_tm_time.tm_hour);
return(HPI_SHELL_PARM_ERROR);
};
if ((new_tm_time.tm_min < 0) || (new_tm_time.tm_min > 60)) {
printf("Minutes out of range: (%d)\n", new_tm_time.tm_min);
return(HPI_SHELL_PARM_ERROR);
};
if ((new_tm_time.tm_sec < 0) || (new_tm_time.tm_sec > 60)) {
printf("Seconds out of range: (%d)\n", new_tm_time.tm_sec);
return(HPI_SHELL_PARM_ERROR);
};
newtime = (SaHpiTimeT) mktime(&new_tm_time) * 1000000000;
rv = saHpiEventLogTimeSet(Domain->sessionId, rptid, newtime);
if (rv != SA_OK)
{
printf("saHpiEventLogTimeSet %s\n", oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
}
return (HPI_SHELL_OK);
}
static void parse_samsync_partial_replication_objects(TALLOC_CTX *mem_ctx,
int argc,
const char **argv,
bool *do_single_object_replication,
struct samsync_object **objects,
uint32_t *num_objects)
{
int i;
if (argc > 0) {
*do_single_object_replication = true;
}
for (i=0; i<argc; i++) {
struct samsync_object o;
ZERO_STRUCT(o);
if (!StrnCaseCmp(argv[i], "user_rid=", strlen("user_rid="))) {
o.object_identifier.rid = get_int_param(argv[i]);
o.object_type = NETR_DELTA_USER;
o.database_id = SAM_DATABASE_DOMAIN;
}
if (!StrnCaseCmp(argv[i], "group_rid=", strlen("group_rid="))) {
o.object_identifier.rid = get_int_param(argv[i]);
o.object_type = NETR_DELTA_GROUP;
o.database_id = SAM_DATABASE_DOMAIN;
}
if (!StrnCaseCmp(argv[i], "group_member_rid=", strlen("group_member_rid="))) {
o.object_identifier.rid = get_int_param(argv[i]);
o.object_type = NETR_DELTA_GROUP_MEMBER;
o.database_id = SAM_DATABASE_DOMAIN;
}
if (!StrnCaseCmp(argv[i], "alias_rid=", strlen("alias_rid="))) {
o.object_identifier.rid = get_int_param(argv[i]);
o.object_type = NETR_DELTA_ALIAS;
o.database_id = SAM_DATABASE_BUILTIN;
}
if (!StrnCaseCmp(argv[i], "alias_member_rid=", strlen("alias_member_rid="))) {
o.object_identifier.rid = get_int_param(argv[i]);
o.object_type = NETR_DELTA_ALIAS_MEMBER;
o.database_id = SAM_DATABASE_BUILTIN;
}
if (!StrnCaseCmp(argv[i], "account_sid=", strlen("account_sid="))) {
const char *sid_str = get_string_param(argv[i]);
string_to_sid(&o.object_identifier.sid, sid_str);
o.object_type = NETR_DELTA_ACCOUNT;
o.database_id = SAM_DATABASE_PRIVS;
}
if (!StrnCaseCmp(argv[i], "policy_sid=", strlen("policy_sid="))) {
const char *sid_str = get_string_param(argv[i]);
string_to_sid(&o.object_identifier.sid, sid_str);
o.object_type = NETR_DELTA_POLICY;
o.database_id = SAM_DATABASE_PRIVS;
}
if (!StrnCaseCmp(argv[i], "trustdom_sid=", strlen("trustdom_sid="))) {
const char *sid_str = get_string_param(argv[i]);
string_to_sid(&o.object_identifier.sid, sid_str);
o.object_type = NETR_DELTA_TRUSTED_DOMAIN;
o.database_id = SAM_DATABASE_PRIVS;
}
if (!StrnCaseCmp(argv[i], "secret_name=", strlen("secret_name="))) {
o.object_identifier.name = get_string_param(argv[i]);
o.object_type = NETR_DELTA_SECRET;
o.database_id = SAM_DATABASE_PRIVS;
}
if (o.object_type > 0) {
ADD_TO_ARRAY(mem_ctx, struct samsync_object, o,
objects, num_objects);
}
}
}
/*********************************************************
List the groups.
**********************************************************/
static int net_groupmap_list(struct net_context *c, int argc, const char **argv)
{
size_t entries;
bool long_list = false;
size_t i;
fstring ntgroup = "";
fstring sid_string = "";
const char list_usage_str[] = N_("net groupmap list [verbose] "
"[ntgroup=NT group] [sid=SID]\n"
" verbose\tPrint verbose list\n"
" ntgroup\tNT group to list\n"
" sid\tSID of group to list");
if (c->display_usage) {
d_printf("%s\n%s\n", _("Usage: "), list_usage_str);
return 0;
}
if (c->opt_verbose || c->opt_long_list_entries)
long_list = true;
/* get the options */
for ( i=0; i<argc; i++ ) {
if ( !strcasecmp_m(argv[i], "verbose")) {
long_list = true;
}
else if ( !strncasecmp_m(argv[i], "ntgroup", strlen("ntgroup")) ) {
fstrcpy( ntgroup, get_string_param( argv[i] ) );
if ( !ntgroup[0] ) {
d_fprintf(stderr, _("must supply a name\n"));
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "sid", strlen("sid")) ) {
fstrcpy( sid_string, get_string_param( argv[i] ) );
if ( !sid_string[0] ) {
d_fprintf(stderr, _("must supply a SID\n"));
return -1;
}
}
else {
d_fprintf(stderr, _("Bad option: %s\n"), argv[i]);
d_printf("%s\n%s\n", _("Usage:"), list_usage_str);
return -1;
}
}
/* list a single group is given a name */
if ( ntgroup[0] || sid_string[0] ) {
struct dom_sid sid;
GROUP_MAP *map;
if ( sid_string[0] )
strlcpy(ntgroup, sid_string, sizeof(ntgroup));
if (!get_sid_from_input(&sid, ntgroup)) {
return -1;
}
map = talloc_zero(NULL, GROUP_MAP);
if (!map) {
return -1;
}
/* Get the current mapping from the database */
if(!pdb_getgrsid(map, sid)) {
d_fprintf(stderr,
_("Failure to local group SID in the "
"database\n"));
TALLOC_FREE(map);
return -1;
}
print_map_entry(map, long_list );
TALLOC_FREE(map);
}
else {
GROUP_MAP **maps = NULL;
bool ok = false;
/* enumerate all group mappings */
ok = pdb_enum_group_mapping(NULL, SID_NAME_UNKNOWN,
&maps, &entries,
ENUM_ALL_MAPPED);
if (!ok) {
return -1;
}
for (i=0; i<entries; i++) {
print_map_entry(maps[i], long_list);
}
TALLOC_FREE(maps);
}
return 0;
}
static int net_groupmap_delete(struct net_context *c, int argc, const char **argv)
{
struct dom_sid sid;
fstring ntgroup = "";
fstring sid_string = "";
int i;
const char delete_usage_str[] = N_("net groupmap delete "
"{ntgroup=<string>|sid=<SID>}");
if (c->display_usage) {
d_printf("%s\n%s\n", _("Usage:\n"), delete_usage_str);
return 0;
}
/* get the options */
for ( i=0; i<argc; i++ ) {
if ( !strncasecmp_m(argv[i], "ntgroup", strlen("ntgroup")) ) {
fstrcpy( ntgroup, get_string_param( argv[i] ) );
if ( !ntgroup[0] ) {
d_fprintf(stderr, _("must supply a name\n"));
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "sid", strlen("sid")) ) {
fstrcpy( sid_string, get_string_param( argv[i] ) );
if ( !sid_string[0] ) {
d_fprintf(stderr, _("must supply a SID\n"));
return -1;
}
}
else {
d_fprintf(stderr, _("Bad option: %s\n"), argv[i]);
return -1;
}
}
if ( !ntgroup[0] && !sid_string[0]) {
d_printf("%s\n%s\n", _("Usage:\n"), delete_usage_str);
return -1;
}
/* give preference to the SID if we have that */
if ( sid_string[0] )
strlcpy(ntgroup, sid_string, sizeof(ntgroup));
if ( !get_sid_from_input(&sid, ntgroup) ) {
d_fprintf(stderr, _("Unable to resolve group %s to a SID\n"),
ntgroup);
return -1;
}
if ( !NT_STATUS_IS_OK(pdb_delete_group_mapping_entry(sid)) ) {
d_fprintf(stderr,
_("Failed to remove group %s from the mapping db!\n"),
ntgroup);
return -1;
}
d_printf(_("Sucessfully removed %s from the mapping db\n"), ntgroup);
return 0;
}
static int net_groupmap_modify(struct net_context *c, int argc, const char **argv)
{
struct dom_sid sid;
GROUP_MAP *map = NULL;
fstring ntcomment = "";
fstring type = "";
fstring ntgroup = "";
fstring unixgrp = "";
fstring sid_string = "";
enum lsa_SidType sid_type = SID_NAME_UNKNOWN;
int i;
gid_t gid;
const char modify_usage_str[] = N_("net groupmap modify "
"{ntgroup=<string>|sid=<SID>} "
"[comment=<string>] "
"[unixgroup=<string>] "
"[type=<domain|local>]");
if (c->display_usage) {
d_printf("%s\n%s\n", _("Usage:\n"), modify_usage_str);
return 0;
}
/* get the options */
for ( i=0; i<argc; i++ ) {
if ( !strncasecmp_m(argv[i], "ntgroup", strlen("ntgroup")) ) {
fstrcpy( ntgroup, get_string_param( argv[i] ) );
if ( !ntgroup[0] ) {
d_fprintf(stderr, _("must supply a name\n"));
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "sid", strlen("sid")) ) {
fstrcpy( sid_string, get_string_param( argv[i] ) );
if ( !sid_string[0] ) {
d_fprintf(stderr, _("must supply a name\n"));
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "comment", strlen("comment")) ) {
fstrcpy( ntcomment, get_string_param( argv[i] ) );
if ( !ntcomment[0] ) {
d_fprintf(stderr,
_("must supply a comment string\n"));
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "unixgroup", strlen("unixgroup")) ) {
fstrcpy( unixgrp, get_string_param( argv[i] ) );
if ( !unixgrp[0] ) {
d_fprintf(stderr,
_("must supply a group name\n"));
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "type", strlen("type")) ) {
fstrcpy( type, get_string_param( argv[i] ) );
switch ( type[0] ) {
case 'd':
case 'D':
sid_type = SID_NAME_DOM_GRP;
break;
case 'l':
case 'L':
sid_type = SID_NAME_ALIAS;
break;
}
}
else {
d_fprintf(stderr, _("Bad option: %s\n"), argv[i]);
return -1;
}
}
if ( !ntgroup[0] && !sid_string[0] ) {
d_printf("%s\n%s\n", _("Usage:\n"), modify_usage_str);
return -1;
}
/* give preference to the SID; if both the ntgroup name and SID
are defined, use the SID and assume that the group name could be a
new name */
if ( sid_string[0] ) {
if (!get_sid_from_input(&sid, sid_string)) {
return -1;
}
}
else {
if (!get_sid_from_input(&sid, ntgroup)) {
return -1;
}
}
map = talloc_zero(NULL, GROUP_MAP);
if (!map) {
return -1;
}
/* Get the current mapping from the database */
if(!pdb_getgrsid(map, sid)) {
d_fprintf(stderr,
_("Failed to find local group SID in the database\n"));
TALLOC_FREE(map);
return -1;
}
/*
* Allow changing of group type only between domain and local
* We disallow changing Builtin groups !!! (SID problem)
*/
if (sid_type == SID_NAME_UNKNOWN) {
d_fprintf(stderr, _("Can't map to an unknown group type.\n"));
TALLOC_FREE(map);
return -1;
}
if (map->sid_name_use == SID_NAME_WKN_GRP) {
d_fprintf(stderr,
_("You can only change between domain and local "
"groups.\n"));
TALLOC_FREE(map);
return -1;
}
map->sid_name_use = sid_type;
/* Change comment if new one */
if (ntcomment[0]) {
map->comment = talloc_strdup(map, ntcomment);
if (!map->comment) {
d_fprintf(stderr, _("Out of memory!\n"));
return -1;
}
}
if (ntgroup[0]) {
map->nt_name = talloc_strdup(map, ntgroup);
if (!map->nt_name) {
d_fprintf(stderr, _("Out of memory!\n"));
return -1;
}
}
if ( unixgrp[0] ) {
gid = nametogid( unixgrp );
if ( gid == -1 ) {
d_fprintf(stderr, _("Unable to lookup UNIX group %s. "
"Make sure the group exists.\n"),
unixgrp);
TALLOC_FREE(map);
return -1;
}
map->gid = gid;
}
if (!NT_STATUS_IS_OK(pdb_update_group_mapping_entry(map))) {
d_fprintf(stderr, _("Could not update group database\n"));
TALLOC_FREE(map);
return -1;
}
d_printf(_("Updated mapping entry for %s\n"), map->nt_name);
TALLOC_FREE(map);
return 0;
}
static int net_groupmap_add(struct net_context *c, int argc, const char **argv)
{
struct dom_sid sid;
fstring ntgroup = "";
fstring unixgrp = "";
fstring string_sid = "";
fstring type = "";
fstring ntcomment = "";
enum lsa_SidType sid_type = SID_NAME_DOM_GRP;
uint32 rid = 0;
gid_t gid;
int i;
GROUP_MAP *map;
const char *name_type;
const char add_usage_str[] = N_("net groupmap add "
"{rid=<int>|sid=<string>}"
" unixgroup=<string> "
"[type=<domain|local|builtin>] "
"[ntgroup=<string>] "
"[comment=<string>]");
name_type = "domain group";
if (c->display_usage) {
d_printf("%s\n%s\n", _("Usage:\n"), add_usage_str);
return 0;
}
/* get the options */
for ( i=0; i<argc; i++ ) {
if ( !strncasecmp_m(argv[i], "rid", strlen("rid")) ) {
rid = get_int_param(argv[i]);
if ( rid < DOMAIN_RID_ADMINS ) {
d_fprintf(stderr,
_("RID must be greater than %d\n"),
(uint32)DOMAIN_RID_ADMINS-1);
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "unixgroup", strlen("unixgroup")) ) {
fstrcpy( unixgrp, get_string_param( argv[i] ) );
if ( !unixgrp[0] ) {
d_fprintf(stderr,_( "must supply a name\n"));
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "ntgroup", strlen("ntgroup")) ) {
fstrcpy( ntgroup, get_string_param( argv[i] ) );
if ( !ntgroup[0] ) {
d_fprintf(stderr, _("must supply a name\n"));
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "sid", strlen("sid")) ) {
fstrcpy( string_sid, get_string_param( argv[i] ) );
if ( !string_sid[0] ) {
d_fprintf(stderr, _("must supply a SID\n"));
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "comment", strlen("comment")) ) {
fstrcpy( ntcomment, get_string_param( argv[i] ) );
if ( !ntcomment[0] ) {
d_fprintf(stderr,
_("must supply a comment string\n"));
return -1;
}
}
else if ( !strncasecmp_m(argv[i], "type", strlen("type")) ) {
fstrcpy( type, get_string_param( argv[i] ) );
switch ( type[0] ) {
case 'b':
case 'B':
sid_type = SID_NAME_WKN_GRP;
name_type = "wellknown group";
break;
case 'd':
case 'D':
sid_type = SID_NAME_DOM_GRP;
name_type = "domain group";
break;
case 'l':
case 'L':
sid_type = SID_NAME_ALIAS;
name_type = "alias (local) group";
break;
default:
d_fprintf(stderr,
_("unknown group type %s\n"),
type);
return -1;
}
}
else {
d_fprintf(stderr, _("Bad option: %s\n"), argv[i]);
return -1;
}
}
if ( !unixgrp[0] ) {
d_printf("%s\n%s\n", _("Usage:\n"), add_usage_str);
return -1;
}
if ( (gid = nametogid(unixgrp)) == (gid_t)-1 ) {
d_fprintf(stderr, _("Can't lookup UNIX group %s\n"), unixgrp);
return -1;
}
map = talloc_zero(NULL, GROUP_MAP);
if (!map) {
return -1;
}
/* Default is domain group. */
map->sid_name_use = SID_NAME_DOM_GRP;
if (pdb_getgrgid(map, gid)) {
d_printf(_("Unix group %s already mapped to SID %s\n"),
unixgrp, sid_string_tos(&map->sid));
TALLOC_FREE(map);
return -1;
}
TALLOC_FREE(map);
if ( (rid == 0) && (string_sid[0] == '\0') ) {
d_printf(_("No rid or sid specified, choosing a RID\n"));
if (pdb_capabilities() & PDB_CAP_STORE_RIDS) {
if (!pdb_new_rid(&rid)) {
d_printf(_("Could not get new RID\n"));
}
} else {
rid = algorithmic_pdb_gid_to_group_rid(gid);
}
d_printf(_("Got RID %d\n"), rid);
}
/* append the rid to our own domain/machine SID if we don't have a full SID */
if ( !string_sid[0] ) {
sid_compose(&sid, get_global_sam_sid(), rid);
sid_to_fstring(string_sid, &sid);
}
if (!ntcomment[0]) {
switch (sid_type) {
case SID_NAME_WKN_GRP:
fstrcpy(ntcomment, "Wellknown Unix group");
break;
case SID_NAME_DOM_GRP:
fstrcpy(ntcomment, "Domain Unix group");
break;
case SID_NAME_ALIAS:
fstrcpy(ntcomment, "Local Unix group");
break;
default:
fstrcpy(ntcomment, "Unix group");
break;
}
}
if (!ntgroup[0] )
strlcpy(ntgroup, unixgrp, sizeof(ntgroup));
if (!NT_STATUS_IS_OK(add_initial_entry(gid, string_sid, sid_type, ntgroup, ntcomment))) {
d_fprintf(stderr, _("adding entry for group %s failed!\n"), ntgroup);
return -1;
}
d_printf(_("Successfully added group %s to the mapping db as a %s\n"),
ntgroup, name_type);
return 0;
}
static int net_dom_unjoin(struct net_context *c, int argc, const char **argv)
{
const char *server_name = NULL;
const char *account = NULL;
const char *password = NULL;
uint32_t unjoin_flags = NETSETUP_ACCT_DELETE |
NETSETUP_JOIN_DOMAIN |
NETSETUP_IGNORE_UNSUPPORTED_FLAGS;
struct cli_state *cli = NULL;
bool do_reboot = false;
NTSTATUS ntstatus;
NET_API_STATUS status;
int ret = -1;
int i;
if (argc < 1 || c->display_usage) {
return net_dom_usage(c, argc, argv);
}
if (c->opt_host) {
server_name = c->opt_host;
}
for (i=0; i<argc; i++) {
if (strnequal(argv[i], "account", strlen("account"))) {
account = get_string_param(argv[i]);
if (!account) {
return -1;
}
}
if (strnequal(argv[i], "password", strlen("password"))) {
password = get_string_param(argv[i]);
if (!password) {
return -1;
}
}
if (strequal(argv[i], "reboot")) {
do_reboot = true;
}
}
if (do_reboot) {
ntstatus = net_make_ipc_connection_ex(c, c->opt_workgroup,
server_name, NULL, 0,
&cli);
if (!NT_STATUS_IS_OK(ntstatus)) {
return -1;
}
}
status = NetUnjoinDomain(server_name, account, password, unjoin_flags);
if (status != 0) {
printf("Failed to unjoin domain: %s\n",
libnetapi_get_error_string(c->netapi_ctx, status));
goto done;
}
if (do_reboot) {
c->opt_comment = "Shutting down due to a domain membership "
"change";
c->opt_reboot = true;
c->opt_timeout = 30;
ret = run_rpc_command(c, cli,
&ndr_table_initshutdown.syntax_id,
0, rpc_init_shutdown_internals,
argc, argv);
if (ret == 0) {
goto done;
}
ret = run_rpc_command(c, cli, &ndr_table_winreg.syntax_id, 0,
rpc_reg_shutdown_internals,
argc, argv);
goto done;
}
ret = 0;
done:
if (cli) {
cli_shutdown(cli);
}
return ret;
}
int main(int argc, char **argv)
{
/* Parameter check */
const char *printdb_path = NULL;
if (argc < 2) {
usage();
return 1;
}
if (strncmp(argv[1], "tdbfile", strlen("tdbfile")) != 0) {
usage();
return 1;
}
printdb_path = get_string_param(argv[1]);
if (!printdb_path) {
return 1;
}
if (!(tdb = tdb_open(printdb_path, 0, 0, O_RDWR | O_CREAT,
0666))) {
printf("%s: unable to open %s\n", argv[0], printdb_path);
return 1;
}
/* Ensure we are modes 666 */
chmod(printdb_path, 0666);
/* Do commands */
if (strcmp(argv[2], "lpq") == 0) {
return lpq_command(argc - 2, &argv[2]);
}
if (strcmp(argv[2], "lprm") == 0) {
return lprm_command(argc - 2, &argv[2]);
}
if (strcmp(argv[2], "print") == 0) {
return print_command(argc - 2, &argv[2]);
}
if (strcmp(argv[2], "queuepause") == 0) {
return queuepause_command(argc - 2, &argv[2]);
}
if (strcmp(argv[2], "queueresume") == 0) {
return queueresume_command(argc - 2, &argv[2]);
}
if (strcmp(argv[2], "lppause") == 0) {
return lppause_command(argc - 2, &argv[2]);
}
if (strcmp(argv[2], "lpresume") == 0) {
return lpresume_command(argc - 2, &argv[2]);
}
/* Unknown command */
printf("%s: invalid command %s\n", argv[0], argv[1]);
return 1;
}
static ret_code_t set_control_state(SaHpiSessionIdT sessionid,
SaHpiResourceIdT resourceid, SaHpiCtrlNumT num)
{
SaErrorT rv;
SaHpiRdrT rdr;
SaHpiCtrlRecT *ctrl;
SaHpiCtrlTypeT type;
SaHpiCtrlStateDigitalT state_val = 0;
SaHpiCtrlModeT mode;
SaHpiCtrlStateT state;
char buf[SAHPI_MAX_TEXT_BUFFER_LENGTH];
char *str;
int i, res;
rv = saHpiRdrGetByInstrumentId(sessionid, resourceid, SAHPI_CTRL_RDR,
num, &rdr);
if (rv != SA_OK) {
printf("saHpiRdrGetByInstrumentId: error: %s\n", oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
memset(&state, 0, sizeof(SaHpiCtrlStateT));
i = get_string_param("Mode(auto|manual): ", buf, 7);
if (i != 0) return(HPI_SHELL_CMD_ERROR);
if (strcmp(buf, "auto") == 0) mode = SAHPI_CTRL_MODE_AUTO;
else if (strcmp(buf, "manual") == 0) mode = SAHPI_CTRL_MODE_MANUAL;
else return(HPI_SHELL_CMD_ERROR);
if (mode == SAHPI_CTRL_MODE_AUTO) {
rv = saHpiControlSet(sessionid, resourceid, num,
mode, (SaHpiCtrlStateT *)NULL);
if (rv != SA_OK) {
printf("saHpiControlSet: error: %s\n",
oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
return(HPI_SHELL_OK);
};
ctrl = &(rdr.RdrTypeUnion.CtrlRec);
type = ctrl->Type;
state.Type = type;
switch (type) {
case SAHPI_CTRL_TYPE_DIGITAL:
i = get_string_param(
"New state(on|off|pulseon|pulseoff): ", buf, 9);
if (i != 0) return(HPI_SHELL_CMD_ERROR);
if (strcmp(buf, "on") == 0) state_val = SAHPI_CTRL_STATE_ON;
if (strcmp(buf, "off") == 0) state_val = SAHPI_CTRL_STATE_OFF;
if (strcmp(buf, "pulseon") == 0)
state_val = SAHPI_CTRL_STATE_PULSE_ON;
if (strcmp(buf, "pulseoff") == 0)
state_val = SAHPI_CTRL_STATE_PULSE_OFF;
state.StateUnion.Digital = state_val;
break;
case SAHPI_CTRL_TYPE_DISCRETE:
i = get_int_param("Value ==> ", &res);
if (i != 1) {
printf("Invalid value\n");
return HPI_SHELL_CMD_ERROR;
};
state.StateUnion.Discrete = res;
break;
case SAHPI_CTRL_TYPE_ANALOG:
i = get_int_param("Value ==> ", &res);
if (i != 1) {
printf("Invalid value\n");
return HPI_SHELL_CMD_ERROR;
};
state.StateUnion.Analog = res;
break;
case SAHPI_CTRL_TYPE_STREAM:
i = get_string_param("Repeat(yes|no): ", buf, 4);
if (i != 0) return(HPI_SHELL_CMD_ERROR);
str = buf;
while (*str == ' ') str++;
if (strncmp(str, "yes", 3) == 0)
state.StateUnion.Stream.Repeat = 1;
i = get_string_param("Stream: ", buf, 4);
i = strlen(buf);
if (i > 4) i = 4;
state.StateUnion.Stream.StreamLength = i;
strncpy((char *)(state.StateUnion.Stream.Stream), buf, i);
break;
case SAHPI_CTRL_TYPE_TEXT:
i = get_int_param("Line #: ", &res);
if (i != 1) {
printf("Invalid value\n");
return HPI_SHELL_CMD_ERROR;
};
state.StateUnion.Text.Line = res;
printf("Text: ");
i = set_text_buffer(&(state.StateUnion.Text.Text));
if (i != 0) {
printf("Invalid text\n");
return(HPI_SHELL_CMD_ERROR);
};
break;
case SAHPI_CTRL_TYPE_OEM:
i = get_int_param("Manufacturer Id: ", &res);
if (i != 1) {
printf("Invalid value\n");
return HPI_SHELL_CMD_ERROR;
};
state.StateUnion.Oem.MId = res;
memset(state.StateUnion.Oem.Body, 0,
SAHPI_CTRL_MAX_OEM_BODY_LENGTH);
i = get_hex_string_param("Oem body: ",
(char *)(state.StateUnion.Oem.Body),
SAHPI_CTRL_MAX_OEM_BODY_LENGTH);
state.StateUnion.Oem.BodyLength = i;
break;
default:
strcpy(buf, "Unknown control type\n");
return(HPI_SHELL_CMD_ERROR);
};
rv = saHpiControlSet(sessionid, resourceid, num,
SAHPI_CTRL_MODE_MANUAL, &state);
if (rv != SA_OK) {
printf("saHpiControlSet: error: %s\n",
oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
return(HPI_SHELL_OK);
}
int set_text_buffer(SaHpiTextBufferT *buf)
{
int i, j, ind;
char str[SAHPI_MAX_TEXT_BUFFER_LENGTH], *str1;
SaHpiTextTypeT type = SAHPI_TL_TYPE_TEXT;
SaHpiLanguageT lang = SAHPI_LANG_ENGLISH;
i = get_string_param("DataType(text|bcd|ascii6|bin|unicode): ", str, 10);
if (i != 0) return(-1);
if (strcmp(str, "text") == 0) type = SAHPI_TL_TYPE_TEXT;
else if (strcmp(str, "bcd") == 0) type = SAHPI_TL_TYPE_BCDPLUS;
else if (strcmp(str, "ascii6") == 0) type = SAHPI_TL_TYPE_ASCII6;
else if (strcmp(str, "bin") == 0) type = SAHPI_TL_TYPE_BINARY;
else if (strcmp(str, "unicode") == 0) type = SAHPI_TL_TYPE_UNICODE;
/*
* ask a language for unicode and text: Fix me
*/
i = get_string_param("Text: ", str, SAHPI_MAX_TEXT_BUFFER_LENGTH);
if (i != 0) return(-1);
buf->DataType = type;
switch (type) {
case SAHPI_TL_TYPE_UNICODE:
printf("UNICODE: not implemented");
return(-1);
case SAHPI_TL_TYPE_BCDPLUS:
str1 = (char *)&(buf->Data);
ind = 0;
for (i = 0; i < strlen(str); i++) {
for (j = 0; j < 0x0D; j++)
if (bcdplus_codes[j] == str[i]) break;
if (j >= 0x0D) return(-1);
if (i % 2) str1[ind++] += j << 4;
else str1[ind] = j;
};
buf->DataLength = (i + 1)/ 2;
break;
case SAHPI_TL_TYPE_ASCII6:
i = stringtoascii6(str, (char *)&(buf->Data));
if (i < 0) return(-1);
buf->DataLength = i;
break;
case SAHPI_TL_TYPE_TEXT:
snprintf((char *)&(buf->Data), SAHPI_MAX_TEXT_BUFFER_LENGTH, "%s", str);
buf->DataLength = strlen(str);
buf->Language = lang;
break;
case SAHPI_TL_TYPE_BINARY:
str1 = (char *)&(buf->Data);
ind = 0;
for (i = 0; i < strlen(str); i++) {
for (j = 0; j < 16; j++)
if (hex_codes[j] == toupper(str[i])) break;
if (j >= 16) return(-1);
if (i % 2) str1[ind++] += j;
else str1[ind] = j << 4;
};
buf->DataLength = (i + 1)/ 2;
break;
};
return(0);
}
static ret_code_t add_announ(SaHpiResourceIdT rptid, SaHpiInstrumentIdT rdrnum)
{
SaErrorT rv;
char str[32];
int i;
SaHpiSeverityT sev = SAHPI_OK;
SaHpiAnnouncementT announ;
SaHpiStatusCondTypeT type = SAHPI_STATUS_COND_TYPE_SENSOR;
SaHpiDomainIdT did;
SaHpiResourceIdT resId;
SaHpiSensorNumT sennum = 0;
memset(&announ, 0, sizeof(SaHpiAnnouncementT));
i = get_string_param("Severity(crit|maj|min|info|ok): ",
str, 10);
if (i != 0) return(HPI_SHELL_PARM_ERROR);
if (strcmp(str, "crit") == 0) sev = SAHPI_CRITICAL;
else if (strcmp(str, "maj") == 0) sev = SAHPI_MAJOR;
else if (strcmp(str, "min") == 0) sev = SAHPI_MINOR;
else if (strcmp(str, "info") == 0) sev = SAHPI_INFORMATIONAL;
else if (strcmp(str, "ok") == 0) sev = SAHPI_OK;
else {
printf("Invalid severity %s\n", str);
return(HPI_SHELL_PARM_ERROR);
};
announ.Severity = sev;
memset(&announ, 0, sizeof(SaHpiAnnouncementT));
i = get_string_param("Condition Type(sensor|res|oem|user): ",
str, 10);
if (i != 0) return(-1);
if (strcmp(str, "sensor") == 0) type = SAHPI_STATUS_COND_TYPE_SENSOR;
else if (strcmp(str, "res") == 0) type = SAHPI_STATUS_COND_TYPE_RESOURCE;
else if (strcmp(str, "oem") == 0) type = SAHPI_STATUS_COND_TYPE_OEM;
else if (strcmp(str, "user") == 0) type = SAHPI_STATUS_COND_TYPE_USER;
else {
printf("Invalid Condition Type %s\n", str);
return(HPI_SHELL_PARM_ERROR);
};
announ.StatusCond.Type = type;
// EntityPath: is needed ???
// oh_encode_entitypath(char *str, SaHpiEntityPathT *ep); convert string into ep.
i = get_int_param("DomainId: ", (int *)&did);
if (i != 1) did = SAHPI_UNSPECIFIED_DOMAIN_ID;
announ.StatusCond.DomainId = did;
i = get_int_param("ResourceId: ", (int *)&resId);
if (i != 1) resId = SAHPI_UNSPECIFIED_RESOURCE_ID;
announ.StatusCond.ResourceId = resId;
i = get_int_param("Sensor number: ", (int *)&sennum);
announ.StatusCond.SensorNum = sennum;
rv = saHpiAnnunciatorAdd(Domain->sessionId, rptid, rdrnum, &announ);
if (rv != SA_OK) {
printf("saHpiAnnunciatorAdd error %s\n", oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
return HPI_SHELL_OK;
}
