自学教程：C++ EDEBUG函数代码示例

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 voidadd_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(&reg, rhs, cflags);	if (compare != 0) {		if (debug_flag) {			char errbuf[128];			regerror(compare, &reg, 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(&reg, lhs, REQUEST_MAX_REGEX + 1, rxmatch, 0);	regfree(&reg);	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 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);}

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(&reg, rhs, cflags);	if (compare != 0) {		if (debug_flag) {			char errbuf[128];			regerror(compare, &reg, errbuf, sizeof(errbuf));			EDEBUG("Failed compiling regular expression: %s", errbuf);		}		EVAL_DEBUG("FAIL %d", __LINE__);		return -1;	}		compare = regexec(&reg, lhs, REQUEST_MAX_REGEX + 1, rxmatch, 0);	regfree(&reg);	/*	 *	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 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(&reg, rhs, cflags);		if (compare != 0) {			if (debug_flag) {				char errbuf[128];				regerror(compare, &reg, errbuf, sizeof(errbuf));				EDEBUG("Failed compiling regular expression: %s", errbuf);			}			EVAL_DEBUG("FAIL %d", __LINE__);			return -1;		}		preg = &reg;	} 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);}

/* * *     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);}

//.........这里部分代码省略.........            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()) {//.........这里部分代码省略.........