void QmlCppEngine::setState(DebuggerState newState, bool forced)
{
EDEBUG("SET MASTER STATE: " << newState);
EDEBUG(" CPP STATE: " << m_cppEngine->state());
EDEBUG(" QML STATE: " << m_qmlEngine->state());
DebuggerEngine::setState(newState, forced);
}
static void
add_myself(void)
{
static const char myself[] = "/proc/self/exe";
static const char moddir[] = PKGLIBDIR;
static const char eprefix[] = "${exec_prefix}";
static const char prefix[] = "${prefix}";
const char *relmoddir;
char wd[PATH_MAX], *dp;
size_t sz;
sz = readlink(myself, wd, sizeof(wd));
wd[sz] = '\0';
if ((dp = strrchr(wd, '/')) == NULL) {
return;
}
/* add the path where the binary resides */
*dp = '\0';
EDEBUG("adding %s\n", wd);
lt_dladdsearchdir(wd);
#define MEMCMPLIT(a, b) memcmp((a), (b), sizeof(b) - 1)
if (moddir[0] == '/') {
/* absolute libdir, add him */
lt_dladdsearchdir(moddir);
return;
} else if (moddir[0] == '.') {
/* relative libdir? relative to what? */
return;
} else if (memcmp(moddir, eprefix, sizeof(eprefix) - 1) == 0) {
/* take the bit after EPREFIX for catting later on */
relmoddir = moddir + sizeof(eprefix) - 1;
} else if (memcmp(moddir, prefix, sizeof(prefix) - 1) == 0) {
/* take the bit after PREFIX for catting later on */
relmoddir = moddir + sizeof(prefix) - 1;
} else {
/* don't know, i guess i'll leave ya to it */
return;
}
/* go back one level in dp */
if ((dp = strrchr(wd, '/')) == NULL) {
return;
} else if (strcmp(dp, "/bin") && strcmp(dp, "/sbin")) {
/* dp doesn't end in /bin nor /sbin */
return;
}
/* good, now we're ready to cat relmoddir to dp */
strncpy(dp, relmoddir, sizeof(wd) - (dp - wd));
EDEBUG("adding %s\n", wd);
lt_dladdsearchdir(wd);
return;
}
static int do_regex(REQUEST *request, char const *lhs, char const *rhs, bool iflag)
{
int compare;
int cflags = REG_EXTENDED;
regex_t reg;
regmatch_t rxmatch[REQUEST_MAX_REGEX + 1];
if (iflag) cflags |= REG_ICASE;
/*
* Include substring matches.
*/
compare = regcomp(®, rhs, cflags);
if (compare != 0) {
if (debug_flag) {
char errbuf[128];
regerror(compare, ®, errbuf, sizeof(errbuf));
EDEBUG("Failed compiling regular expression: %s", errbuf);
}
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
memset(&rxmatch, 0, sizeof(rxmatch)); /* regexec does not seem to initialise unused elements */
compare = regexec(®, lhs, REQUEST_MAX_REGEX + 1, rxmatch, 0);
regfree(®);
rad_regcapture(request, compare, lhs, rxmatch);
return (compare == 0);
}
void vdi_v_curright(VDI_Workstation *vwk)
{
EDEBUG("v_curright: Call not implemented!\n");
vdipb->contrl[N_PTSOUT] = 0;
vdipb->contrl[N_INTOUT] = 0;
}
void vdi_v_hardcopy(VDI_Workstation *vwk)
{
EDEBUG("v_hardcopy: Call not implemented!\n");
vdipb->contrl[N_PTSOUT] = 0;
vdipb->contrl[N_INTOUT] = 0;
}
void vdi_vq_chcells(VDI_Workstation *vwk)
{
EDEBUG("vq_chcells: Call not implemented!\n");
vdipb->contrl[N_PTSOUT] = 0;
vdipb->contrl[N_INTOUT] = 2;
}
static int krb5_instantiate(CONF_SECTION *conf, void *instance)
{
rlm_krb5_t *inst = instance;
krb5_error_code ret;
krb5_keytab keytab;
char keytab_name[200];
char *princ_name;
#ifdef HEIMDAL_KRB5
DEBUG("Using Heimdal Kerberos library");
#else
DEBUG("Using MIT Kerberos library");
#endif
#ifndef KRB5_IS_THREAD_SAFE
if (!krb5_is_thread_safe()) {
DEBUGI("libkrb5 is not threadsafe, recompile it with thread support enabled");
WDEBUG("rlm_krb5 will run in single threaded mode, performance may be degraded");
} else {
WDEBUG("Build time libkrb5 was not threadsafe, but run time library claims to be");
WDEBUG("Reconfigure and recompile rlm_krb5 to enable thread support");
}
#endif
inst->xlat_name = cf_section_name2(conf);
if (!inst->xlat_name) {
inst->xlat_name = cf_section_name1(conf);
}
ret = krb5_init_context(&inst->context);
if (ret) {
EDEBUG("rlm_krb5 (%s): Context initialisation failed: %s", inst->xlat_name, error_message(ret));
return -1;
}
DEBUG("rlm_krb5 (%s): Context initialised successfully", inst->xlat_name);
/*
* Split service principal into service and host components
* they're needed to build the server principal in MIT,
* and to set the validation service in Heimdal.
*/
if (inst->service_princ) {
size_t len;
/* Service principal appears to contain a host component */
inst->hostname = strchr(inst->service_princ, '/');
if (inst->hostname) {
len = (inst->hostname - inst->service_princ);
inst->hostname++;
} else {
len = strlen(inst->service_princ);
}
if (len) {
inst->service = talloc_array(inst, char, (len + 1));
strlcpy(inst->service, inst->service_princ, len + 1);
}
}
void QmlCppEngine::notifyEngineRemoteSetupFailed(const QString &message)
{
EDEBUG("MASTER REMOTE SETUP FAILED");
DebuggerEngine::notifyEngineRemoteSetupFailed(message);
cppEngine()->notifyEngineRemoteSetupFailed(message);
qmlEngine()->notifyEngineRemoteSetupFailed(message);
}
void QmlCppEngine::shutdownEngine()
{
EDEBUG("\nMASTER SHUTDOWN ENGINE");
m_cppEngine->shutdownSlaveEngine();
QmlJS::ConsoleManagerInterface *consoleManager = QmlJS::ConsoleManagerInterface::instance();
if (consoleManager)
consoleManager->setScriptEvaluator(0);
}
void vdi_characters(VDI_Workstation *vwk)
{
if(vdi_charfuncs[vdipb->contrl[SUBROUTINE]] &&
(vdipb->contrl[SUBROUTINE] <= 17) && (vdipb->contrl[SUBROUTINE] >= 0))
vdi_charfuncs[vdipb->contrl[SUBROUTINE]](vwk);
else
EDEBUG("vdi_characters: Subroutine %d doesn't exist!\n",vdipb->contrl[SUBROUTINE]);
}
void QmlCppEngine::notifyEngineRemoteSetupFinished(const RemoteSetupResult &result)
{
EDEBUG("MASTER REMOTE SETUP FINISHED");
DebuggerEngine::notifyEngineRemoteSetupFinished(result);
cppEngine()->notifyEngineRemoteSetupFinished(result);
qmlEngine()->notifyEngineRemoteSetupFinished(result);
}
void QmlCppEngine::notifyEngineRemoteSetupDone(int gdbServerPort, int qmlPort)
{
EDEBUG("MASTER REMOTE SETUP DONE");
DebuggerEngine::notifyEngineRemoteSetupDone(gdbServerPort, qmlPort);
cppEngine()->notifyEngineRemoteSetupDone(gdbServerPort, qmlPort);
qmlEngine()->notifyEngineRemoteSetupDone(gdbServerPort, qmlPort);
}
static int do_regex(REQUEST *request, const char *lhs, const char *rhs, int iflag)
{
int i, compare;
int cflags = REG_EXTENDED;
regex_t reg;
regmatch_t rxmatch[REQUEST_MAX_REGEX + 1];
if (iflag) cflags |= REG_ICASE;
/*
* Include substring matches.
*/
compare = regcomp(®, rhs, cflags);
if (compare != 0) {
if (debug_flag) {
char errbuf[128];
regerror(compare, ®, errbuf, sizeof(errbuf));
EDEBUG("Failed compiling regular expression: %s", errbuf);
}
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
compare = regexec(®, lhs, REQUEST_MAX_REGEX + 1, rxmatch, 0);
regfree(®);
/*
* Add new %{0}, %{1}, etc.
*/
if (compare == 0) for (i = 0; i <= REQUEST_MAX_REGEX; i++) {
char *r;
free(request_data_get(request, request,
REQUEST_DATA_REGEX | i));
/*
* No %{i}, skip it.
* We MAY have %{2} without %{1}.
*/
if (rxmatch[i].rm_so == -1) continue;
/*
* Copy substring into allocated buffer
*/
r = rad_malloc(rxmatch[i].rm_eo -rxmatch[i].rm_so + 1);
memcpy(r, lhs + rxmatch[i].rm_so,
rxmatch[i].rm_eo - rxmatch[i].rm_so);
r[rxmatch[i].rm_eo - rxmatch[i].rm_so] = '\0';
request_data_add(request, request,
REQUEST_DATA_REGEX | i,
r, free);
}
return (compare == 0);
}
void QmlCppEngine::setupEngine()
{
EDEBUG("\nMASTER SETUP ENGINE");
setActiveEngine(m_cppEngine);
m_qmlEngine->setupSlaveEngine();
m_cppEngine->setupSlaveEngine();
if (startParameters().remoteSetupNeeded)
notifyEngineRequestRemoteSetup();
}
void NotifyBox::show(void) {
if(shown())
return;
EDEBUG(ESTRLOC ": %i %i\n", x(), y());
resize_all();
Fl_Window::show();
is_shown = true;
Fl::add_timeout(TIME_SHOWN, visible_timeout_cb, this);
}
static int do_regex(REQUEST *request, value_pair_map_t const *map, bool iflag)
{
int compare, rcode;
int cflags = REG_EXTENDED;
regex_t reg, *preg;
char *lhs, *rhs;
regmatch_t rxmatch[REQUEST_MAX_REGEX + 1];
if (iflag) cflags |= REG_ICASE;
/*
* Expand and then compile it.
*/
if (map->src->type == VPT_TYPE_REGEX) {
rcode = radius_expand_tmpl(&rhs, request, map->src);
if (rcode < 0) {
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
rad_assert(rhs != NULL);
compare = regcomp(®, rhs, cflags);
if (compare != 0) {
if (debug_flag) {
char errbuf[128];
regerror(compare, ®, errbuf, sizeof(errbuf));
EDEBUG("Failed compiling regular expression: %s", errbuf);
}
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
preg = ®
} else {
preg = map->src->vpt_preg;
}
rcode = radius_expand_tmpl(&lhs, request, map->dst);
if (rcode < 0) {
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
rad_assert(lhs != NULL);
memset(&rxmatch, 0, sizeof(rxmatch)); /* regexec does not seem to initialise unused elements */
compare = regexec(preg, lhs, REQUEST_MAX_REGEX + 1, rxmatch, 0);
rad_regcapture(request, compare, lhs, rxmatch);
return (compare == 0);
}
void QmlCppEngine::continueInferior()
{
EDEBUG("\nMASTER CONTINUE INFERIOR"
<< state() << m_qmlEngine->state());
notifyInferiorRunRequested();
if (m_cppEngine->state() == InferiorStopOk) {
m_cppEngine->continueInferior();
} else if (m_qmlEngine->state() == InferiorStopOk) {
m_qmlEngine->continueInferior();
} else {
QTC_ASSERT(false, qDebug() << "MASTER CANNOT CONTINUE INFERIOR"
<< m_cppEngine->state() << m_qmlEngine->state());
notifyEngineIll();
}
}
/*
*
* Verify that a Perl SV is a string and save it in FreeRadius
* Value Pair Format
*
*/
static int pairadd_sv(TALLOC_CTX *ctx, VALUE_PAIR **vps, char *key, SV *sv, FR_TOKEN op)
{
char *val;
VALUE_PAIR *vp;
if (SvOK(sv)) {
val = SvPV_nolen(sv);
vp = pairmake(ctx, vps, key, val, op);
if (vp != NULL) {
DEBUG("rlm_perl: Added pair %s = %s", key, val);
return 1;
} else {
EDEBUG("rlm_perl: Failed to create pair %s = %s", key, val);
}
}
return 0;
}
/*************************************************************************
*
* Function: rlm_sql_fetch_row
*
* Purpose: call the module's sql_fetch_row and implement re-connect
*
*************************************************************************/
int rlm_sql_fetch_row(rlm_sql_handle_t **handle, rlm_sql_t *inst)
{
int ret;
if (!*handle || !(*handle)->conn) {
return -1;
}
/*
* We can't implement reconnect logic here, because the caller may require
* the original connection to free up queries or result sets associated with
* that connection.
*/
ret = (inst->module->sql_fetch_row)(*handle, inst->config);
if (ret < 0) {
char const *error = (inst->module->sql_error)(*handle, inst->config);
EDEBUG("rlm_sql (%s): Error fetching row: %s",
inst->config->xlat_name, error ? error : "<UNKNOWN>");
}
return ret;
}
/*
* Generate the TTLS challenge
*
* It's in the TLS module simply because it's only a few lines
* of code, and it needs access to the TLS PRF functions.
*/
void eapttls_gen_challenge(SSL *s, uint8_t *buffer, size_t size)
{
uint8_t out[32], buf[32];
uint8_t seed[sizeof(FR_TLS_PRF_CHALLENGE)-1 + 2*SSL3_RANDOM_SIZE];
uint8_t *p = seed;
if (!s->s3) {
EDEBUG("No SSLv3 information");
return;
}
memcpy(p, FR_TLS_PRF_CHALLENGE, sizeof(FR_TLS_PRF_CHALLENGE)-1);
p += sizeof(FR_TLS_PRF_CHALLENGE)-1;
memcpy(p, s->s3->client_random, SSL3_RANDOM_SIZE);
p += SSL3_RANDOM_SIZE;
memcpy(p, s->s3->server_random, SSL3_RANDOM_SIZE);
PRF(s->session->master_key, s->session->master_key_length,
seed, sizeof(seed), out, buf, sizeof(out));
memcpy(buffer, out, size);
}
/*
* Actually generates EAP-Session-Id, which is an internal server
* attribute. Not all systems want to send EAP-Key-Nam
*/
void eaptls_gen_eap_key(RADIUS_PACKET *packet, SSL *s, uint32_t header)
{
VALUE_PAIR *vp;
uint8_t *p;
if (!s->s3) {
EDEBUG("No SSLv3 information");
return;
}
vp = paircreate(packet, PW_EAP_SESSION_ID, 0);
if (!vp) return;
vp->length = 1 + 2 * SSL3_RANDOM_SIZE;
p = talloc_array(vp, uint8_t, vp->length);
p[0] = header & 0xff;
memcpy(p + 1, s->s3->client_random, SSL3_RANDOM_SIZE);
memcpy(p + 1 + SSL3_RANDOM_SIZE,
s->s3->server_random, SSL3_RANDOM_SIZE);
vp->vp_octets = p;
pairadd(&packet->vps, vp);
}
/*
* Generate keys according to RFC 2716 and add to reply
*/
void eaptls_gen_mppe_keys(REQUEST *request, SSL *s,
char const *prf_label)
{
unsigned char out[4*EAPTLS_MPPE_KEY_LEN], buf[4*EAPTLS_MPPE_KEY_LEN];
unsigned char seed[64 + 2*SSL3_RANDOM_SIZE];
unsigned char *p = seed;
size_t prf_size;
if (!s->s3) {
EDEBUG("No SSLv3 information");
return;
}
prf_size = strlen(prf_label);
memcpy(p, prf_label, prf_size);
p += prf_size;
memcpy(p, s->s3->client_random, SSL3_RANDOM_SIZE);
p += SSL3_RANDOM_SIZE;
prf_size += SSL3_RANDOM_SIZE;
memcpy(p, s->s3->server_random, SSL3_RANDOM_SIZE);
prf_size += SSL3_RANDOM_SIZE;
PRF(s->session->master_key, s->session->master_key_length,
seed, prf_size, out, buf, sizeof(out));
p = out;
eap_add_reply(request, "MS-MPPE-Recv-Key", p, EAPTLS_MPPE_KEY_LEN);
p += EAPTLS_MPPE_KEY_LEN;
eap_add_reply(request, "MS-MPPE-Send-Key", p, EAPTLS_MPPE_KEY_LEN);
eap_add_reply(request, "EAP-MSK", out, 64);
eap_add_reply(request, "EAP-EMSK", out + 64, 64);
}
void QmlCppEngine::notifyInferiorSetupOk()
{
EDEBUG("\nMASTER INFERIOR SETUP OK");
emit aboutToNotifyInferiorSetupOk();
DebuggerEngine::notifyInferiorSetupOk();
}
void QmlCppEngine::setupInferior()
{
EDEBUG("\nMASTER SETUP INFERIOR");
m_qmlEngine->setupSlaveInferior();
m_cppEngine->setupSlaveInferior();
}
void QmlCppEngine::runEngine()
{
EDEBUG("\nMASTER RUN ENGINE");
m_qmlEngine->runSlaveEngine();
m_cppEngine->runSlaveEngine();
}
void QmlCppEngine::shutdownInferior()
{
EDEBUG("\nMASTER SHUTDOWN INFERIOR");
m_cppEngine->shutdownInferior();
}
static rlm_rcode_t do_linelog(void *instance, REQUEST *request)
{
int fd = -1;
char buffer[4096];
char *p;
char line[1024];
rlm_linelog_t *inst = (rlm_linelog_t*) instance;
char const *value = inst->line;
#ifdef HAVE_GRP_H
gid_t gid;
struct group *grp;
char *endptr;
#endif
if (inst->reference) {
CONF_ITEM *ci;
CONF_PAIR *cp;
p = line + 1;
if (radius_xlat(p, sizeof(line) - 2, request, inst->reference, linelog_escape_func,
NULL) < 0) {
return RLM_MODULE_FAIL;
}
line[0] = '.'; /* force to be in current section */
/*
* Don't allow it to go back up
*/
if (line[1] == '.') goto do_log;
ci = cf_reference_item(NULL, inst->cs, line);
if (!ci) {
RDEBUG2("No such entry \"%s\"", line);
return RLM_MODULE_NOOP;
}
if (!cf_item_is_pair(ci)) {
RDEBUG2("Entry \"%s\" is not a variable assignment ", line);
goto do_log;
}
cp = cf_itemtopair(ci);
value = cf_pair_value(cp);
if (!value) {
RDEBUG2("Entry \"%s\" has no value", line);
goto do_log;
}
/*
* Value exists, but is empty. Don't log anything.
*/
if (!*value) return RLM_MODULE_OK;
}
do_log:
/*
* FIXME: Check length.
*/
if (strcmp(inst->filename, "syslog") != 0) {
if (radius_xlat(buffer, sizeof(buffer), request, inst->filename, NULL, NULL) < 0) {
return RLM_MODULE_FAIL;
}
/* check path and eventually create subdirs */
p = strrchr(buffer,'/');
if (p) {
*p = '\0';
if (rad_mkdir(buffer, 0700) < 0) {
RERROR("rlm_linelog: Failed to create directory %s: %s", buffer, fr_syserror(errno));
return RLM_MODULE_FAIL;
}
*p = '/';
}
fd = fr_logfile_open(inst->lf, buffer, inst->permissions);
if (fd == -1) {
ERROR("rlm_linelog: Failed to open %s: %s",
buffer, fr_syserror(errno));
return RLM_MODULE_FAIL;
}
#ifdef HAVE_GRP_H
if (inst->group != NULL) {
gid = strtol(inst->group, &endptr, 10);
if (*endptr != '\0') {
grp = getgrnam(inst->group);
if (!grp) {
RDEBUG2("Unable to find system group \"%s\"", inst->group);
goto skip_group;
}
gid = grp->gr_gid;
}
if (chown(buffer, -1, gid) == -1) {
RDEBUG2("Unable to change system group of \"%s\"", buffer);
}
}
#endif
}
skip_group:
/*
* FIXME: Check length.
*/
if (radius_xlat(line, sizeof(line) - 1, request, value, linelog_escape_func, NULL) < 0) {
if (fd > -1) {
fr_logfile_close(inst->lf, fd);
}
return RLM_MODULE_FAIL;
}
if (fd >= 0) {
strcat(line, "\n");
if (write(fd, line, strlen(line)) < 0) {
EDEBUG("rlm_linelog: Failed writing: %s", fr_syserror(errno));
fr_logfile_close(inst->lf, fd);
return RLM_MODULE_FAIL;
}
fr_logfile_close(inst->lf, fd);
#ifdef HAVE_SYSLOG_H
} else {
syslog(inst->facility, "%s", line);
#endif
}
return RLM_MODULE_OK;
}
void QmlCppEngine::slaveEngineStateChanged
(DebuggerEngine *slaveEngine, const DebuggerState newState)
{
DebuggerEngine *otherEngine = (slaveEngine == m_cppEngine)
? m_qmlEngine : m_cppEngine;
QTC_CHECK(otherEngine != slaveEngine);
if (debug) {
EDEBUG("GOT SLAVE STATE: " << slaveEngine << newState);
EDEBUG(" OTHER ENGINE: " << otherEngine << otherEngine->state());
EDEBUG(" COMBINED ENGINE: " << this << state() << isDying());
}
// Idea is to follow the state of the cpp engine, except where we are stepping in QML.
// That is, when the QmlEngine moves between InferiorStopOk, and InferiorRunOk, InferiorStopOk ...
//
// Accordingly, the 'active engine' is the cpp engine until the qml engine enters the
// InferiorStopOk state. The cpp engine becomes the active one again as soon as it itself enters
// the InferiorStopOk state.
if (slaveEngine == m_cppEngine) {
switch (newState) {
case DebuggerNotReady: {
// Can this ever happen?
break;
}
case EngineSetupRequested: {
// set by queueSetupEngine()
QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state());
break;
}
case EngineSetupFailed: {
qmlEngine()->quitDebugger();
notifyEngineSetupFailed();
break;
}
case EngineSetupOk: {
notifyEngineSetupOk();
break;
}
case InferiorSetupRequested: {
// set by queueSetupInferior()
QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state());
break;
}
case InferiorSetupFailed: {
qmlEngine()->quitDebugger();
notifyInferiorSetupFailed();
break;
}
case InferiorSetupOk: {
notifyInferiorSetupOk();
break;
}
case EngineRunRequested: {
// set by queueRunEngine()
break;
}
case EngineRunFailed: {
qmlEngine()->quitDebugger();
notifyEngineRunFailed();
break;
}
case InferiorUnrunnable: {
qmlEngine()->quitDebugger();
notifyInferiorUnrunnable();
break;
}
case InferiorRunRequested: {
// might be set already by notifyInferiorRunRequested()
QTC_ASSERT(state() == InferiorRunRequested
|| state() == InferiorStopOk, qDebug() << state());
if (state() != InferiorRunRequested)
notifyInferiorRunRequested();
break;
}
case InferiorRunOk: {
QTC_ASSERT(state() == EngineRunRequested
|| state() == InferiorRunRequested, qDebug() << state());
if (state() == EngineRunRequested)
notifyEngineRunAndInferiorRunOk();
else if (state() == InferiorRunRequested)
notifyInferiorRunOk();
if (qmlEngine()->state() == InferiorStopOk) {
// track qml engine again
setState(InferiorStopRequested);
notifyInferiorStopOk();
setActiveEngine(m_qmlEngine);
}
break;
}
case InferiorRunFailed: {
qmlEngine()->quitDebugger();
notifyInferiorRunFailed();
break;
}
case InferiorStopRequested: {
if (m_activeEngine == cppEngine()) {
// might be set by doInterruptInferior()
QTC_ASSERT(state() == InferiorStopRequested
|| state() == InferiorRunOk, qDebug() << state());
if (state() == InferiorRunOk)
setState(InferiorStopRequested);
} else {
// we're debugging qml, but got an interrupt, or abort
QTC_ASSERT(state() == InferiorRunOk
|| state() == InferiorStopOk
|| state() == InferiorRunRequested, qDebug() << state());
if (state() == InferiorRunOk) {
setState(InferiorStopRequested);
} else if (state() == InferiorStopOk) {
notifyInferiorRunRequested();
notifyInferiorRunOk();
setState(InferiorStopRequested);
} else if (state() == InferiorRunRequested) {
notifyInferiorRunOk();
setState(InferiorStopRequested);
}
// now track cpp engine
setActiveEngine(m_cppEngine);
}
break;
}
case InferiorStopOk: {
if (isDying()) {
EDEBUG("... CPP ENGINE STOPPED DURING SHUTDOWN ");
QTC_ASSERT(state() == InferiorStopRequested
|| state() == InferiorRunOk
|| state() == InferiorStopOk, qDebug() << state());
// Just to make sure, we're shutting down anyway ...
setActiveEngine(m_cppEngine);
if (state() == InferiorStopRequested)
setState(InferiorStopOk);
// otherwise we're probably inside notifyInferiorStopOk already
} else {
if (m_activeEngine != cppEngine()) {
showStatusMessage(tr("C++ debugger activated"));
setActiveEngine(m_cppEngine);
}
QTC_ASSERT(state() == InferiorStopRequested
|| state() == InferiorRunRequested
|| state() == EngineRunRequested
|| state() == InferiorRunOk
|| state() == InferiorStopOk, qDebug() << state());
switch (state()) {
case InferiorStopRequested:
EDEBUG("... CPP ENGINE STOPPED EXPECTEDLY");
notifyInferiorStopOk();
break;
case EngineRunRequested:
EDEBUG("... CPP ENGINE STOPPED ON STARTUP");
notifyEngineRunAndInferiorStopOk();
break;
case InferiorRunOk:
EDEBUG("... CPP ENGINE STOPPED SPONTANEOUSLY");
notifyInferiorSpontaneousStop();
break;
case InferiorRunRequested:
// can happen if qml engine was active
notifyInferiorRunFailed();
default:
break;
}
}
break;
}
case InferiorStopFailed: {
QTC_ASSERT(state() == InferiorStopRequested, qDebug() << state());
notifyInferiorStopFailed();
break;
}
case InferiorExitOk: {
// InferiorExitOk will be called through notifyInferiorExited
// when InferiorShutDownOk is reached
qmlEngine()->quitDebugger();
break;
}
case InferiorShutdownRequested: {
// might be set by queueShutdownInferior() already
QTC_ASSERT(state() == InferiorShutdownRequested
|| state() == InferiorStopOk, qDebug() << state());
if (state() == InferiorStopOk)
setState(InferiorShutdownRequested);
qmlEngine()->quitDebugger();
break;
}
case InferiorShutdownFailed: {
QTC_ASSERT(state() == InferiorShutdownRequested, qDebug() << state());
notifyInferiorShutdownFailed();
break;
}
case InferiorShutdownOk: {
if (state() == InferiorShutdownRequested) {
notifyInferiorShutdownOk();
} else {
// we got InferiorExitOk before, but ignored it ...
notifyInferiorExited();
}
break;
}
case EngineShutdownRequested: {
// set by queueShutdownEngine()
QTC_ASSERT(state() == EngineShutdownRequested, qDebug() << state());
break;
}
case EngineShutdownFailed: {
QTC_ASSERT(state() == EngineShutdownRequested, qDebug() << state());
notifyEngineShutdownFailed();
break;
}
case EngineShutdownOk: {
QTC_ASSERT(state() == EngineShutdownRequested, qDebug() << state());
notifyEngineShutdownOk();
break;
}
case DebuggerFinished: {
// set by queueFinishDebugger()
QTC_ASSERT(state() == DebuggerFinished, qDebug() << state());
break;
}
}
} else {
// QML engine state change
if (newState == InferiorStopOk) {
if (isDying()) {
EDEBUG("... QML ENGINE STOPPED DURING SHUTDOWN ");
// Just to make sure, we're shutting down anyway ...
setActiveEngine(m_cppEngine);
if (state() == InferiorStopRequested)
notifyInferiorStopOk();
// otherwise we're probably inside notifyInferiorStopOk already
} else {
if (m_activeEngine != qmlEngine()) {
showStatusMessage(tr("QML debugger activated"));
setActiveEngine(m_qmlEngine);
}
QTC_ASSERT(state() == InferiorRunOk
|| state() == InferiorStopRequested
|| state() == InferiorShutdownRequested, qDebug() << state());
if (state() == InferiorRunOk)
notifyInferiorSpontaneousStop();
else if (state() == InferiorStopRequested)
notifyInferiorStopOk();
}
} else if (newState == InferiorRunOk) {
if (m_activeEngine == qmlEngine()) {
QTC_ASSERT(state() == InferiorRunRequested, qDebug() << state());
notifyInferiorRunOk();
}
}
}
}
void QmlCppEngine::quitDebugger()
{
EDEBUG("\nMASTER QUIT DEBUGGER");
m_cppEngine->quitDebugger();
}
void QmlCppEngine::abortDebugger()
{
EDEBUG("\nMASTER ABORT DEBUGGER");
m_cppEngine->abortDebugger();
}