/*
* la_objopen() caller. Create an audit information structure for the indicated
* link-map, regardless of an la_objopen() entry point. This structure is used
* to supply information to various audit interfaces (see LML_MSK_AUDINFO).
* Traverse through all audit libraries and call any la_objopen() entry points
* found.
*/
static int
_audit_objopen(APlist *list, Rt_map *nlmp, Lmid_t lmid, Audit_info *aip,
int *ndx)
{
Lm_list *nlml = LIST(nlmp);
Audit_list *alp;
Aliste idx;
for (APLIST_TRAVERSE(list, idx, alp)) {
uint_t flags;
Audit_client *acp;
Rt_map *almp = alp->al_lmp;
Lm_list *alml = LIST(almp);
/*
* Associate a cookie with the audit library, and assign the
* initial cookie as the present link-map.
*/
acp = &aip->ai_clients[(*ndx)++];
acp->ac_lmp = alp->al_lmp;
acp->ac_cookie = (uintptr_t)nlmp;
if (alp->al_objopen == NULL)
continue;
DBG_CALL(Dbg_audit_objopen(nlml, DBG_AUD_CALL, alp->al_libname,
NAME(nlmp), 0, FALSE));
leave(alml, thr_flg_reenter);
flags = (*alp->al_objopen)((Link_map *)nlmp, lmid,
&(acp->ac_cookie));
(void) enter(thr_flg_reenter);
/*
* Diagnose any flags returned by the auditor.
*/
if (flags) {
DBG_CALL(Dbg_audit_objopen(nlml, DBG_AUD_RET,
alp->al_libname, NAME(nlmp), flags, FALSE));
}
if (flags & LA_FLG_BINDTO)
acp->ac_flags |= FLG_AC_BINDTO;
if (flags & LA_FLG_BINDFROM) {
ulong_t pltcnt;
acp->ac_flags |= FLG_AC_BINDFROM;
/*
* We only need dynamic plt's if a pltenter and/or a
* pltexit() entry point exist in one of our auditing
* libraries.
*/
if (aip->ai_dynplts || (JMPREL(nlmp) == 0) ||
((audit_flags & (AF_PLTENTER | AF_PLTEXIT)) == 0))
continue;
/*
* Create one dynplt for every 'PLT' that exists in the
* object.
*/
pltcnt = PLTRELSZ(nlmp) / RELENT(nlmp);
if ((aip->ai_dynplts = calloc(pltcnt,
dyn_plt_ent_size)) == NULL)
return (0);
}
}
return (1);
}
void GoCodeFormatter::recalculateStateAfter(const QTextBlock &block)
{
restoreCurrentState(block.previous());
const LexerState lexerState(tokenizeBlock(block));
m_newStates.clear();
int currentState;
for (m_index = 0; m_index < m_tokens.count(); ++m_index) {
currentState = m_currentState.top().state;
m_tk = m_tokens.at(m_index);
switch (currentState) {
case TopMost:
tryDeclaration();
break;
case PackageClause:
switch (m_tk.kind()) {
case T_IDENTIFIER: leave(); break;
default: break;
}
break;
case ImportDecl:
switch (m_tk.kind()) {
case T_LPAREN: enter(ImportOpen); break;
case T_STRING: leave(); break;
default: break;
}
break;
case ImportOpen:
switch (m_tk.kind()) {
case T_RPAREN: leave(); leave(); break;
default: break;
}
break;
case InterfaceDecl:
switch (m_tk.kind()) {
case T_LBRACE: enter(InterfaceOpen); break;
default: break;
}
break;
case InterfaceOpen:
switch (m_tk.kind()) {
case T_RBRACE: leave(); leave(); break;
default: break;
}
break;
case StructDecl:
switch (m_tk.kind()) {
case T_LBRACE: enter(StructOpen); break;
default: break;
}
break;
case StructOpen:
switch (m_tk.kind()) {
case T_RBRACE: leave(); leave(); break;
default: break;
}
break;
case TypeDecl:
switch (m_tk.kind()) {
case T_LPAREN: enter(TypeOpen); break;
case T_INTERFACE: leave(); enter(InterfaceDecl); break;
case T_STRUCT: leave(); enter(StructDecl); break;
default: leave(); break;
}
break;
case TypeOpen:
switch (m_tk.kind()) {
case T_INTERFACE: leave(); enter(InterfaceDecl); break;
case T_STRUCT: enter(StructDecl); break;
case T_RPAREN: leave(); leave(); break;
default: break;
}
break;
case IdentDecl:
leave(); break; // TODO: implement
/*
switch (m_tk.kind()) {
case T_LPAREN: enter(IdentArgs); break;
case T_LBRACE: enter(IdentFields); break;
default: leave(); break;
}
break;
case IdentArgs:
switch (m_tk.kind()) {
case T_RPAREN: leave(); break;
default: break;
}
break;
case IdentFields:
switch (m_tk.kind()) {
case T_RBRACE: leave(); break;
default: break;
}
break;*/
case ConstDecl:
leave(); break; // TODO: implement
case VarDecl:
leave(); break; // TODO: implement
/*
switch (m_tk.kind()) {
case T_LPAREN: enter(VarOpen); break;
case T_EQUAL: enter(VarExpr); break;
default: break;
}
break;
case VarOpen:
switch (m_tk.kind()) {
case T_RPAREN: leave(); leave(); break;
default: if (!tryDeclaration()) leave(); break;
}
break;
case VarExpr:
if (tryDeclaration())
break;
else
leave();
break;*/
case FuncDecl:
switch (m_tk.kind()) {
case T_LBRACE: enter(FuncOpen); break;
case T_LPAREN: enter(FuncParams); break;
default: break;
}
break;
case FuncOpen:
switch (m_tk.kind()) {
case T_RBRACE: leave(); leave(); break;
default: tryStatement(); break;
}
break;
case FuncParams:
switch (m_tk.kind()) {
case T_RPAREN: leave(); break;
default: break;
}
break;
case BlockOpen:
switch (m_tk.kind()) {
case T_RBRACE: leave(); break;
default: tryStatement(); break;
}
break;
case GroupOpen:
switch (m_tk.kind()) {
case T_RPAREN: leave(); break;
default: tryStatement(); break;
}
break;
case ForStmt:
switch (m_tk.kind()) {
case T_LBRACE: enter(ForOpen); break;
default: break;
}
break;
case ForOpen:
// TODO: parse arguments
switch (m_tk.kind()) {
case T_RBRACE: leave(); leave(); break;
default: tryStatement(); break;
}
break;
case IfStmt:
switch (m_tk.kind()) {
case T_LBRACE: enter(IfOpen); break;
default: break;
}
break;
case IfOpen:
// TODO: parse arguments
switch (m_tk.kind()) {
case T_RBRACE: leave(); leave(); break;
default: tryStatement(); break;
}
break;
case SwitchStmt:
switch (m_tk.kind()) {
case T_LBRACE: enter(SwitchOpen); break;
default: break;
}
break;
case SwitchOpen:
switch (m_tk.kind()) {
case T_RBRACE: leave(); leave(); break;
case T_DEFAULT:
case T_CASE: enter(CaseClause); break;
default: break;
}
break;
case CaseClause:
switch (m_tk.kind()) {
case T_COLON: leave(); enter(CaseOpen); break;
default: break;
}
break;
case CaseOpen:
switch (m_tk.kind()) {
case T_DEFAULT:
case T_CASE: leave(); enter(CaseClause); break;
case T_RBRACE: leave(); leave(); leave(); break;
default: tryStatement(); break;
}
break;
case Label:
switch (m_tk.kind()) {
case T_COLON: leave(); break;
default: leave(); continue; // shouldn't happen
} break;
case MultilineCommentStart:
case MultilineCommentCont:
if (m_tk.kind() != T_COMMENT) {
leave();
continue;
} else if (m_index == m_tokens.size() - 1
&& lexerState.multiLine() == LexerState::NoMultiLine) {
leave();
} else if (m_index == 0 && m_tk.is(T_COMMENT)) {
// to allow enter/leave to update the indentDepth
leave();
enter(MultilineCommentCont);
}
break;
default:
break;
}
}
currentState = m_currentState.top().state;
if (currentState != MultilineCommentStart
&& currentState != MultilineCommentCont
&& (lexerState.multiLine() == LexerState::MultiLineComment)) {
enter(MultilineCommentStart);
}
saveCurrentState(block);
}
tuple(const obj& o)noexcept(!PY11_ENFORCE)
{
type_check(o);
enter(o.p());
}
/*
* la_objopen() caller for the head link-map. Global auditors, or an auditor
* started from the object that heads a link-map list (typically the dynamic
* executable), are passed to la_objopen(). However, local auditors can
* provide activity and preinit events, and for these events, a cookie
* representing the head link-map list object is expected. This routine obtains
* these cookies from the link-map list lm_cookies element. This element
* ensures all clients of the same auditor use the same cookie.
*
* Although a local auditor will get an la_objopen() call for the object that
* heads the link-map list of the object being audited, the auditor is not
* permitted to request binding information for this head object. The head
* object has already been in existence, and bindings may have been resolved
* with it. This local auditor is coming into existence too late, and thus we
* don't allow any bindings to be caught at all.
*/
static int
_audit_add_head(Rt_map *clmp, Rt_map *hlmp, int preinit, int activity)
{
Lm_list *clml = LIST(clmp);
Lmid_t lmid = get_linkmap_id(clml);
Audit_list *alp;
Aliste idx;
int save = 0;
for (APLIST_TRAVERSE(AUDITORS(clmp)->ad_list, idx, alp)) {
Audit_client *acp;
Rt_map *almp = alp->al_lmp;
Lm_list *alml = LIST(almp);
uintptr_t *cookie;
uint_t rtldflags;
/*
* Ensure this local auditor isn't already in existence as an
* auditor for the head of the link-map list. If it is, then
* this auditor will have already receive preinit and activity
* events.
*/
if (AUDITORS(hlmp) && _audit_used_by_head(hlmp, almp))
continue;
/*
* Create a cookie that represents the object that heads the
* link-map list. If the cookie already exists, then this
* auditor has already been established for another objects
* local auditing. In this case, do not issue a la_objopen()
* or la_activity() event, as these will have already occurred.
*/
if ((acp = _audit_get_head_client(clml->lm_head, almp)) != NULL)
continue;
if ((acp =
_audit_create_head_client(clml->lm_head, almp)) == NULL)
return (0);
cookie = &(acp->ac_cookie);
save++;
/*
* Call the la_objopen() if available.
*/
if (alp->al_objopen) {
uint_t flags;
DBG_CALL(Dbg_audit_objopen(clml, DBG_AUD_CALL,
alp->al_libname, NAME(hlmp), 0, FALSE));
APPLICATION_ENTER(rtldflags);
leave(alml, thr_flg_reenter);
flags = (*alp->al_objopen)((Link_map *)hlmp, lmid,
cookie);
(void) enter(thr_flg_reenter);
APPLICATION_RETURN(rtldflags);
if (flags) {
DBG_CALL(Dbg_audit_objopen(clml, DBG_AUD_RET,
alp->al_libname, NAME(hlmp), flags, TRUE));
}
}
/*
* Call the la_activity() if available.
*/
if (alp->al_activity) {
alml->lm_flags |= LML_FLG_AUDITNOTIFY;
clml->lm_flags |= LML_FLG_ACTAUDIT;
DBG_CALL(Dbg_audit_activity(clml, alp->al_libname,
NAME(clml->lm_head), LA_ACT_ADD));
APPLICATION_ENTER(rtldflags);
leave(alml, thr_flg_reenter);
(*alp->al_activity)(cookie, LA_ACT_ADD);
(void) enter(thr_flg_reenter);
APPLICATION_RETURN(rtldflags);
}
}
/*
* If new head link-map cookies have been generated, then maintain
* any preinit and/or activity requirements.
*/
if (save) {
if (preinit && (aplist_append(&aud_preinit, clmp,
AL_CNT_AUDITORS) == NULL))
return (0);
if (activity && (aplist_append(&aud_activity, clmp,
AL_CNT_AUDITORS) == NULL))
return (0);
}
return (1);
}
NodeBase* NodeJsonGet::run(base_script_t* param) {
IVR_TRACE("%s", enter(param->name_var_map).c_str());
const char* exit = EXIT_FAIL;
std::string value = "";
std::string input = "";
std::string key = "";
variable_t var_value;
variable_t var_reason;
std::string reason_type_error = "reason type error";
var_value.pvalue = &reason_type_error;
var_reason.pvalue = &reason_type_error;
if (param->name_var_map.find(_value) == param->name_var_map.end()) {
IVR_WARN("not found variable %s", _value.c_str());
goto LEAVE;
}
if (param->name_var_map.find(_reason) == param->name_var_map.end()) {
IVR_WARN("not found variable %s", _reason.c_str());
goto LEAVE;
}
var_value = param->name_var_map[_value];
var_reason = param->name_var_map[_reason];
if (var_reason.type != INT32) {
IVR_WARN("变量%s 的类型错误", _reason.c_str());
//(*(std::string*)var_reason.pvalue).assign("5");
goto LEAVE;
}
(*(std::string*)var_reason.pvalue).assign("0");
if (parse_all(_input, param->name_var_map, input) && parse_all(_key, param->name_var_map, key)) {
IVR_TRACE("INPUT: %s; key: %s", input.c_str(), key.c_str());
//获取json串
json_object* obj = json_tokener_parse(input.c_str());
if (is_error(obj) || NULL == obj) {
IVR_TRACE("未找到需要赋值的变量");
(*(std::string*)var_reason.pvalue).assign("1");
goto LEAVE;
}
const char* tmp = json_object_get_string(obj);
if (tmp[0] >= '0' && tmp[0] <= '9') {
IVR_TRACE("未找到需要赋值的变量");
(*(std::string*)var_reason.pvalue).assign("1");
json_object_put(obj);
goto LEAVE;
}
//查找key
json_object* obj_value = json_object_object_get(obj, key.c_str());
if (is_error(obj_value) || NULL == obj_value) {
IVR_TRACE("未找到key值");
(*(std::string*)var_reason.pvalue).assign("2");
json_object_put(obj);
goto LEAVE;
}
//根据需要转化
if (0 == strcasecmp(_valuetype.c_str(), PARAMITEM_TYPE_STRING)) {
const char* cstr_value = json_object_get_string(obj_value);
if (NULL == cstr_value) {
IVR_TRACE("转换key值错误");
(*(std::string*)var_reason.pvalue).assign("3");
json_object_put(obj);
//json_object_put(obj_value);
goto LEAVE;
}
if (var_value.type != STRING) {
IVR_TRACE("赋值变量类型错误");
(*(std::string*)var_reason.pvalue).assign("4");
json_object_put(obj);
//json_object_put(obj_value);
goto LEAVE;
}
value.assign(cstr_value);
*(string*)var_value.pvalue = value;
exit = EXIT_SUCC;
json_object_put(obj);
goto LEAVE;
} else if (0 == strcasecmp(_valuetype.c_str(), PARAMITEM_TYPE_INT32)) {
int32_t int32_value = json_object_get_int(obj_value);
if (var_value.type != INT32) {
IVR_TRACE("赋值变量类型错误");
(*(std::string*)var_reason.pvalue).assign("4");
json_object_put(obj);
//json_object_put(obj_value);
goto LEAVE;
}
std::stringstream ss;
ss << int32_value;
ss >> value;
*(string*)var_value.pvalue = value;
exit = EXIT_SUCC;
json_object_put(obj);
goto LEAVE;
} else if (0 == strcasecmp(_valuetype.c_str(), PARAMITEM_TYPE_BOOL)) {
void LineEditFocusWidget::focusInEvent(QFocusEvent *e)
{
QLineEdit::focusInEvent(e);
emit(enter());
}
int block(int value)
{
int error = value;
int num_variables = 0;
//Finds constants in the beginning (not working)******
if (tokenValues[i] == constsym)
{
do
{
i++;
if (tokenValues[i] != identsym)
{
addError(4);
error = 1;
}
i++;
if (tokenValues[i] != eqsym)
{
if (tokenValues[i] == becomessym)
addError(1);
else
addError(3);
error = 1;
}
i++;
if (tokenValues[i] != numbersym)
{
addError(2);
error = 1;
}
i++;
enter(1, tokenTable[i-3], numberValues[i-1], 0);
} while (tokenValues[i] == commasym);
if (tokenValues[i] != semicolonsym)
{
addError(5);
error = 1;
}
i++;
}
//Finds ints in the beginning, there currently is storage of these
if (tokenValues[i] == intsym)
{
do
{
i++;
if (tokenValues[i] != identsym)
{
addError(4);
error = 1;
}
i++;
enter(2, tokenTable[i-1], level, num_variables+1);
num_variables++;
} while (tokenValues[i] == commasym);
if (tokenValues[i] != semicolonsym)
{
addError(5);
error = 1;
}
i++;
}
int tempcx;
//Finds procedures, currently does nothing and you don't need to mess with
while (tokenValues[i] == procsym)
{
i++;
if (tokenValues[i] != identsym)
{
addError(4);
error = 1;
}
enter(3, tokenTable[i], level, cx);
i++;
if (tokenValues[i] != semicolonsym)
{
addError(5);
error = 1;
}
i++;
tempcx = cx;
emit(jmp, 0, 0);
level++;
error = block(error);
if (tokenValues[i] != semicolonsym)
{
addError(5);
error = 1;
}
i++;
emit(opr, 0, 0);
}
code[tempcx].m = cx;
emit(inc, 0, num_variables+4); //Use to allocate space in the beggining of the AR
error = statement(error);
level--;
return error;
}
/*
* la_symbind() caller. Traverses through all audit library and calls any
* la_symbind() entry points found.
*/
static Addr
_audit_symbind(List *list, Rt_map *rlmp, Rt_map *dlmp, Sym *sym, uint_t ndx,
uint_t *flags, int *called)
{
Audit_list *alp;
Listnode *lnp;
#if defined(_ELF64)
const char *name = (const char *)(sym->st_name + STRTAB(dlmp));
#else
const char *name = (const char *)(sym->st_name);
#endif
for (LIST_TRAVERSE(list, lnp, alp)) {
Audit_client *racp, *dacp;
Addr prev = sym->st_value;
uint_t lflags;
if (alp->al_symbind == 0)
continue;
if ((racp = _audit_client(AUDINFO(rlmp), alp->al_lmp)) == 0)
continue;
if ((dacp = _audit_client(AUDINFO(dlmp), alp->al_lmp)) == 0)
continue;
if (((racp->ac_flags & FLG_AC_BINDFROM) == 0) ||
((dacp->ac_flags & FLG_AC_BINDTO) == 0))
continue;
/*
* The la_symbind interface is only called when the calling
* object has been identified as BINDFROM, and the destination
* object has been identified as BINDTO. Use a local version of
* the flags, so that any user update can be collected.
*/
called++;
lflags = (*flags & ~(LA_SYMB_NOPLTENTER | LA_SYMB_NOPLTEXIT));
leave(LIST(alp->al_lmp));
sym->st_value = (*alp->al_symbind)(sym, ndx,
&(racp->ac_cookie), &(dacp->ac_cookie),
#if defined(_ELF64)
&lflags, name);
#else
&lflags);
#endif
(void) enter();
/*
* If the auditor indicated that they did not want to process
* pltenter, or pltexit audits for this symbol, retain this
* information. Also retain whether an alternative symbol value
* has been supplied.
*/
*flags |= (lflags & (LA_SYMB_NOPLTENTER | LA_SYMB_NOPLTEXIT));
if ((prev != sym->st_value) && (alp->al_vernum >= LAV_VERSION2))
*flags |= LA_SYMB_ALTVALUE;
DBG_CALL(Dbg_audit_symval(LIST(alp->al_lmp), alp->al_libname,
MSG_ORIG(MSG_AUD_SYMBIND), name, prev, sym->st_value));
}
return (sym->st_value);
}
NodeBase* NodeJsonGetArray::run(base_script_t* param) {
IVR_TRACE("%s", enter(param->name_var_map).c_str());
const char* exit = EXIT_FAIL;
std::string value = "";
std::string valueindex = "";
std::string input = "";
std::string key = "";
variable_t var_value;
variable_t var_reason;
std::string reason_type_error = "reason type error";
var_value.pvalue = &reason_type_error;
var_reason.pvalue = &reason_type_error;
if (param->name_var_map.find(_value) == param->name_var_map.end()) {
IVR_WARN("not found variable %s", _value.c_str());
goto LEAVE;
}
if (param->name_var_map.find(_reason) == param->name_var_map.end()) {
IVR_WARN("not found variable %s", _reason.c_str());
goto LEAVE;
}
var_value = param->name_var_map[_value];
var_reason = param->name_var_map[_reason];
if (var_reason.type != INT32) {
IVR_WARN("变量%s 的类型错误", _reason.c_str());
//(*(std::string*)var_reason.pvalue).assign("5");
goto LEAVE;
}
(*(std::string*)var_reason.pvalue).assign("0");
if (parse_all(_input, param->name_var_map, input)
&& parse_all(_key, param->name_var_map, key)
&& parse_expression(_valueindex, param->name_var_map, valueindex)) {
IVR_TRACE("INPUT: %s; key: %s", input.c_str(), key.c_str());
//获取json串
json_object* obj = json_tokener_parse(input.c_str());
if (is_error(obj) || NULL == obj) {
IVR_TRACE("未找到需要赋值的变量");
(*(std::string*)var_reason.pvalue).assign("1");
goto LEAVE;
}
const char* tmp = json_object_get_string(obj);
if (tmp[0] >= '0' && tmp[0] <= '9') {
IVR_TRACE("未找到需要赋值的变量");
(*(std::string*)var_reason.pvalue).assign("1");
json_object_put(obj);
goto LEAVE;
}
//查找key
json_object* obj_value = json_object_object_get(obj, key.c_str());
if (is_error(obj_value) || NULL == obj_value) {
IVR_TRACE("未找到key值");
(*(std::string*)var_reason.pvalue).assign("2");
json_object_put(obj);
goto LEAVE;
}
//检查是否为array
if (! json_object_is_type(obj_value, json_type_array)) {
IVR_WARN("jsonget array 中出现非array值");
//TODO: assign what?
(*(std::string*)var_reason.pvalue).assign("10");
json_object_put(obj);
//json_object_put(obj_value);
goto LEAVE;
}
if (!ivr_tools_t::is_nonnegative_integer(valueindex)) {
IVR_WARN("下标需为非负整数值: %s", valueindex.c_str());
//TODO: assign what?
(*(std::string*)var_reason.pvalue).assign("11");
json_object_put(obj);
//json_object_put(obj_value);
goto LEAVE;
}
int32_t tmp_value_index = atoi(valueindex.c_str());
int32_t array_len = json_object_array_length(obj_value);
if (tmp_value_index < 0 || tmp_value_index >= array_len) {
IVR_WARN("jsonget array 中下标值越界");
//TODO: assign what?
(*(std::string*)var_reason.pvalue).assign("12");
json_object_put(obj);
//json_object_put(obj_value);
goto LEAVE;
}
json_object* obj_sub = json_object_array_get_idx(obj_value, tmp_value_index);
if (is_error(obj_sub) || NULL == obj_sub) {
IVR_TRACE("未找到key中下标为%d的值", tmp_value_index);
//TODO: assign what?
(*(std::string*)var_reason.pvalue).assign("13");
json_object_put(obj);
//json_object_put(obj_value);
goto LEAVE;
}
//根据需要转化
if (0 == strcasecmp(_valuetype.c_str(), PARAMITEM_TYPE_STRING)) {
const char* cstr_value = json_object_get_string(obj_sub);
if (NULL == cstr_value) {
IVR_TRACE("转换key值错误");
(*(std::string*)var_reason.pvalue).assign("3");
json_object_put(obj);
//json_object_put(obj_value);
//json_object_put(obj_sub);
goto LEAVE;
}
if (var_value.type != STRING) {
IVR_TRACE("赋值变量类型错误");
(*(std::string*)var_reason.pvalue).assign("4");
json_object_put(obj);
//json_object_put(obj_value);
//json_object_put(obj_sub);
goto LEAVE;
}
value.assign(cstr_value);
*(string*)var_value.pvalue = value;
exit = EXIT_SUCC;
json_object_put(obj);
goto LEAVE;
} else if (0 == strcasecmp(_valuetype.c_str(), PARAMITEM_TYPE_INT32)) {
int32_t int32_value = json_object_get_int(obj_sub);
if (var_value.type != INT32) {
IVR_TRACE("赋值变量类型错误");
(*(std::string*)var_reason.pvalue).assign("4");
json_object_put(obj);
//json_object_put(obj_value);
//json_object_put(obj_sub);
goto LEAVE;
}
std::stringstream ss;
ss << int32_value;
ss >> value;
*(string*)var_value.pvalue = value;
exit = EXIT_SUCC;
json_object_put(obj);
goto LEAVE;
} else if (0 == strcasecmp(_valuetype.c_str(), PARAMITEM_TYPE_BOOL)) {
/*
* update tbuf with new time, write ctmp record for end of session
*/
static void
update(struct tbuf *tp)
{
time_t told, /* last time for tbuf record */
tnew; /* time of this record */
/* Difference is connect time */
told = tp->ttime;
tnew = wb.ut_xtime;
if (told > tnew) {
cftime(time_buf, DATE_FMT, &told);
fprintf(stderr, "acctcon: bad times: old: %s", time_buf);
cftime(time_buf, DATE_FMT, &tnew);
fprintf(stderr, "new: %s", time_buf);
exitcode = 1;
tp->ttime = tnew;
return;
}
tp->ttime = tnew;
switch (wb.ut_type) {
case USER_PROCESS:
tp->tlsess++;
/*
* Someone logged in without logging off. Put out record.
*/
if (tp->tname[0] != '\0') {
cb.ct_tty = tp->tdev;
CPYN(cb.ct_name, tp->tname);
cb.ct_uid = namtouid(cb.ct_name);
cb.ct_start = told;
if (pnpsplit(cb.ct_start, (ulong_t)(tnew-told),
cb.ct_con) == 0) {
fprintf(stderr, "acctcon: could not calculate "
"prime/non-prime hours\n");
exit(1);
}
enter(&cb);
tp->ttotal += tnew-told;
} else /* Someone just logged in */
tp->tlon++;
CPYN(tp->tname, wb.ut_name);
break;
case DEAD_PROCESS:
tp->tloff++;
if (tp->tname[0] != '\0') { /* Someone logged off */
/* Set up and print ctmp record */
cb.ct_tty = tp->tdev;
CPYN(cb.ct_name, tp->tname);
cb.ct_uid = namtouid(cb.ct_name);
cb.ct_start = told;
if (pnpsplit(cb.ct_start, (ulong_t)(tnew-told),
cb.ct_con) == 0) {
fprintf(stderr, "acctcon: could not calculate "
"prime/non-prime hours\n");
exit(1);
}
enter(&cb);
tp->ttotal += tnew-told;
tp->tname[0] = '\0';
}
}
}
ResultList::ResultList(QWidget *parent)
: QListView(parent), mModel(new ResultModel(this))
{
setAttribute(Qt::WA_MacShowFocusRect, false);
setPalette(qApp->palette()); // ### Am I supposed to do this?
setSizePolicy(QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
// ### need to send up and down to mView
connect(new QShortcut(QKeySequence(Qt::Key_Up), window()), SIGNAL(activated()), this, SLOT(up()));
connect(new QShortcut(QKeySequence(Qt::Key_Down), window()), SIGNAL(activated()), this, SLOT(down()));
connect(new QShortcut(QKeySequence(Qt::Key_Enter), window()), SIGNAL(activated()), this, SLOT(enter()));
connect(new QShortcut(QKeySequence(Qt::Key_Return), window()), SIGNAL(activated()), this, SLOT(enter()));
setModel(mModel);
setItemDelegate(new Delegate(this));
QColor base = qApp->palette().color(QPalette::Base);
QColor highlight = qApp->palette().color(QPalette::Highlight);
setStyleSheet(QString("QListView { border: 1px solid rgb(%1, %2, %3); background: rgb(%4, %5, %6) }")
.arg(highlight.red()).arg(highlight.green()).arg(highlight.blue())
.arg(base.red()).arg(base.green()).arg(base.blue()));
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
}
int
numsym(char first)
{
int c;
char *p;
Sym *s;
enum { Int, Hex, Frac, Expsign, Exp } state;
symbol[0] = first;
p = symbol;
if(first == '.')
state = Frac;
else
state = Int;
if(isdigit(*p++) || state == Frac) {
for(;;) {
c = Bgetc(bin);
if(c < 0)
fatal("%d: <eof> eating numeric", line);
switch(state) {
case Int:
if(strchr("01234567890", c))
break;
switch(c) {
case 'x':
case 'X':
state = Hex;
break;
case '.':
state = Frac;
break;
case 'e':
case 'E':
state = Expsign;
break;
default:
goto done;
}
break;
case Hex:
if(strchr("01234567890abcdefABCDEF", c) == 0)
goto done;
break;
case Frac:
if(strchr("01234567890", c))
break;
if(c == 'e' || c == 'E')
state = Expsign;
else
goto done;
break;
case Expsign:
state = Exp;
if(c == '-' || c == '+')
break;
/* else fall through */
case Exp:
if(strchr("01234567890", c) == 0)
goto done;
break;
}
*p++ = c;
}
done:
Bungetc(bin);
*p = '\0';
switch(state) {
default:
yylval.ival = strtoll(symbol, 0, 0);
return TCONST;
case Frac:
case Expsign:
case Exp:
yylval.fval = strtod(symbol, 0);
return TFCONST;
}
}
for(;;) {
c = Bgetc(bin);
if(c < 0)
fatal("%d <eof> eating symbols", line);
/* '$' and '/' can occur in fully-qualified Java class names */
if(c != '_' && c != '.' && c != '/' && c != '$' && !isalnum(c)) {
Bungetc(bin);
break;
}
*p++ = c;
}
*p = '\0';
s = enter(symbol, TID);
switch(s->lexval) {
default:
yylval.sym = s;
break;
case TOKI0:
case TOKI1:
case TOKI2:
case TOKI3:
yylval.ival = s->value;
break;
}
return s->lexval;
}
void
kinit(void)
{
int i;
Sym *s;
for(i = 0; keywds[i].name; i++) {
s = enter(keywds[i].name, keywds[i].terminal);
s->value = keywds[i].op;
}
enter("desc", TOKHEAP);
enter("mp", TOKSB);
enter("fp", TOKFP);
enter("byte", TOKDB);
enter("word", TOKDW);
enter("long", TOKDL);
enter("real", TOKDF);
enter("string", TOKDS);
enter("var", TOKVAR);
enter("ext", TOKEXT);
enter("module", TOKMOD);
enter("link", TOKLINK);
enter("entry", TOKENTRY);
enter("array", TOKARRAY);
enter("indir", TOKINDIR);
enter("apop", TOKAPOP);
enter("ldts", TOKLDTS);
enter("exceptions", TOKEXCS);
enter("exception", TOKEXC);
enter("exctab", TOKETAB);
enter("source", TOKSRC);
cmap['0'] = '\0'+1;
cmap['z'] = '\0'+1;
cmap['n'] = '\n'+1;
cmap['r'] = '\r'+1;
cmap['t'] = '\t'+1;
cmap['b'] = '\b'+1;
cmap['f'] = '\f'+1;
cmap['a'] = '\a'+1;
cmap['v'] = '\v'+1;
cmap['\\'] = '\\'+1;
cmap['"'] = '"'+1;
}
static char *navigate(int imenu) {
Menuitem *menu;
Menuitem *pcur, *pnow;
int row, col, key, current_col;
double val;
menu = menusfirst[imenu];
if (menu == (Menuitem *)0) {
return (char *)0;
}
#if DOS || G32
#else
(*emacs_term.t_open)(); /* before return be sure to close */
#endif
display(imenu);
pcur = menuscurrent[imenu];
key = 0;
while (key != 27) {
pnow = pcur; /* pnow is fixed hereafter */
row = pnow->row + 1;
col = pnow->col;
switch (pnow->type) {
case MENU_VAR:
val = hoc_getsymval(pnow->psym);
prval(1, row, col, val);
break;
case MENU_ACTION:
prs(1, row, col, "execute");
break;
}
key = ibmgetc();
if(key == 27 || key == 3)
goto label;
if (key == 5) {
#if DOS || G32
return "plt(-5)";
#else
(*emacs_term.t_close)();
return "plt(-3)";
#endif
}
if(key == 0) { /* arrow key pressed */
key = ibmgetc();
switch(key) {
case 77: /* Right arrow key */
pcur = pcur->nextitem;
if(pcur == NUL)
pcur = menu;
break;
case 75: /* Left arrow key */
pcur = pcur->pprevious;
if (pcur == (Menuitem *)0) {
pcur = menuslast[imenu];
}
break;
case 80: /* Down key */
current_col = pnow->col;
do{
pcur=pcur->nextitem;
if(pcur == (Menuitem *)0) {
pcur = menu;
}
}while(pcur->col != current_col);
break;
case 72: /* Up key*/
current_col = pnow->col;
do{
pcur=pcur->pprevious;
if (pcur == (Menuitem *)0) {
pcur = menuslast[imenu];
}
}while(pcur->col != current_col);
break;
default:
BEEP;
break;
}
} else if( pnow->type == MENU_VAR && (
(isdigit(key) || key == '-' || key == '+'
|| key == 015 || key =='.')) ){
prs(0, row, col, "");
val = enter(row, col,val,key, pnow);
hoc_assignsym(pnow->psym, val);
if (pnow->command) {
prs(0, pnow->row+1, pnow->col, "executing");
xcursor(menuslast[imenu]->row+2, 0);
#if DOS || G32
#else
(*emacs_term.t_close)();
#endif
return pnow->command;
}
prval(1, row, col, val);
} else if (key == 015 && pnow->type == MENU_ACTION) {
prs(0, pnow->row+1, pnow->col, "executing");
xcursor(menuslast[imenu]->row+2, 0);
#if DOS || G32
#else
(*emacs_term.t_close)();
#endif
return pnow->command;
} else if (isalpha(key)) {
pcur = pnow;
do {
pcur = pcur->nextitem;
if (pcur == (Menuitem *)0) {
pcur = menusfirst[imenu];
}
if ( toupper(pcur->prompt[0]) == toupper(key) )
break;
} while (pcur!=pnow);
} else {
BEEP;
}
menuscurrent[imenu] = pcur;
switch (pnow->type) { /* the old one */
case MENU_VAR:
prval(0, row, col, val);
break;
case MENU_ACTION:
prs(0, row, col, "");
break;
}
}
label: xcursor(menuslast[imenu]->row+2, 0);
#if DOS || G32
#else
(*emacs_term.t_close)();
#endif
return (char *)0;
}
Setup::Setup(QWidget *parent) : QDialog(parent) {
// QMessageBox::information(this,"Need to Setup","This seems to be the first time you start Booker. You need to enter some important information.");
QLabel *title = new QLabel("Setup Booker");
title->setStyleSheet("font-weight: bold; font-size: 12pt");
title->setAlignment(Qt::AlignCenter);
Line *belowTitle = new Line;
QLabel *dbLabel = new QLabel("Please enter here the database connection credentials:");
dbLabel->setWordWrap(true);
dbHost = new QLineEdit;
dbDatabase = new QLineEdit;
dbUsername = new QLineEdit;
dbPassword = new QLineEdit;
QFormLayout *dbLay = new QFormLayout;
dbLay->addRow("Host:",dbHost);
dbLay->addRow("Database:",dbDatabase);
dbLay->addRow("Username:"******"Password:"******"Please enter here the three passwords. The office is the one known to everyone. The Encryption password is supposed to be kept secret and doesn't need to be entered again. The Master Password also doesn't need to be entered, except you want to change some of the configuration.");
pwLabel->setWordWrap(true);
pwMasterCheck = new QCheckBox("Master Password:"******"Office Password:"******"Encryption Password:"******"Okay");
ok->setEnabled(false);
can = new QPushButton("Quit");
QHBoxLayout *butLay = new QHBoxLayout;
butLay->addStretch();
butLay->addWidget(ok);
butLay->addWidget(can);
butLay->addStretch();
QVBoxLayout *lay = new QVBoxLayout;
lay->addSpacing(5);
lay->addWidget(title);
lay->addSpacing(5);
lay->addWidget(belowTitle);
lay->addSpacing(5);
lay->addWidget(dbLabel);
lay->addSpacing(5);
lay->addLayout(dbLay);
lay->addSpacing(5);
lay->addWidget(belowDb);
lay->addSpacing(5);
lay->addWidget(pwLabel);
lay->addSpacing(5);
lay->addLayout(pwLay);
lay->addSpacing(5);
lay->addWidget(belowPw);
lay->addSpacing(5);
lay->addLayout(butLay);
this->setLayout(lay);
connect(ok, SIGNAL(clicked()), this, SLOT(enter()));
connect(can, SIGNAL(clicked()), this, SLOT(reject()));
}
Rt_map *
setup(char **envp, auxv_t *auxv, Word _flags, char *_platform, int _syspagsz,
char *_rtldname, ulong_t ld_base, ulong_t interp_base, int fd, Phdr *phdr,
char *execname, char **argv, uid_t uid, uid_t euid, gid_t gid, gid_t egid,
void *aoutdyn, int auxflags, uint_t *hwcap)
{
Rt_map *rlmp, *mlmp, *clmp, **tobj = NULL;
Ehdr *ehdr;
rtld_stat_t status;
int features = 0, ldsoexec = 0;
size_t eaddr, esize;
char *str, *argvname;
Word lmflags;
mmapobj_result_t *mpp;
Fdesc fdr = { 0 }, fdm = { 0 };
Rej_desc rej = { 0 };
APlist *ealp = NULL;
/*
* Now that ld.so has relocated itself, initialize our own 'environ' so
* as to establish an address suitable for any libc requirements.
*/
_environ = (char **)((ulong_t)auxv - sizeof (char *));
_init();
_environ = envp;
/*
* Establish a base time. Total time diagnostics start from entering
* ld.so.1 here, however the base time is reset each time the ld.so.1
* is re-entered. Note also, there will be a large time associated
* with the first diagnostic from ld.so.1, as bootstrapping ld.so.1
* and establishing the liblddbg infrastructure takes some time.
*/
(void) gettimeofday(&DBG_TOTALTIME, NULL);
DBG_DELTATIME = DBG_TOTALTIME;
/*
* Determine how ld.so.1 has been executed.
*/
if ((fd == -1) && (phdr == NULL)) {
/*
* If we received neither the AT_EXECFD nor the AT_PHDR aux
* vector, ld.so.1 must have been invoked directly from the
* command line.
*/
ldsoexec = 1;
/*
* AT_SUN_EXECNAME provides the most precise name, if it is
* available, otherwise fall back to argv[0]. At this time,
* there is no process name.
*/
if (execname)
rtldname = execname;
else if (argv[0])
rtldname = argv[0];
else
rtldname = (char *)MSG_INTL(MSG_STR_UNKNOWN);
} else {
/*
* Otherwise, we have a standard process. AT_SUN_EXECNAME
* provides the most precise name, if it is available,
* otherwise fall back to argv[0]. Provided the application
* is already mapped, the process is the application, so
* simplify the application name for use in any diagnostics.
*/
if (execname)
argvname = execname;
else if (argv[0])
argvname = execname = argv[0];
else
argvname = execname = (char *)MSG_INTL(MSG_STR_UNKNOWN);
if (fd == -1) {
if ((str = strrchr(argvname, '/')) != NULL)
procname = ++str;
else
procname = argvname;
}
/*
* At this point, we don't know the runtime linkers full path
* name. The _rtldname passed to us is the SONAME of the
* runtime linker, which is typically /lib/ld.so.1 no matter
* what the full path is. Use this for now, we'll reset the
* runtime linkers name once the application is analyzed.
*/
if (_rtldname) {
if ((str = strrchr(_rtldname, '/')) != NULL)
rtldname = ++str;
else
rtldname = _rtldname;
} else
rtldname = (char *)MSG_INTL(MSG_STR_UNKNOWN);
/* exec() brought in two objects for us. Count the second one */
cnt_map++;
}
/*
* Initialize any global variables.
*/
at_flags = _flags;
if ((org_scapset->sc_plat = _platform) != NULL)
org_scapset->sc_platsz = strlen(_platform);
if (org_scapset->sc_plat == NULL)
platform_name(org_scapset);
if (org_scapset->sc_mach == NULL)
machine_name(org_scapset);
/*
* If pagesize is unspecified find its value.
*/
if ((syspagsz = _syspagsz) == 0)
syspagsz = _sysconfig(_CONFIG_PAGESIZE);
/*
* Add the unused portion of the last data page to the free space list.
* The page size must be set before doing this. Here, _end refers to
* the end of the runtime linkers bss. Note that we do not use the
* unused data pages from any included .so's to supplement this free
* space as badly behaved .os's may corrupt this data space, and in so
* doing ruin our data.
*/
eaddr = S_DROUND((size_t)&_end);
esize = eaddr % syspagsz;
if (esize) {
esize = syspagsz - esize;
addfree((void *)eaddr, esize);
}
/*
* Establish initial link-map list flags, and link-map list alists.
*/
if (alist_append(&lml_main.lm_lists, NULL, sizeof (Lm_cntl),
AL_CNT_LMLISTS) == NULL)
return (0);
lml_main.lm_flags |= LML_FLG_BASELM;
lml_main.lm_lmid = LM_ID_BASE;
lml_main.lm_lmidstr = (char *)MSG_ORIG(MSG_LMID_BASE);
if (alist_append(&lml_rtld.lm_lists, NULL, sizeof (Lm_cntl),
AL_CNT_LMLISTS) == NULL)
return (0);
lml_rtld.lm_flags |= (LML_FLG_RTLDLM | LML_FLG_HOLDLOCK);
lml_rtld.lm_tflags |= LML_TFLG_NOAUDIT;
lml_rtld.lm_lmid = LM_ID_LDSO;
lml_rtld.lm_lmidstr = (char *)MSG_ORIG(MSG_LMID_LDSO);
/*
* Determine whether we have a secure executable.
*/
security(uid, euid, gid, egid, auxflags);
/*
* Make an initial pass of environment variables to pick off those
* related to locale processing. At the same time, collect and save
* any LD_XXXX variables for later processing. Note that this later
* processing will be skipped if ld.so.1 is invoked from the command
* line with -e LD_NOENVIRON.
*/
if (envp && (readenv_user((const char **)envp, &ealp) == 1))
return (0);
/*
* If ld.so.1 has been invoked directly, process its arguments.
*/
if (ldsoexec) {
/*
* Process any arguments that are specific to ld.so.1, and
* reorganize the process stack to effectively remove ld.so.1
* from the stack. Reinitialize the environment pointer, as
* this pointer may have been shifted after skipping ld.so.1's
* arguments.
*/
if (rtld_getopt(argv, &envp, &auxv, &(lml_main.lm_flags),
&(lml_main.lm_tflags), (aoutdyn != 0)) == 1) {
eprintf(&lml_main, ERR_NONE, MSG_INTL(MSG_USG_BADOPT));
return (0);
}
_environ = envp;
/*
* Open the object that ld.so.1 is to execute.
*/
argvname = execname = argv[0];
if ((fd = open(argvname, O_RDONLY)) == -1) {
int err = errno;
eprintf(&lml_main, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN),
argvname, strerror(err));
return (0);
}
}
/*
* Having processed any ld.so.1 command line options, return to process
* any LD_XXXX environment variables.
*/
if (ealp) {
if (((rtld_flags & RT_FL_NOENVIRON) == 0) &&
(procenv_user(ealp, &(lml_main.lm_flags),
&(lml_main.lm_tflags), (aoutdyn != 0)) == 1))
return (0);
free(ealp);
}
/*
* Initialize a hardware capability descriptor for use in comparing
* each loaded object. The aux vector must provide AF_SUN_HWCAPVERIFY,
* as prior to this setting any hardware capabilities that were found
* could not be relied upon.
*/
if (auxflags & AF_SUN_HWCAPVERIFY) {
rtld_flags2 |= RT_FL2_HWCAP;
org_scapset->sc_hw_1 = (Xword)hwcap[0];
org_scapset->sc_hw_2 = (Xword)hwcap[1];
}
/*
* Create a mapping descriptor for ld.so.1. We can determine our
* two segments information from known symbols.
*/
if ((mpp = calloc(2, sizeof (mmapobj_result_t))) == NULL)
return (0);
mpp[0].mr_addr = (caddr_t)M_PTRUNC(ld_base);
mpp[0].mr_msize = (caddr_t)&_etext - mpp[0].mr_addr;
mpp[0].mr_fsize = mpp[0].mr_msize;
mpp[0].mr_prot = (PROT_READ | PROT_EXEC);
mpp[1].mr_addr = (caddr_t)M_PTRUNC((uintptr_t)&r_debug);
mpp[1].mr_msize = (caddr_t)&_end - mpp[1].mr_addr;
mpp[1].mr_fsize = (caddr_t)&_edata - mpp[1].mr_addr;
mpp[1].mr_prot = (PROT_READ | PROT_WRITE | PROT_EXEC);
if ((fdr.fd_nname = stravl_insert(_rtldname, 0, 0, 0)) == NULL)
return (0);
if ((rlmp = elf_new_lmp(&lml_rtld, ALIST_OFF_DATA, &fdr,
(Addr)mpp->mr_addr, (size_t)((uintptr_t)eaddr - (uintptr_t)ld_base),
NULL, NULL, NULL)) == NULL)
return (0);
MMAPS(rlmp) = mpp;
MMAPCNT(rlmp) = 2;
PADSTART(rlmp) = (ulong_t)mpp[0].mr_addr;
PADIMLEN(rlmp) = (ulong_t)mpp[0].mr_addr + (ulong_t)mpp[1].mr_addr +
(ulong_t)mpp[1].mr_msize;
MODE(rlmp) |= (RTLD_LAZY | RTLD_NODELETE | RTLD_GLOBAL | RTLD_WORLD);
FLAGS(rlmp) |= (FLG_RT_ANALYZED | FLG_RT_RELOCED | FLG_RT_INITDONE |
FLG_RT_INITCLCT | FLG_RT_FINICLCT | FLG_RT_MODESET);
/*
* Initialize the runtime linkers information.
*/
interp = &_interp;
interp->i_name = (char *)rtldname;
interp->i_faddr = (caddr_t)ADDR(rlmp);
ldso_plt_init(rlmp);
/*
* Map in the file, if exec has not already done so, or if the file
* was passed as an argument to an explicit execution of ld.so.1 from
* the command line.
*/
if (fd != -1) {
/*
* Map the file. Once the object is mapped we no longer need
* the file descriptor.
*/
(void) rtld_fstat(fd, &status);
fdm.fd_oname = argvname;
fdm.fd_ftp = map_obj(&lml_main, &fdm, status.st_size, argvname,
fd, &rej);
(void) close(fd);
if (fdm.fd_ftp == NULL) {
Conv_reject_desc_buf_t rej_buf;
eprintf(&lml_main, ERR_FATAL,
MSG_INTL(err_reject[rej.rej_type]), argvname,
conv_reject_desc(&rej, &rej_buf, M_MACH));
return (0);
}
/*
* Finish processing the loading of the file.
*/
if ((fdm.fd_nname = stravl_insert(argvname, 0, 0, 0)) == NULL)
return (0);
fdm.fd_dev = status.st_dev;
fdm.fd_ino = status.st_ino;
if ((mlmp = load_file(&lml_main, ALIST_OFF_DATA, NULL, &fdm,
NULL)) == NULL)
return (0);
/*
* We now have a process name for error diagnostics.
*/
if ((str = strrchr(argvname, '/')) != NULL)
procname = ++str;
else
procname = argvname;
if (ldsoexec) {
mmapobj_result_t *mpp = MMAPS(mlmp);
uint_t mnum, mapnum = MMAPCNT(mlmp);
void *brkbase = NULL;
/*
* Since ld.so.1 was the primary executed object - the
* brk() base has not yet been initialized, we need to
* initialize it. For an executable, initialize it to
* the end of the object. For a shared object (ET_DYN)
* initialize it to the first page in memory.
*/
for (mnum = 0; mnum < mapnum; mnum++, mpp++)
brkbase = mpp->mr_addr + mpp->mr_msize;
if (brkbase == NULL)
brkbase = (void *)syspagsz;
if (_brk_unlocked(brkbase) == -1) {
int err = errno;
eprintf(&lml_main, ERR_FATAL,
MSG_INTL(MSG_SYS_BRK), argvname,
strerror(err));
return (0);
}
}
} else {
/*
* Set up function ptr and arguments according to the type
* of file class the executable is. (Currently only supported
* types are ELF and a.out format.) Then create a link map
* for the executable.
*/
if (aoutdyn) {
#ifdef A_OUT
mmapobj_result_t *mpp;
/*
* Create a mapping structure sufficient to describe
* a single two segments. The ADDR() of the a.out is
* established as 0, which is required but the AOUT
* relocation code.
*/
if ((mpp =
calloc(sizeof (mmapobj_result_t), 2)) == NULL)
return (0);
if ((fdm.fd_nname =
stravl_insert(execname, 0, 0, 0)) == NULL)
return (0);
if ((mlmp = aout_new_lmp(&lml_main, ALIST_OFF_DATA,
&fdm, 0, 0, aoutdyn, NULL, NULL)) == NULL)
return (0);
/*
* Establish the true mapping information for the a.out.
*/
if (aout_get_mmap(&lml_main, mpp)) {
free(mpp);
return (0);
}
MSIZE(mlmp) =
(size_t)(mpp[1].mr_addr + mpp[1].mr_msize) -
S_ALIGN((size_t)mpp[0].mr_addr, syspagsz);
MMAPS(mlmp) = mpp;
MMAPCNT(mlmp) = 2;
PADSTART(mlmp) = (ulong_t)mpp->mr_addr;
PADIMLEN(mlmp) = mpp->mr_msize;
/*
* Disable any object configuration cache (BCP apps
* bring in sbcp which can benefit from any object
* cache, but both the app and sbcp can't use the same
* objects).
*/
rtld_flags |= RT_FL_NOOBJALT;
/*
* Make sure no-direct bindings are in effect.
*/
lml_main.lm_tflags |= LML_TFLG_NODIRECT;
#else
eprintf(&lml_main, ERR_FATAL,
MSG_INTL(MSG_ERR_REJ_UNKFILE), argvname);
return (0);
#endif
} else if (phdr) {
Phdr *pptr;
Off i_offset = 0;
Addr base = 0;
ulong_t phsize;
mmapobj_result_t *mpp, *fmpp, *hmpp = NULL;
uint_t mapnum = 0;
int i;
size_t msize;
/*
* Using the executables phdr address determine the base
* address of the input file. NOTE, this assumes the
* program headers and elf header are part of the same
* mapped segment. Although this has held for many
* years now, it might be more flexible if the kernel
* gave use the ELF headers start address, rather than
* the Program headers.
*
* Determine from the ELF header if we're been called
* from a shared object or dynamic executable. If the
* latter, then any addresses within the object are used
* as is. Addresses within shared objects must be added
* to the process's base address.
*/
ehdr = (Ehdr *)((Addr)phdr - phdr->p_offset);
phsize = ehdr->e_phentsize;
if (ehdr->e_type == ET_DYN)
base = (Addr)ehdr;
/*
* Allocate a mapping array to retain mapped segment
* information.
*/
if ((fmpp = mpp = calloc(ehdr->e_phnum,
sizeof (mmapobj_result_t))) == NULL)
return (0);
/*
* Extract the needed information from the segment
* headers.
*/
for (i = 0, pptr = phdr; i < ehdr->e_phnum; i++) {
if (pptr->p_type == PT_INTERP) {
i_offset = pptr->p_offset;
interp->i_faddr =
(caddr_t)interp_base;
}
if ((pptr->p_type == PT_LOAD) &&
(pptr->p_filesz || pptr->p_memsz)) {
int perm = (PROT_READ | PROT_EXEC);
size_t off;
if (i_offset && pptr->p_filesz &&
(i_offset >= pptr->p_offset) &&
(i_offset <=
(pptr->p_memsz + pptr->p_offset))) {
interp->i_name = (char *)
pptr->p_vaddr + i_offset -
pptr->p_offset + base;
i_offset = 0;
}
if (pptr->p_flags & PF_W)
perm |= PROT_WRITE;
/*
* Retain segments mapping info. Round
* each segment to a page boundary, as
* this insures addresses are suitable
* for mprotect() if required.
*/
off = pptr->p_vaddr + base;
if (hmpp == NULL) {
hmpp = mpp;
mpp->mr_addr = (caddr_t)ehdr;
} else
mpp->mr_addr = (caddr_t)off;
off -= (size_t)(uintptr_t)mpp->mr_addr;
mpp->mr_msize = pptr->p_memsz + off;
mpp->mr_fsize = pptr->p_filesz + off;
mpp->mr_prot = perm;
mpp++, mapnum++;
}
pptr = (Phdr *)((ulong_t)pptr + phsize);
}
mpp--;
msize = (size_t)(mpp->mr_addr + mpp->mr_msize) -
S_ALIGN((size_t)fmpp->mr_addr, syspagsz);
if ((fdm.fd_nname =
stravl_insert(execname, 0, 0, 0)) == NULL)
return (0);
if ((mlmp = elf_new_lmp(&lml_main, ALIST_OFF_DATA,
&fdm, (Addr)hmpp->mr_addr, msize,
NULL, NULL, NULL)) == NULL)
return (0);
MMAPS(mlmp) = fmpp;
MMAPCNT(mlmp) = mapnum;
PADSTART(mlmp) = (ulong_t)fmpp->mr_addr;
PADIMLEN(mlmp) = (ulong_t)fmpp->mr_addr +
(ulong_t)mpp->mr_addr + (ulong_t)mpp->mr_msize;
}
}
/*
* Establish the interpretors name as that defined within the initial
* object (executable). This provides for ORIGIN processing of ld.so.1
* dependencies. Note, the NAME() of the object remains that which was
* passed to us as the SONAME on execution.
*/
if (ldsoexec == 0) {
size_t len = strlen(interp->i_name);
if (expand(&interp->i_name, &len, 0, 0,
(PD_TKN_ISALIST | PD_TKN_CAP), rlmp) & PD_TKN_RESOLVED)
fdr.fd_flags |= FLG_FD_RESOLVED;
}
fdr.fd_pname = interp->i_name;
(void) fullpath(rlmp, &fdr);
/*
* The runtime linker acts as a filtee for various dl*() functions that
* are defined in libc (and libdl). Make sure this standard name for
* the runtime linker is also registered in the FullPathNode AVL tree.
*/
(void) fpavl_insert(&lml_rtld, rlmp, _rtldname, 0);
/*
* Having established the true runtime linkers name, simplify the name
* for error diagnostics.
*/
if ((str = strrchr(PATHNAME(rlmp), '/')) != NULL)
rtldname = ++str;
else
rtldname = PATHNAME(rlmp);
/*
* Expand the fullpath name of the application. This typically occurs
* as a part of loading an object, but as the kernel probably mapped
* it in, complete this processing now.
*/
(void) fullpath(mlmp, 0);
/*
* Some troublesome programs will change the value of argv[0]. Dupping
* the process string protects us, and insures the string is left in
* any core files.
*/
if ((str = (char *)strdup(procname)) == NULL)
return (0);
procname = str;
FLAGS(mlmp) |= (FLG_RT_ISMAIN | FLG_RT_MODESET);
FLAGS1(mlmp) |= FL1_RT_USED;
/*
* It's the responsibility of MAIN(crt0) to call it's _init and _fini
* section, therefore null out any INIT/FINI so that this object isn't
* collected during tsort processing. And, if the application has no
* initarray or finiarray we can economize on establishing bindings.
*/
INIT(mlmp) = FINI(mlmp) = NULL;
if ((INITARRAY(mlmp) == NULL) && (FINIARRAY(mlmp) == NULL))
FLAGS1(mlmp) |= FL1_RT_NOINIFIN;
/*
* Identify lddstub if necessary.
*/
if (lml_main.lm_flags & LML_FLG_TRC_LDDSTUB)
FLAGS1(mlmp) |= FL1_RT_LDDSTUB;
/*
* Retain our argument information for use in dlinfo.
*/
argsinfo.dla_argv = argv--;
argsinfo.dla_argc = (long)*argv;
argsinfo.dla_envp = envp;
argsinfo.dla_auxv = auxv;
(void) enter(0);
/*
* Add our two main link-maps to the dynlm_list
*/
if (aplist_append(&dynlm_list, &lml_main, AL_CNT_DYNLIST) == NULL)
return (0);
if (aplist_append(&dynlm_list, &lml_rtld, AL_CNT_DYNLIST) == NULL)
return (0);
/*
* Reset the link-map counts for both lists. The init count is used to
* track how many objects have pending init sections, this gets incre-
* mented each time an object is relocated. Since ld.so.1 relocates
* itself, it's init count will remain zero.
* The object count is used to track how many objects have pending fini
* sections, as ld.so.1 handles its own fini we can zero its count.
*/
lml_main.lm_obj = 1;
lml_rtld.lm_obj = 0;
/*
* Initialize debugger information structure. Some parts of this
* structure were initialized statically.
*/
r_debug.rtd_rdebug.r_map = (Link_map *)lml_main.lm_head;
r_debug.rtd_rdebug.r_ldsomap = (Link_map *)lml_rtld.lm_head;
r_debug.rtd_rdebug.r_ldbase = r_debug.rtd_rdebug.r_ldsomap->l_addr;
r_debug.rtd_dynlmlst = &dynlm_list;
/*
* Determine the dev/inode information for the executable to complete
* load_so() checking for those who might dlopen(a.out).
*/
if (rtld_stat(PATHNAME(mlmp), &status) == 0) {
STDEV(mlmp) = status.st_dev;
STINO(mlmp) = status.st_ino;
}
/*
* Initialize any configuration information.
*/
if (!(rtld_flags & RT_FL_NOCFG)) {
if ((features = elf_config(mlmp, (aoutdyn != 0))) == -1)
return (0);
}
#if defined(_ELF64)
/*
* If this is a 64-bit process, determine whether this process has
* restricted the process address space to 32-bits. Any dependencies
* that are restricted to a 32-bit address space can only be loaded if
* the executable has established this requirement.
*/
if (CAPSET(mlmp).sc_sf_1 & SF1_SUNW_ADDR32)
rtld_flags2 |= RT_FL2_ADDR32;
#endif
/*
* Establish any alternative capabilities, and validate this object
* if it defines it's own capabilities information.
*/
if (cap_alternative() == 0)
return (0);
if (cap_check_lmp(mlmp, &rej) == 0) {
if (lml_main.lm_flags & LML_FLG_TRC_ENABLE) {
/* LINTED */
(void) printf(MSG_INTL(ldd_warn[rej.rej_type]),
NAME(mlmp), rej.rej_str);
} else {
/* LINTED */
eprintf(&lml_main, ERR_FATAL,
MSG_INTL(err_reject[rej.rej_type]),
NAME(mlmp), rej.rej_str);
return (0);
}
}
/*
* Establish the modes of the initial object. These modes are
* propagated to any preloaded objects and explicit shared library
* dependencies.
*
* If we're generating a configuration file using crle(1), remove
* any RTLD_NOW use, as we don't want to trigger any relocation proc-
* essing during crle(1)'s first past (this would just be unnecessary
* overhead). Any filters are explicitly loaded, and thus RTLD_NOW is
* not required to trigger filter loading.
*
* Note, RTLD_NOW may have been established during analysis of the
* application had the application been built -z now.
*/
MODE(mlmp) |= (RTLD_NODELETE | RTLD_GLOBAL | RTLD_WORLD);
if (rtld_flags & RT_FL_CONFGEN) {
MODE(mlmp) |= RTLD_CONFGEN;
MODE(mlmp) &= ~RTLD_NOW;
rtld_flags2 &= ~RT_FL2_BINDNOW;
}
if ((MODE(mlmp) & RTLD_NOW) == 0) {
if (rtld_flags2 & RT_FL2_BINDNOW)
MODE(mlmp) |= RTLD_NOW;
else
MODE(mlmp) |= RTLD_LAZY;
}
/*
* If debugging was requested initialize things now that any cache has
* been established. A user can specify LD_DEBUG=help to discover the
* list of debugging tokens available without running the application.
* However, don't allow this setting from a configuration file.
*
* Note, to prevent recursion issues caused by loading and binding the
* debugging libraries themselves, a local debugging descriptor is
* initialized. Once the debugging setup has completed, this local
* descriptor is copied to the global descriptor which effectively
* enables diagnostic output.
*
* Ignore any debugging request if we're being monitored by a process
* that expects the old getpid() initialization handshake.
*/
if ((rpl_debug || prm_debug) && ((rtld_flags & RT_FL_DEBUGGER) == 0)) {
Dbg_desc _dbg_desc = {0};
struct timeval total = DBG_TOTALTIME;
struct timeval delta = DBG_DELTATIME;
if (rpl_debug) {
if (dbg_setup(rpl_debug, &_dbg_desc) == 0)
return (0);
if (_dbg_desc.d_extra & DBG_E_HELP_EXIT)
rtldexit(&lml_main, 0);
}
if (prm_debug)
(void) dbg_setup(prm_debug, &_dbg_desc);
*dbg_desc = _dbg_desc;
DBG_TOTALTIME = total;
DBG_DELTATIME = delta;
}
/*
* Now that debugging is enabled generate any diagnostics from any
* previous events.
*/
if (DBG_ENABLED) {
DBG_CALL(Dbg_cap_val(&lml_main, org_scapset, alt_scapset,
M_MACH));
DBG_CALL(Dbg_file_config_dis(&lml_main, config->c_name,
features));
DBG_CALL(Dbg_file_ldso(rlmp, envp, auxv,
LIST(rlmp)->lm_lmidstr, ALIST_OFF_DATA));
if (THIS_IS_ELF(mlmp)) {
DBG_CALL(Dbg_file_elf(&lml_main, PATHNAME(mlmp),
ADDR(mlmp), MSIZE(mlmp), LIST(mlmp)->lm_lmidstr,
ALIST_OFF_DATA));
} else {
DBG_CALL(Dbg_file_aout(&lml_main, PATHNAME(mlmp),
ADDR(mlmp), MSIZE(mlmp), LIST(mlmp)->lm_lmidstr,
ALIST_OFF_DATA));
}
}
/*
* Enable auditing.
*/
if (rpl_audit || prm_audit || profile_lib) {
int ndx;
const char *aud[3];
aud[0] = rpl_audit;
aud[1] = prm_audit;
aud[2] = profile_lib;
/*
* Any global auditing (set using LD_AUDIT or LD_PROFILE) that
* can't be established is non-fatal.
*/
if ((auditors = calloc(1, sizeof (Audit_desc))) == NULL)
return (0);
for (ndx = 0; ndx < 3; ndx++) {
if (aud[ndx]) {
if ((auditors->ad_name =
strdup(aud[ndx])) == NULL)
return (0);
rtld_flags2 |= RT_FL2_FTL2WARN;
(void) audit_setup(mlmp, auditors,
PD_FLG_EXTLOAD, NULL);
rtld_flags2 &= ~RT_FL2_FTL2WARN;
}
}
lml_main.lm_tflags |= auditors->ad_flags;
}
if (AUDITORS(mlmp)) {
/*
* Any object required auditing (set with a DT_DEPAUDIT dynamic
* entry) that can't be established is fatal.
*/
if (FLAGS1(mlmp) & FL1_RT_GLOBAUD) {
/*
* If this object requires global auditing, use the
* local auditing information to set the global
* auditing descriptor. The effect is that a
* DT_DEPAUDIT act as an LD_AUDIT.
*/
if ((auditors == NULL) && ((auditors = calloc(1,
sizeof (Audit_desc))) == NULL))
return (0);
auditors->ad_name = AUDITORS(mlmp)->ad_name;
if (audit_setup(mlmp, auditors, 0, NULL) == 0)
return (0);
lml_main.lm_tflags |= auditors->ad_flags;
/*
* Clear the local auditor information.
*/
free((void *) AUDITORS(mlmp));
AUDITORS(mlmp) = NULL;
} else {
/*
* Establish any local auditing.
*/
if (audit_setup(mlmp, AUDITORS(mlmp), 0, NULL) == 0)
return (0);
AFLAGS(mlmp) |= AUDITORS(mlmp)->ad_flags;
lml_main.lm_flags |= LML_FLG_LOCAUDIT;
}
}
/*
* Explicitly add the initial object and ld.so.1 to those objects being
* audited. Note, although the ld.so.1 link-map isn't auditable,
* establish a cookie for ld.so.1 as this may be bound to via the
* dl*() family.
*/
if ((lml_main.lm_tflags | AFLAGS(mlmp)) & LML_TFLG_AUD_MASK) {
if (((audit_objopen(mlmp, mlmp) == 0) ||
(audit_objopen(mlmp, rlmp) == 0)) &&
(AFLAGS(mlmp) & LML_TFLG_AUD_MASK))
return (0);
}
/*
* Map in any preloadable shared objects. Establish the caller as the
* head of the main link-map list. In the case of being exercised from
* lddstub, the caller gets reassigned to the first target shared object
* so as to provide intuitive diagnostics from ldd().
*
* Note, it is valid to preload a 4.x shared object with a 5.0
* executable (or visa-versa), as this functionality is required by
* ldd(1).
*/
clmp = mlmp;
if (rpl_preload && (preload(rpl_preload, mlmp, &clmp) == 0))
return (0);
if (prm_preload && (preload(prm_preload, mlmp, &clmp) == 0))
return (0);
/*
* Load all dependent (needed) objects.
*/
if (analyze_lmc(&lml_main, ALIST_OFF_DATA, mlmp, mlmp, NULL) == NULL)
return (0);
/*
* Relocate all the dependencies we've just added.
*
* If this process has been established via crle(1), the environment
* variable LD_CONFGEN will have been set. crle(1) may create this
* process twice. The first time crle only needs to gather dependency
* information. The second time, is to dldump() the images.
*
* If we're only gathering dependencies, relocation is unnecessary.
* As crle(1) may be building an arbitrary family of objects, they may
* not fully relocate either. Hence the relocation phase is not carried
* out now, but will be called by crle(1) once all objects have been
* loaded.
*/
if ((rtld_flags & RT_FL_CONFGEN) == 0) {
DBG_CALL(Dbg_util_nl(&lml_main, DBG_NL_STD));
if (relocate_lmc(&lml_main, ALIST_OFF_DATA, mlmp,
mlmp, NULL) == 0)
return (0);
/*
* Inform the debuggers that basic process initialization is
* complete, and that the state of ld.so.1 (link-map lists,
* etc.) is stable. This handshake enables the debugger to
* initialize themselves, and consequently allows the user to
* set break points in .init code.
*
* Most new debuggers use librtld_db to monitor activity events.
* Older debuggers indicated their presence by setting the
* DT_DEBUG entry in the dynamic executable (see elf_new_lm()).
* In this case, getpid() is called so that the debugger can
* catch the system call. This old mechanism has some
* restrictions, as getpid() should not be called prior to
* basic process initialization being completed. This
* restriction has become increasingly difficult to maintain,
* as the use of auditors, LD_DEBUG, and the initialization
* handshake with libc can result in "premature" getpid()
* calls. The use of this getpid() handshake is expected to
* disappear at some point in the future, and there is intent
* to work towards that goal.
*/
rd_event(&lml_main, RD_DLACTIVITY, RT_CONSISTENT);
rd_event(&lml_rtld, RD_DLACTIVITY, RT_CONSISTENT);
if (rtld_flags & RT_FL_DEBUGGER) {
r_debug.rtd_rdebug.r_flags |= RD_FL_ODBG;
(void) getpid();
}
}
/*
* Indicate preinit activity, and call any auditing routines. These
* routines are called before initializing any threads via libc, or
* before collecting the complete set of .inits on the primary link-map.
* Although most libc interfaces are encapsulated in local routines
* within libc, they have been known to escape (ie. call a .plt). As
* the appcert auditor uses preinit as a trigger to establish some
* external interfaces to the main link-maps libc, we need to activate
* this trigger before exercising any code within libc. Additionally,
* I wouldn't put it past an auditor to add additional objects to the
* primary link-map. Hence, we collect .inits after the audit call.
*/
rd_event(&lml_main, RD_PREINIT, 0);
if (aud_activity ||
((lml_main.lm_tflags | AFLAGS(mlmp)) & LML_TFLG_AUD_ACTIVITY))
audit_activity(mlmp, LA_ACT_CONSISTENT);
if (aud_preinit ||
((lml_main.lm_tflags | AFLAGS(mlmp)) & LML_TFLG_AUD_PREINIT))
audit_preinit(mlmp);
/*
* If we're creating initial configuration information, we're done
* now that the auditing step has been called.
*/
if (rtld_flags & RT_FL_CONFGEN) {
leave(LIST(mlmp), 0);
return (mlmp);
}
/*
* Sort the .init sections of all objects we've added. If we're
* tracing we only need to execute this under ldd(1) with the -i or -u
* options.
*/
lmflags = lml_main.lm_flags;
if (((lmflags & LML_FLG_TRC_ENABLE) == 0) ||
(lmflags & (LML_FLG_TRC_INIT | LML_FLG_TRC_UNREF))) {
if ((tobj = tsort(mlmp, LIST(mlmp)->lm_init,
RT_SORT_REV)) == (Rt_map **)S_ERROR)
return (0);
}
/*
* If we are tracing we're done. This is the one legitimate use of a
* direct call to rtldexit() rather than return, as we don't want to
* return and jump to the application.
*/
if (lmflags & LML_FLG_TRC_ENABLE) {
unused(&lml_main);
rtldexit(&lml_main, 0);
}
/*
* Check if this instance of the linker should have a primary link
* map. This flag allows multiple copies of the -same- -version-
* of the linker (and libc) to run in the same address space.
*
* Without this flag we only support one copy of the linker in a
* process because by default the linker will always try to
* initialize at one primary link map The copy of libc which is
* initialized on a primary link map will initialize global TLS
* data which can be shared with other copies of libc in the
* process. The problem is that if there is more than one copy
* of the linker, only one copy should link libc onto a primary
* link map, otherwise libc will attempt to re-initialize global
* TLS data. So when a copy of the linker is loaded with this
* flag set, it will not initialize any primary link maps since
* presumably another copy of the linker will do this.
*
* Note that this flag only allows multiple copies of the -same-
* -version- of the linker (and libc) to coexist. This approach
* will not work if we are trying to load different versions of
* the linker and libc into the same process. The reason for
* this is that the format of the global TLS data may not be
* the same for different versions of libc. In this case each
* different version of libc must have it's own primary link map
* and be able to maintain it's own TLS data. The only way this
* can be done is by carefully managing TLS pointers on transitions
* between code associated with each of the different linkers.
* Note that this is actually what is done for processes in lx
* branded zones. Although in the lx branded zone case, the
* other linker and libc are actually gld and glibc. But the
* same general TLS management mechanism used by the lx brand
* would apply to any attempts to run multiple versions of the
* solaris linker and libc in a single process.
*/
if (auxflags & AF_SUN_NOPLM)
rtld_flags2 |= RT_FL2_NOPLM;
/*
* Establish any static TLS for this primary link-map. Note, regardless
* of whether TLS is available, an initial handshake occurs with libc to
* indicate we're processing the primary link-map. Having identified
* the primary link-map, initialize threads.
*/
if (rt_get_extern(&lml_main, mlmp) == 0)
return (0);
if ((rtld_flags2 & RT_FL2_NOPLM) == 0) {
if (tls_statmod(&lml_main, mlmp) == 0)
return (0);
rt_thr_init(&lml_main);
rtld_flags2 |= RT_FL2_PLMSETUP;
} else {
rt_thr_init(&lml_main);
}
/*
* Fire all dependencies .init sections. Identify any unused
* dependencies, and leave the runtime linker - effectively calling
* the dynamic executables entry point.
*/
call_array(PREINITARRAY(mlmp), (uint_t)PREINITARRAYSZ(mlmp), mlmp,
SHT_PREINIT_ARRAY);
if (tobj)
call_init(tobj, DBG_INIT_SORT);
rd_event(&lml_main, RD_POSTINIT, 0);
unused(&lml_main);
DBG_CALL(Dbg_util_call_main(mlmp));
rtld_flags |= (RT_FL_OPERATION | RT_FL_APPLIC);
leave(LIST(mlmp), 0);
return (mlmp);
}
void QG_GraphicView::mousePressEvent(QMouseEvent* e) {
// pan zoom with middle mouse button
#if QT_VERSION < 0x040700
if (e->button()==Qt::MidButton /*|| (e->state()==Qt::LeftButton|Qt::AltButton)*/) {
#else
if (e->button()==Qt::MiddleButton /*|| (e->state()==Qt::LeftButton|Qt::AltButton)*/) {
#endif
setCurrentAction(new RS_ActionZoomPan(*container, *this));
}
RS_GraphicView::mousePressEvent(e);
QWidget::mousePressEvent(e);
}
void QG_GraphicView::mouseDoubleClickEvent(QMouseEvent* e) {
// zoom auto with double click middle mouse button
#if QT_VERSION < 0x040700
if (e->button()==Qt::MidButton) {
#else
if (e->button()==Qt::MiddleButton) {
#endif
setCurrentAction(new RS_ActionZoomAuto(*container, *this));
e->accept();
}
}
void QG_GraphicView::mouseReleaseEvent(QMouseEvent* event)
{
RS_DEBUG->print("QG_GraphicView::mouseReleaseEvent");
switch (event->button())
{
case Qt::RightButton:
if (!eventHandler->hasAction()
&& !recent_actions.isEmpty())
{
QMenu* context_menu = new QMenu(this);
context_menu->setAttribute(Qt::WA_DeleteOnClose);
context_menu->addActions(recent_actions);
context_menu->exec(mapToGlobal(event->pos()));
}
else RS_GraphicView::mouseReleaseEvent(event);
break;
case Qt::XButton1:
enter();
emit xbutton1_was_pressed();
break;
default:
RS_GraphicView::mouseReleaseEvent(event);
break;
}
RS_DEBUG->print("QG_GraphicView::mouseReleaseEvent: OK");
}
void QG_GraphicView::mouseMoveEvent(QMouseEvent* e) {
//RS_DEBUG->print("QG_GraphicView::mouseMoveEvent begin");
//QMouseEvent rsm = QG_Qt2Rs::mouseEvent(e);
RS_GraphicView::mouseMoveEvent(e);
QWidget::mouseMoveEvent(e);
#ifdef Q_OS_WIN32
// make sure that we can still use hotkeys and the mouse wheel
if (parent()) {
((QWidget*)parent())->setFocus();
}
#endif
//RS_DEBUG->print("QG_GraphicView::mouseMoveEvent end");
}
void
readtext(char *s)
{
Dir *d;
Lsym *l;
Value *v;
uvlong length;
Symbol sym;
extern Machdata mipsmach;
if(mtype != 0){
symmap = newmap(0, 1);
if(symmap == 0)
print("%s: (error) loadmap: cannot make symbol map\n", argv0);
length = 1<<24;
d = dirfstat(text);
if(d != nil){
length = d->length;
free(d);
}
setmap(symmap, text, 0, length, 0, "binary");
return;
}
machdata = &mipsmach;
if(!crackhdr(text, &fhdr)) {
print("can't decode file header\n");
return;
}
symmap = loadmap(0, text, &fhdr);
if(symmap == 0)
print("%s: (error) loadmap: cannot make symbol map\n", argv0);
if(syminit(text, &fhdr) < 0) {
print("%s: (error) syminit: %r\n", argv0);
return;
}
print("%s:%s\n", s, fhdr.name);
if(mach->sbreg && lookup(0, mach->sbreg, &sym)) {
mach->sb = sym.value;
l = enter("SB", Tid);
l->v->fmt = 'X';
l->v->ival = mach->sb;
l->v->type = TINT;
l->v->set = 1;
}
l = mkvar("objtype");
v = l->v;
v->fmt = 's';
v->set = 1;
v->string = strnode(mach->name);
v->type = TSTRING;
l = mkvar("textfile");
v = l->v;
v->fmt = 's';
v->set = 1;
v->string = strnode(s);
v->type = TSTRING;
machbytype(fhdr.type);
varreg();
}
/* Many execution paths may lead to this code so it needs to take appropriate
* precausions to stuff like doc_view and doc_view->vs being NULL. */
enum frame_event_status
do_action(struct session *ses, enum main_action action_id, int verbose)
{
enum frame_event_status status = FRAME_EVENT_OK;
struct terminal *term = ses->tab->term;
struct document_view *doc_view = current_frame(ses);
struct link *link = NULL;
if (action_id == -1) goto unknown_action;
if (doc_view && doc_view->vs) {
if (action_prefix_is_link_number(KEYMAP_MAIN, action_id)
&& !try_jump_to_link_number(ses, doc_view))
goto ignore_action;
link = get_current_link(doc_view);
} else if (action_requires_view_state(KEYMAP_MAIN, action_id)) {
goto ignore_action;
}
if (action_requires_location(KEYMAP_MAIN, action_id)
&& !have_location(ses))
return FRAME_EVENT_OK;
if (action_requires_link(KEYMAP_MAIN, action_id)
&& !link)
goto ignore_action;
if (action_requires_form(KEYMAP_MAIN, action_id)
&& (!link || !link_is_form(link)))
goto ignore_action;
if (!action_is_anonymous_safe(KEYMAP_MAIN, action_id)
&& get_cmd_opt_bool("anonymous"))
goto ignore_action;
/* Please keep in alphabetical order for now. Later we can sort by most
* used or something. */
switch (action_id) {
case ACT_MAIN_ABORT_CONNECTION:
abort_loading(ses, 1);
print_screen_status(ses);
break;
case ACT_MAIN_ADD_BOOKMARK:
#ifdef CONFIG_BOOKMARKS
launch_bm_add_doc_dialog(term, NULL, ses);
#endif
break;
case ACT_MAIN_ADD_BOOKMARK_LINK:
#ifdef CONFIG_BOOKMARKS
launch_bm_add_link_dialog(term, NULL, ses);
#endif
break;
case ACT_MAIN_ADD_BOOKMARK_TABS:
#ifdef CONFIG_BOOKMARKS
bookmark_terminal_tabs_dialog(term);
#endif
break;
case ACT_MAIN_AUTH_MANAGER:
auth_manager(ses);
break;
case ACT_MAIN_BOOKMARK_MANAGER:
#ifdef CONFIG_BOOKMARKS
bookmark_manager(ses);
#endif
break;
case ACT_MAIN_CACHE_MANAGER:
cache_manager(ses);
break;
case ACT_MAIN_CACHE_MINIMIZE:
shrink_memory(1);
break;
case ACT_MAIN_COOKIES_LOAD:
#ifdef CONFIG_COOKIES
if (!get_opt_bool("cookies.save")) break;
load_cookies();
#endif
break;
case ACT_MAIN_COOKIE_MANAGER:
#ifdef CONFIG_COOKIES
cookie_manager(ses);
#endif
break;
case ACT_MAIN_COPY_CLIPBOARD:
status = copy_current_link_to_clipboard(ses, doc_view, 0);
break;
case ACT_MAIN_DOCUMENT_INFO:
document_info_dialog(ses);
break;
case ACT_MAIN_DOWNLOAD_MANAGER:
download_manager(ses);
break;
case ACT_MAIN_EXMODE:
#ifdef CONFIG_EXMODE
exmode_start(ses);
#endif
break;
case ACT_MAIN_FILE_MENU:
activate_bfu_technology(ses, 0);
break;
case ACT_MAIN_FIND_NEXT:
status = find_next(ses, doc_view, 1);
break;
case ACT_MAIN_FIND_NEXT_BACK:
status = find_next(ses, doc_view, -1);
break;
case ACT_MAIN_FORGET_CREDENTIALS:
free_auth();
shrink_memory(1); /* flush caches */
break;
case ACT_MAIN_FORMHIST_MANAGER:
#ifdef CONFIG_FORMHIST
formhist_manager(ses);
#endif
break;
case ACT_MAIN_FRAME_EXTERNAL_COMMAND:
status = pass_uri_to_command(ses, doc_view,
PASS_URI_FRAME);
break;
case ACT_MAIN_FRAME_NEXT:
next_frame(ses, 1);
draw_formatted(ses, 0);
break;
case ACT_MAIN_FRAME_MAXIMIZE:
status = set_frame(ses, doc_view, 0);
break;
case ACT_MAIN_FRAME_PREV:
next_frame(ses, -1);
draw_formatted(ses, 0);
break;
case ACT_MAIN_GOTO_URL:
goto_url_action(ses, NULL);
break;
case ACT_MAIN_GOTO_URL_CURRENT:
goto_url_action(ses, get_current_url);
break;
case ACT_MAIN_GOTO_URL_CURRENT_LINK:
goto_url_action(ses, get_current_link_url);
break;
case ACT_MAIN_GOTO_URL_HOME:
goto_url_home(ses);
break;
case ACT_MAIN_HEADER_INFO:
protocol_header_dialog(ses);
break;
case ACT_MAIN_HISTORY_MANAGER:
#ifdef CONFIG_GLOBHIST
history_manager(ses);
#endif
break;
case ACT_MAIN_HISTORY_MOVE_BACK:
{
int count = int_max(1, eat_kbd_repeat_count(ses));
go_history_by_n(ses, -count);
break;
}
case ACT_MAIN_HISTORY_MOVE_FORWARD:
{
int count = int_max(1, eat_kbd_repeat_count(ses));
go_history_by_n(ses, count);
break;
}
case ACT_MAIN_JUMP_TO_LINK:
break;
case ACT_MAIN_KEYBINDING_MANAGER:
keybinding_manager(ses);
break;
case ACT_MAIN_KILL_BACKGROUNDED_CONNECTIONS:
abort_background_connections();
break;
case ACT_MAIN_LINK_DOWNLOAD:
case ACT_MAIN_LINK_DOWNLOAD_IMAGE:
case ACT_MAIN_LINK_DOWNLOAD_RESUME:
status = download_link(ses, doc_view, action_id);
break;
case ACT_MAIN_LINK_EXTERNAL_COMMAND:
status = pass_uri_to_command(ses, doc_view,
PASS_URI_LINK);
break;
case ACT_MAIN_LINK_FOLLOW:
status = enter(ses, doc_view, 0);
break;
case ACT_MAIN_LINK_FOLLOW_RELOAD:
status = enter(ses, doc_view, 1);
break;
case ACT_MAIN_LINK_MENU:
link_menu(term, NULL, ses);
break;
case ACT_MAIN_LINK_FORM_MENU:
link_form_menu(ses);
break;
case ACT_MAIN_LUA_CONSOLE:
#ifdef CONFIG_LUA
trigger_event_name("dialog-lua-console", ses);
#endif
break;
case ACT_MAIN_MARK_SET:
#ifdef CONFIG_MARKS
ses->kbdprefix.mark = KP_MARK_SET;
status = FRAME_EVENT_REFRESH;
#endif
break;
case ACT_MAIN_MARK_GOTO:
#ifdef CONFIG_MARKS
/* TODO: Show promptly a menu (or even listbox?)
* with all the marks. But the next letter must
* still choose a mark directly! --pasky */
ses->kbdprefix.mark = KP_MARK_GOTO;
status = FRAME_EVENT_REFRESH;
#endif
break;
case ACT_MAIN_MENU:
activate_bfu_technology(ses, -1);
break;
case ACT_MAIN_MOVE_CURSOR_UP:
status = move_cursor_up(ses, doc_view);
break;
case ACT_MAIN_MOVE_CURSOR_DOWN:
status = move_cursor_down(ses, doc_view);
break;
case ACT_MAIN_MOVE_CURSOR_LEFT:
status = move_cursor_left(ses, doc_view);
break;
case ACT_MAIN_MOVE_CURSOR_RIGHT:
status = move_cursor_right(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_DOWN:
status = move_link_down(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_LEFT:
status = move_link_left(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_NEXT:
status = move_link_next(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_PREV:
status = move_link_prev(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_RIGHT:
status = move_link_right(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_UP:
status = move_link_up(ses, doc_view);
break;
case ACT_MAIN_MOVE_PAGE_DOWN:
status = move_page_down(ses, doc_view);
break;
case ACT_MAIN_MOVE_PAGE_UP:
status = move_page_up(ses, doc_view);
break;
case ACT_MAIN_MOVE_DOCUMENT_START:
status = move_document_start(ses, doc_view);
break;
case ACT_MAIN_MOVE_DOCUMENT_END:
status = move_document_end(ses, doc_view);
break;
case ACT_MAIN_OPEN_LINK_IN_NEW_TAB:
open_current_link_in_new_tab(ses, 0);
break;
case ACT_MAIN_OPEN_LINK_IN_NEW_TAB_IN_BACKGROUND:
open_current_link_in_new_tab(ses, 1);
break;
case ACT_MAIN_OPEN_LINK_IN_NEW_WINDOW:
open_in_new_window(term, send_open_in_new_window, ses);
break;
case ACT_MAIN_OPEN_NEW_TAB:
open_uri_in_new_tab(ses, NULL, 0, 1);
break;
case ACT_MAIN_OPEN_NEW_TAB_IN_BACKGROUND:
open_uri_in_new_tab(ses, NULL, 1, 1);
break;
case ACT_MAIN_OPEN_NEW_WINDOW:
open_in_new_window(term, send_open_new_window, ses);
break;
case ACT_MAIN_OPEN_OS_SHELL:
exec_shell(term);
break;
case ACT_MAIN_OPTIONS_MANAGER:
options_manager(ses);
break;
case ACT_MAIN_QUIT:
exit_prog(ses, 1);
break;
case ACT_MAIN_REALLY_QUIT:
exit_prog(ses, 0);
break;
case ACT_MAIN_REDRAW:
redraw_terminal_cls(term);
break;
case ACT_MAIN_RELOAD:
reload(ses, CACHE_MODE_INCREMENT);
break;
case ACT_MAIN_RERENDER:
draw_formatted(ses, 2);
break;
case ACT_MAIN_RESET_FORM:
status = reset_form(ses, doc_view, 0);
break;
case ACT_MAIN_RESOURCE_INFO:
resource_info(term);
break;
case ACT_MAIN_SAVE_AS:
status = save_as(ses, doc_view, 0);
break;
case ACT_MAIN_SAVE_FORMATTED:
status = save_formatted_dlg(ses, doc_view, 0);
break;
case ACT_MAIN_SAVE_OPTIONS:
write_config(term);
break;
case ACT_MAIN_SAVE_URL_AS:
save_url_as(ses);
break;
case ACT_MAIN_SCROLL_DOWN:
status = scroll_down(ses, doc_view);
break;
case ACT_MAIN_SCROLL_LEFT:
status = scroll_left(ses, doc_view);
break;
case ACT_MAIN_SCROLL_RIGHT:
status = scroll_right(ses, doc_view);
break;
case ACT_MAIN_SCROLL_UP:
status = scroll_up(ses, doc_view);
break;
case ACT_MAIN_SEARCH:
status = search_dlg(ses, doc_view, 1);
break;
case ACT_MAIN_SEARCH_BACK:
status = search_dlg(ses, doc_view, -1);
break;
case ACT_MAIN_SEARCH_TYPEAHEAD:
case ACT_MAIN_SEARCH_TYPEAHEAD_LINK:
case ACT_MAIN_SEARCH_TYPEAHEAD_TEXT:
case ACT_MAIN_SEARCH_TYPEAHEAD_TEXT_BACK:
status = search_typeahead(ses, doc_view, action_id);
break;
case ACT_MAIN_SHOW_TERM_OPTIONS:
terminal_options(term, NULL, ses);
break;
case ACT_MAIN_SUBMIT_FORM:
status = submit_form(ses, doc_view, 0);
break;
case ACT_MAIN_SUBMIT_FORM_RELOAD:
status = submit_form(ses, doc_view, 1);
break;
case ACT_MAIN_TAB_CLOSE:
close_tab(term, ses);
status = FRAME_EVENT_SESSION_DESTROYED;
break;
case ACT_MAIN_TAB_CLOSE_ALL_BUT_CURRENT:
close_all_tabs_but_current(ses);
break;
case ACT_MAIN_TAB_EXTERNAL_COMMAND:
status = pass_uri_to_command(ses, doc_view,
PASS_URI_TAB);
break;
case ACT_MAIN_TAB_MOVE_LEFT:
move_current_tab(ses, -1);
break;
case ACT_MAIN_TAB_MOVE_RIGHT:
move_current_tab(ses, 1);
break;
case ACT_MAIN_TAB_MENU:
assert(ses->tab == get_current_tab(term));
if (ses->status.show_tabs_bar)
tab_menu(ses, ses->tab->xpos,
term->height - 1
- ses->status.show_status_bar,
1);
else
tab_menu(ses, 0, 0, 0);
break;
case ACT_MAIN_TAB_NEXT:
switch_current_tab(ses, 1);
break;
case ACT_MAIN_TAB_PREV:
switch_current_tab(ses, -1);
break;
case ACT_MAIN_TERMINAL_RESIZE:
resize_terminal_dialog(term);
break;
case ACT_MAIN_TOGGLE_CSS:
#ifdef CONFIG_CSS
toggle_document_option(ses, "document.css.enable");
#endif
break;
case ACT_MAIN_TOGGLE_DISPLAY_IMAGES:
toggle_document_option(ses, "document.browse.images.show_as_links");
break;
case ACT_MAIN_TOGGLE_DISPLAY_TABLES:
toggle_document_option(ses, "document.html.display_tables");
break;
case ACT_MAIN_TOGGLE_DOCUMENT_COLORS:
toggle_document_option(ses, "document.colors.use_document_colors");
break;
case ACT_MAIN_TOGGLE_HTML_PLAIN:
toggle_plain_html(ses, ses->doc_view, 0);
break;
case ACT_MAIN_TOGGLE_MOUSE:
#ifdef CONFIG_MOUSE
toggle_mouse();
#endif
break;
case ACT_MAIN_TOGGLE_NUMBERED_LINKS:
toggle_document_option(ses, "document.browse.links.numbering");
break;
case ACT_MAIN_TOGGLE_PLAIN_COMPRESS_EMPTY_LINES:
toggle_document_option(ses, "document.plain.compress_empty_lines");
break;
case ACT_MAIN_TOGGLE_WRAP_TEXT:
toggle_wrap_text(ses, ses->doc_view, 0);
break;
case ACT_MAIN_VIEW_IMAGE:
status = view_image(ses, doc_view, 0);
break;
case ACT_MAIN_SCRIPTING_FUNCTION:
case ACT_MAIN_NONE:
case MAIN_ACTIONS:
default:
unknown_action:
if (verbose) {
INTERNAL("No action handling defined for '%s'.",
get_action_name(KEYMAP_MAIN, action_id));
}
status = FRAME_EVENT_IGNORED;
}
ignore_action:
/* XXX: At this point the session may have been destroyed */
if (status != FRAME_EVENT_SESSION_DESTROYED
&& ses->insert_mode == INSERT_MODE_ON
&& link != get_current_link(doc_view))
ses->insert_mode = INSERT_MODE_OFF;
if (status == FRAME_EVENT_REFRESH && doc_view)
refresh_view(ses, doc_view, 0);
return status;
}
static int
merge_beg(Cx_t* cx, Cxexpr_t* expr, void* data, Cxdisc_t* disc)
{
register State_t* state;
register File_t* file;
char** argv = (char**)data;
char** files = expr->files;
Dss_t* dss = DSS(cx);
int errors = error_info.errors;
int i;
int k;
int n;
int r;
char* path;
char* u;
char** v;
Cxvariable_t* variable;
Cxoperand_t* operands;
Key_t* key;
Key_t* lastkey;
Key_t* keys;
Vmalloc_t* vm;
if (!(vm = vmopen(Vmdcheap, Vmbest, 0)))
{
if (disc->errorf)
(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
return -1;
}
r = -1;
k = 0;
keys = 0;
sfprintf(cx->buf, "%s%s", strchr(dss_lib_merge.description, '['), merge_usage);
u = sfstruse(cx->buf);
for (;;)
{
switch (i = optget(argv, u))
{
case 'k':
case 'r':
if (!(variable = cxvariable(cx, opt_info.arg, NiL, disc)))
goto bad;
if (!(key = vmnewof(vm, 0, Key_t, 1, 0)))
{
if (disc->errorf)
(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
goto bad;
}
key->variable = variable;
key->sense = (i == 'r') ? -1 : 1;
if (keys)
lastkey = lastkey->next = key;
else
lastkey = keys = key;
k++;
continue;
case '?':
if (disc->errorf)
(*disc->errorf)(NiL, disc, ERROR_USAGE|4, "%s", opt_info.arg);
else
return -1;
continue;
case ':':
if (disc->errorf)
(*disc->errorf)(NiL, disc, 2, "%s", opt_info.arg);
else
return -1;
continue;
}
break;
}
if (error_info.errors > errors)
goto bad;
argv += opt_info.index;
for (v = argv; *v; v++);
n = v - argv;
if (files)
{
for (v = files; *v; v++);
n += v - files;
}
if (!n)
n = 1;
if (!(state = vmnewof(vm, 0, State_t, 1, (n - 1) * sizeof(File_t))) || !(operands = vmnewof(vm, 0, Cxoperand_t, n * k, 0)))
{
if (cx->disc->errorf)
(*cx->disc->errorf)(NiL, cx->disc, ERROR_SYSTEM|2, "out of space");
goto bad;
}
state->cx = cx;
if (!(state->getf = cxcallout(cx, CX_GET, cx->state->type_void, cx->state->type_void, cx->disc)))
{
if (cx->disc->errorf)
(*cx->disc->errorf)(NiL, cx->disc, 2, "CX_GET callout required");
goto bad;
}
state->nfiles = n;
state->nkeys = k;
state->keys = keys;
for (n = 0; n < state->nfiles; n++)
{
state->files[n].data = operands;
operands += k;
}
state->orderdisc.comparf = ordercmp;
if (!(state->order = dtnew(vm, &state->orderdisc, Dtoset)))
{
if (cx->disc->errorf)
(*cx->disc->errorf)(NiL, cx->disc, ERROR_SYSTEM|2, "out of space");
goto bad;
}
n = 0;
if (path = *argv)
argv++;
else if (files)
{
argv = files;
files = 0;
if (path = *argv)
argv++;
}
for (;;)
{
if (!(state->files[n].file = dssfopen(dss, path, NiL, DSS_FILE_READ, NiL)))
goto drop;
enter(dss, state, &state->files[n]);
n++;
if (!(path = *argv++))
{
if (!files)
break;
argv = files;
files = 0;
if (!(path = *argv++))
break;
}
}
expr = expr->pass;
if (dssbeg(dss, expr))
goto drop;
while (file = (File_t*)dtfirst(state->order))
{
if (dsseval(dss, expr, file->record) < 0)
goto drop;
enter(dss, state, file);
}
if (error_info.errors == errors)
r = 0;
drop:
for (n = 0; n < state->nfiles; n++)
if (state->files[n].file)
dssfclose(state->files[n].file);
bad:
vmclose(vm);
return r;
}
void CPmtGrabber::OnNewSection(CSection& section)
{
try
{
// if only service ID given, lookup from PAT
if (GetPid() == 0) // PID 0 is the PAT, so look for matching PMT
{
int PMTPid=m_patgrab.PATRequest(section, m_iServiceId);
if (PMTPid>0)
{
SetPmtPid(PMTPid,m_iServiceId);
SetPid(PMTPid);
}
else
{
LogDebug("PMT Pid wasn't found on the PAT. Channel may have moved, try a new channel scan.");
}
}
if (section.table_id!=2) return;
CEnterCriticalSection enter(m_section);
if (section.section_length<0 || section.section_length>=MAX_SECTION_LENGTH) return;
long serviceId = section.table_id_extension;
if (m_iPmtVersion<0)
LogDebug("pmtgrabber: got pmt %x sid:%x",GetPid(), serviceId);
if (serviceId != m_iServiceId)
{
LogDebug("pmtgrabber: serviceid mismatch %x != %x",serviceId,m_iServiceId);
return;
}
m_iPmtLength=section.section_length;
// copy pmt data for passing it to tvserver
memcpy(m_pmtData,section.Data,m_iPmtLength);
// compare the current section data with the previous one
if (memcmp(section.Data, m_pmtPrevSection.Data, m_iPmtLength)!=0)
{
bool pidsChanged = false;
CPmtParser prevPmtParser;
CPmtParser currPmtParser;
prevPmtParser.SetPid(GetPid());
prevPmtParser.DecodePmtPidTable(m_pmtPrevSection);
currPmtParser.SetPid(GetPid());
// Check if failed - if corrupted it can crash tv service after the callback
if(!currPmtParser.DecodePmtPidTable(section))
{
LogDebug("CPmtGrabber::OnNewSection() - Error decoding PMT from new section, bad signal?");
return;
}
if (!(prevPmtParser.GetPidInfo() == currPmtParser.GetPidInfo()))
{
LogDebug("pmtgrabber: PMT pids changed from:");
prevPmtParser.GetPidInfo().LogPIDs();
LogDebug("pmtgrabber: PMT pids changed to:");
currPmtParser.GetPidInfo().LogPIDs();
pidsChanged = true;
}
m_pmtPrevSection=section;
// do a callback each time the version number changes. this also allows switching for "regional channels"
if (m_pCallback!=NULL && m_iPmtVersion != section.version_number)
{
LogDebug("pmtgrabber: got new pmt version:%x %x, service_id:%x", section.version_number, m_iPmtVersion, serviceId);
// if the pids are different, then a callback is required.
if (pidsChanged)
{
LogDebug("pmtgrabber: do callback pid %x",GetPid());
m_pCallback->OnPMTReceived(GetPid());
}
// otherwise no need to callback, i.e. if _only_ version number changes regulary...
else
{
LogDebug("pmtgrabber: NO callback done because a/v pids still the same.");
}
}
}
m_iPmtVersion=section.version_number;
}
catch(...)
{
LogDebug("CPmtGrabber::OnNewSection exception");
}
}
HomerMenu(KeyPanel& kpl, Scheduler& sch, TemperatureSensor& _tsens,
BarometricSensor& _psens)
: keyPanel(kpl),
scheduler(sch),
tsens(_tsens),
psens(_psens),
mv(root) {
Logger loghomer = Logger::getInstance(LOGHOMERD);
temperature = std::make_shared < MenuLeaf > (tsens);
pressure = std::make_shared < MenuLeaf > (psens);
root->add(welcome);
sensors->add(temperature);
sensors->add(pressure);
system->add(cpu);
system->add(alarms);
root->add(sensors);
root->add(system);
root->home();
active_element = root->getActiveElement();
// Timer on no key press reset menu to Home
timedHome.setCallback([&] () {
leave(nokey);
mutex.lock();
try {
active_element = mv.home();
} catch (MenuEmptyException& e) {
LOG4CPLUS_WARN(loghomer, "timedHome MenuEmptyException " << e.what());
} catch (MenuException& e) {
LOG4CPLUS_ERROR(loghomer, "timedHome MenuException " << e.what());
}
mutex.unlock();
enter(nokey);
});
// Attach key handler
keyPanel.keyAttach(rkeyPanel, [&] ( KeyButton& k ) {
shared_ptr<MenuComponent> temp;
scheduler.ScheduleCancel(timedHome);
if(k.getKey() == BUTTON_ENTER) {
click(k);
} else {
leave(k);
mutex.lock();
try {
active_element = active_element->execMove(mv,k);
} catch (MenuEmptyException& e) {
LOG4CPLUS_WARN(loghomer, "timedHome MenuEmptyException " << e.what());
} catch (MenuException& e) {
LOG4CPLUS_ERROR(loghomer, "timedHome MenuException " << e.what());
}
mutex.unlock();
enter(k);
}
scheduler.ScheduleAfter(std::chrono::seconds(30),timedHome);
});
// Display welcome immediatly
scheduler.ScheduleAfter(std::chrono::milliseconds(100), timedHome);
}
void DynamicVehicle::interaction(const InteractionType type)
{
if (type == ACTION && !currentVehicle)
enter();
}
