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

bool starter_klips_init(void){	struct stat stb;	if (stat(PROC_KLIPS, &stb) != 0)	{		/* ipsec module makes the pf_key proc interface visible */		if (stat(PROC_MODULES, &stb) == 0)		{			ignore_result(system("modprobe -qv ipsec"));		}		/* now test again */		if (stat(PROC_KLIPS, &stb) != 0)		{			DBG2(DBG_APP, "kernel appears to lack the KLIPS IPsec stack");			return FALSE;		}	}	/* load crypto algorithm modules */	ignore_result(system("modprobe -qv ipsec_aes"));	ignore_result(system("modprobe -qv ipsec_blowfish"));	ignore_result(system("modprobe -qv ipsec_sha2"));	DBG2(DBG_APP, "found KLIPS IPsec stack");	return TRUE;}

static void ar9002_hw_setup_calibration(struct ath_hw *ah,					struct ath9k_cal_list *currCal){	REG_RMW_FIELD(ah, AR_PHY_TIMING_CTRL4(0),		      AR_PHY_TIMING_CTRL4_IQCAL_LOG_COUNT_MAX,		      currCal->calData->calCountMax);	switch (currCal->calData->calType) {	case IQ_MISMATCH_CAL:		REG_WRITE(ah, AR_PHY_CALMODE, AR_PHY_CALMODE_IQ);		DBG2("ath9k: "			"starting IQ Mismatch Calibration/n");		break;	case ADC_GAIN_CAL:		REG_WRITE(ah, AR_PHY_CALMODE, AR_PHY_CALMODE_ADC_GAIN);		DBG2("ath9k: "			"starting ADC Gain Calibration/n");		break;	case ADC_DC_CAL:		REG_WRITE(ah, AR_PHY_CALMODE, AR_PHY_CALMODE_ADC_DC_PER);		DBG2("ath9k: "			"starting ADC DC Calibration/n");		break;	}	REG_SET_BIT(ah, AR_PHY_TIMING_CTRL4(0),		    AR_PHY_TIMING_CTRL4_DO_CAL);}

GList* DataStorage::lookup_network(const gchar *a_object_path) {	GList *item = NULL;	DBG3();	if(a_object_path == NULL) {		ERR("no object_path.");		return NULL;	}	if(m_list_networks == NULL) {		DBG2("network not found, list is empty.");		return NULL;	}	item = g_list_find_custom(m_list_networks, a_object_path, compare_object_path);	if(item != NULL) {		DBG2("network found");		return item;	}	else {		DBG2("network not found.");	}	return NULL;}

/* * vdds_cleanup_hybrid_res -- Cleanup Hybrid resource. */voidvdds_cleanup_hybrid_res(void *arg){	vnet_t *vnetp = arg;	vnet_dds_info_t *vdds = &vnetp->vdds_info;	DBG1(vdds, "Hybrid device cleanup...");	mutex_enter(&vdds->lock);	if (vdds->task_flags == VNET_DDS_TASK_ADD_SHARE) {		/*		 * Task for ADD_SHARE is pending, simply		 * cleanup the flags, the task will quit without		 * any changes.		 */		vdds->task_flags = 0;		DBG2(vdds, "Task for ADD is pending, clean flags only");	} else if ((vdds->hio_dip != NULL) && (vdds->task_flags == 0)) {		/*		 * There is no task pending and a hybrid device		 * is present, so dispatch a task to release the share.		 */		vdds->task_flags = VNET_DDS_TASK_REL_SHARE;		(void) ddi_taskq_dispatch(vdds->dds_taskqp,		    vdds_process_dds_msg_task, vnetp, DDI_NOSLEEP);		DBG2(vdds, "Dispatched a task to destroy HIO device");	}	/*	 * Other possible cases include either DEL_SHARE or	 * REL_SHARE as pending. In that case, there is nothing	 * to do as a task is already pending to do the cleanup.	 */	mutex_exit(&vdds->lock);	DBG1(vdds, "Hybrid device cleanup complete");}

/* * Disable UST channel for session and domain. */int channel_ust_disable(struct ltt_ust_session *usess,		struct ltt_ust_channel *uchan){	int ret = LTTNG_OK;	assert(usess);	assert(uchan);	/* Already disabled */	if (uchan->enabled == 0) {		DBG2("Channel UST %s already disabled", uchan->name);		goto end;	}	DBG2("Channel %s being disabled in UST global domain", uchan->name);	/* Disable channel for global domain */	ret = ust_app_disable_channel_glb(usess, uchan);	if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {		ret = LTTNG_ERR_UST_CHAN_DISABLE_FAIL;		goto error;	}	uchan->enabled = 0;	DBG2("Channel %s disabled successfully", uchan->name);	return LTTNG_OK;end:error:	return ret;}

void strb_imm(uint8_t rt, uint8_t rn, uint32_t imm32,		bool index, bool add, bool wback) {	DBG2("strb r%02d, [r%02d, #%08x]/n", rt, rn, imm32);	uint32_t rn_val = CORE_reg_read(rn);	uint32_t rt_val = CORE_reg_read(rt);	uint32_t offset_addr;	if (add) {		offset_addr = rn_val + imm32;	} else {		offset_addr = rn_val - imm32;	}	uint32_t address;	if (index) {		address = offset_addr;	} else {		address = rn_val;	}	DBG2("address: %08x/n", address);	write_byte(address, rt_val & 0xff);	if (wback) {		CORE_reg_write(rn, offset_addr);	}	DBG2("strb_imm ran/n");}

/* * Enable UST channel for session and domain. */int channel_ust_enable(struct ltt_ust_session *usess,		struct ltt_ust_channel *uchan){	int ret = LTTNG_OK;	assert(usess);	assert(uchan);	/* If already enabled, everything is OK */	if (uchan->enabled) {		DBG3("Channel %s already enabled. Skipping", uchan->name);		ret = LTTNG_ERR_UST_CHAN_EXIST;		goto end;	}	DBG2("Channel %s being enabled in UST domain", uchan->name);	/*	 * Enable channel for UST global domain on all applications. Ignore return	 * value here since whatever error we got, it means that the channel was	 * not created on one or many registered applications and we can not report	 * this to the user yet. However, at this stage, the channel was	 * successfully created on the session daemon side so the enable-channel	 * command is a success.	 */	(void) ust_app_enable_channel_glb(usess, uchan);	uchan->enabled = 1;	DBG2("Channel %s enabled successfully", uchan->name);end:	return ret;}

static void ar9003_hw_setup_calibration(struct ath_hw *ah,					struct ath9k_cal_list *currCal){	/* Select calibration to run */	switch (currCal->calData->calType) {	case IQ_MISMATCH_CAL:		/*		 * Start calibration with		 * 2^(INIT_IQCAL_LOG_COUNT_MAX+1) samples		 */		REG_RMW_FIELD(ah, AR_PHY_TIMING4,			      AR_PHY_TIMING4_IQCAL_LOG_COUNT_MAX,		currCal->calData->calCountMax);		REG_WRITE(ah, AR_PHY_CALMODE, AR_PHY_CALMODE_IQ);		DBG2("ath9k: "			"starting IQ Mismatch Calibration/n");		/* Kick-off cal */		REG_SET_BIT(ah, AR_PHY_TIMING4, AR_PHY_TIMING4_DO_CAL);		break;	case TEMP_COMP_CAL:		REG_RMW_FIELD(ah, AR_PHY_65NM_CH0_THERM,			      AR_PHY_65NM_CH0_THERM_LOCAL, 1);		REG_RMW_FIELD(ah, AR_PHY_65NM_CH0_THERM,			      AR_PHY_65NM_CH0_THERM_START, 1);		DBG2("ath9k: "			"starting Temperature Compensation Calibration/n");		break;	}}

/** * Load a generic private key from an ASN.1 encoded blob */static private_key_t *parse_private_key(chunk_t blob){	asn1_parser_t *parser;	chunk_t object, params = chunk_empty;	int objectID;	private_key_t *key = NULL;	key_type_t type = KEY_ANY;	parser = asn1_parser_create(pkinfoObjects, blob);	parser->set_flags(parser, FALSE, TRUE);	while (parser->iterate(parser, &objectID, &object))	{		switch (objectID)		{			case PKINFO_PRIVATE_KEY_ALGORITHM:			{				int oid = asn1_parse_algorithmIdentifier(object,									parser->get_level(parser) + 1, &params);				switch (oid)				{					case OID_RSA_ENCRYPTION:						type = KEY_RSA;						break;					case OID_EC_PUBLICKEY:						type = KEY_ECDSA;						break;					default:						/* key type not supported */						goto end;				}				break;			}			case PKINFO_PRIVATE_KEY:			{				DBG2(DBG_ASN, "-- > --");				if (params.ptr)				{					key = lib->creds->create(lib->creds, CRED_PRIVATE_KEY,											 type, BUILD_BLOB_ALGID_PARAMS,											 params, BUILD_BLOB_ASN1_DER,											 object, BUILD_END);				}				else				{					key = lib->creds->create(lib->creds, CRED_PRIVATE_KEY,											 type, BUILD_BLOB_ASN1_DER, object,											 BUILD_END);				}				DBG2(DBG_ASN, "-- < --");				break;			}		}	}end:	parser->destroy(parser);	return key;}

EXPORT void CORE_reg_write(int r, uint32_t val) {	assert(r >= 0 && r < 16 && "CORE_reg_write");	if (r == SP_REG) {		SW(physical_sp_p, val & 0xfffffffc);	} else if (r == LR_REG) {		SW(&physical_lr, val);	} else if (r == PC_REG) {		DBG2("Writing %08x to PC/n", val & 0xfffffffe);#ifdef NO_PIPELINE		pipeline_flush_exception_handler(val & 0xfffffffe);#else		if (state_is_debugging()) {			DBG1("PC write + debugging --> flush/n");			state_pipeline_flush(val & 0xfffffffe);		} else {			// Only flush if the new PC differs from predicted in pipeline:			if (((SR(&if_id_PC) & 0xfffffffe) - 4) == (val & 0xfffffffe)) {				DBG2("Predicted PC correctly (%08x)/n", val);			} else {				state_pipeline_flush(val & 0xfffffffe);				DBG2("Predicted PC incorrectly/n");				DBG2("Pred: %08x, val: %08x/n", SR(&if_id_PC), val);			}		}#endif	}	else {		SW(&(physical_reg[r]), val);	}}

bool starter_netkey_init(void){	struct stat stb;	if (stat(PROC_NETKEY, &stb) != 0)	{		/* af_key module makes the netkey proc interface visible */		if (stat(PROC_MODULES, &stb) == 0)		{			ignore_result(system("modprobe -qv af_key"));		}		/* now test again */		if (stat(PROC_NETKEY, &stb) != 0)		{			DBG2(DBG_APP, "kernel appears to lack the native netkey IPsec stack");			return FALSE;		}	}	/* make sure that all required IPsec modules are loaded */	if (stat(PROC_MODULES, &stb) == 0)	{		ignore_result(system("modprobe -qv ah4"));		ignore_result(system("modprobe -qv esp4"));		ignore_result(system("modprobe -qv ipcomp"));		ignore_result(system("modprobe -qv xfrm4_tunnel"));		ignore_result(system("modprobe -qv xfrm_user"));	}	DBG2(DBG_APP, "found netkey IPsec stack");	return TRUE;}

void set_Arm (unsigned char mode){#ifdef CMM_ARM_EXPERIMENT	unsigned long cur_pos;	unsigned char old_mode;	unsigned char pct_deployed;	get_ArmPosition(&cur_pos, &old_mode);	if (mode == old_mode) return;	if (old_mode != ARM_STOP)	{		if (cur_pos != arm_pos)		{			pct_deployed = cur_pos / ARM_STROKE_PCT;#ifdef ARM_POS_DEBUG			DBG("Arm moved ");			if (cur_pos > arm_pos)				DBG2("+%lu", cur_pos - arm_pos);			else				DBG2("-%lu", arm_pos - cur_pos);			DBG3(" to %lu (%lu)/n", cur_pos, pct_deployed);#endif			arm_pos = cur_pos;		}	}	else	{		pct_deployed = cur_pos / ARM_STROKE_PCT;	}	if (mode != ARM_STOP) gettimestamp(&arm_start);#endif	switch (mode) {	default:	case ARM_STOP:		ARM(LAT) &= ~(ARM_UPDOWN_MASK | ARM_ONOFF_MASK);		break;	case ARM_UP:		ARM(LAT) &= ~ARM_UPDOWN_MASK;		ARM(LAT) |=  ARM_ONOFF_MASK;		break;	case ARM_DOWN:		ARM(LAT) |= ARM_UPDOWN_MASK;		ARM(LAT) |= ARM_ONOFF_MASK;		break;	}#ifdef CMM_ARM_EXPERIMENT	// % deployed in lower bits, mode in upper bits	eventlog_track(EVENTLOG_ARM, (((uint16_t)pct_deployed) << 8) | mode);#else	eventlog_track(EVENTLOG_ARM, mode);#endif}

/** * Described in header. */bool pts_dh_group_probe(pts_dh_group_t *dh_groups){	enumerator_t *enumerator;	diffie_hellman_group_t dh_group;	const char *plugin_name;	char format1[] = "  %s PTS DH group %N[%s] available";	char format2[] = "  %s PTS DH group %N not available";	*dh_groups = PTS_DH_GROUP_NONE;	enumerator = lib->crypto->create_dh_enumerator(lib->crypto);	while (enumerator->enumerate(enumerator, &dh_group, &plugin_name))	{		if (dh_group == MODP_1024_BIT)		{			*dh_groups |= PTS_DH_GROUP_IKE2;			DBG2(DBG_PTS, format1, "optional ", diffie_hellman_group_names,									dh_group, plugin_name);		}		else if (dh_group == MODP_1536_BIT)		{			*dh_groups |= PTS_DH_GROUP_IKE5;			DBG2(DBG_PTS, format1, "optional ", diffie_hellman_group_names,									dh_group, plugin_name);		}		else if (dh_group == MODP_2048_BIT)		{			*dh_groups |= PTS_DH_GROUP_IKE14;			DBG2(DBG_PTS, format1, "optional ", diffie_hellman_group_names,									dh_group, plugin_name);		}		else if (dh_group == ECP_256_BIT)		{			*dh_groups |= PTS_DH_GROUP_IKE19;			DBG2(DBG_PTS, format1, "mandatory", diffie_hellman_group_names,									dh_group, plugin_name);		}		else if (dh_group == ECP_384_BIT)		{			*dh_groups |= PTS_DH_GROUP_IKE20;			DBG2(DBG_PTS, format1, "optional ", diffie_hellman_group_names,									dh_group, plugin_name);		}	}	enumerator->destroy(enumerator);	if (*dh_groups & PTS_DH_GROUP_IKE19)	{		return TRUE;	}	else	{		DBG1(DBG_PTS, format2, "mandatory", diffie_hellman_group_names,											ECP_256_BIT);	}	return FALSE;}

/* * Defined in header. */size_t asn1_length(chunk_t *blob){	u_char n;	size_t len;	if (blob->len < 2)	{		DBG2(DBG_ASN, "insufficient number of octets to parse ASN.1 length");		return ASN1_INVALID_LENGTH;	}	/* read length field, skip tag and length */	n = blob->ptr[1];	blob->ptr += 2;	blob->len -= 2;	if ((n & 0x80) == 0)	{	/* single length octet */		if (n > blob->len)		{			DBG2(DBG_ASN, "length is larger than remaining blob size");			return ASN1_INVALID_LENGTH;		}		return n;	}	/* composite length, determine number of length octets */	n &= 0x7f;	if (n == 0 || n > blob->len)	{		DBG2(DBG_ASN, "number of length octets invalid");		return ASN1_INVALID_LENGTH;	}	if (n > sizeof(len))	{		DBG2(DBG_ASN, "number of length octets is larger than limit of"			 " %d octets", (int)sizeof(len));		return ASN1_INVALID_LENGTH;	}	len = 0;	while (n-- > 0)	{		len = 256*len + *blob->ptr++;		blob->len--;	}	if (len > blob->len)	{		DBG2(DBG_ASN, "length is larger than remaining blob size");		return ASN1_INVALID_LENGTH;	}	return len;}

static void tea_thread_stop(int tid){  THREAD_WORK *tw;  int r;  /* wait until we have exclusive access right on ttable */  DBG("[tea] Thread %d killing scheduled.", tid);  pthreadex_lock_get_exclusive_n(&ttable_lock, "kill-thread");  /* going to kill thread */  tw = ttable[tid];  pthreadex_lock_release();  if(tw != NULL)  {    DBG("[tea] Killing thread %d.", tid);    /* consider it dead */    ttable[tid] = NULL;    /* allow thread to do the cleanup */    DBG2("[tea] Approve cleanup...");    pthreadex_flag_up(&(tw->cleanup_do));    while((r = pthread_cancel(tw->pthread_id)) != 0 && errno == EINTR)    {      DBG("[tea] Cancel EINTR; repeating pthread_cancel() on %d", tid);      errno = 0;    }    if(r != 0)      ERR_ERRNO("[tea] Cannot cancel thread %d", tid);    /* kill thread */    while((r = pthread_detach(tw->pthread_id)) != 0 && errno == EINTR)    {      DBG("[tea] Detach EINTR; repeating pthread_detach() on  %d", tid);      errno = 0;    }    if(r != 0)      ERR_ERRNO("[tea] Cannot detach thread %d", tid);    /* wait cleanup finishes */    DBG2("[tea] Wait cleanup termination...");    pthreadex_flag_wait(&(tw->cleanup_done));    DBG("[tea] THREAD %d KILLED!", tid);    /* destroy flags && free mem */    pthreadex_flag_destroy(&(tw->mwaiting));    pthreadex_flag_destroy(&(tw->cleanup_do));    pthreadex_flag_destroy(&(tw->cleanup_done));    free(tw);  } else    ERR("[tea] Thread %d does not exist or died voluntarely.", tid);}

/** * Load a generic public key from an ASN.1 encoded blob */static public_key_t *parse_public_key(chunk_t blob){	asn1_parser_t *parser;	chunk_t object;	int objectID;	public_key_t *key = NULL;	key_type_t type = KEY_ANY;	parser = asn1_parser_create(pkinfoObjects, blob);	while (parser->iterate(parser, &objectID, &object))	{		switch (objectID)		{			case PKINFO_SUBJECT_PUBLIC_KEY_ALGORITHM:			{				int oid = asn1_parse_algorithmIdentifier(object,										parser->get_level(parser)+1, NULL);				if (oid == OID_RSA_ENCRYPTION || oid == OID_RSAES_OAEP)				{					type = KEY_RSA;				}				else if (oid == OID_EC_PUBLICKEY)				{					/* we need the whole subjectPublicKeyInfo for EC public keys */					key = lib->creds->create(lib->creds, CRED_PUBLIC_KEY,								KEY_ECDSA, BUILD_BLOB_ASN1_DER, blob, BUILD_END);					goto end;				}				else				{					/* key type not supported */					goto end;				}				break;			}			case PKINFO_SUBJECT_PUBLIC_KEY:				if (object.len > 0 && *object.ptr == 0x00)				{					/* skip initial bit string octet defining 0 unused bits */					object = chunk_skip(object, 1);				}				DBG2(DBG_ASN, "-- > --");				key = lib->creds->create(lib->creds, CRED_PUBLIC_KEY, type,										 BUILD_BLOB_ASN1_DER, object, BUILD_END);				DBG2(DBG_ASN, "-- < --");				break;		}	}end:	parser->destroy(parser);	return key;}

/** * Extract X.501 attributes */void extract_attributes(pkcs7_t *pkcs7, scep_attributes_t *attrs){	pkcs9_t *attributes = pkcs7->get_attributes(pkcs7);	chunk_t attr;	attr = attributes->get_attribute(attributes, OID_PKI_MESSAGE_TYPE);	if (attr.ptr)	{		scep_msg_t m;		for (m = SCEP_CertRep_MSG; m < SCEP_Unknown_MSG; m++)		{			if (strncmp(msgType_values[m], attr.ptr, attr.len) == 0)			{				attrs->msgType = m;			}		}		DBG2(DBG_APP, "messageType:  %s", msgType_names[attrs->msgType]);	}	attr = attributes->get_attribute(attributes, OID_PKI_STATUS);	if (attr.ptr)	{		pkiStatus_t s;		for (s = SCEP_SUCCESS; s < SCEP_UNKNOWN; s++)		{			if (strncmp(pkiStatus_values[s], attr.ptr, attr.len) == 0)			{				attrs->pkiStatus = s;			}		}		DBG2(DBG_APP, "pkiStatus:    %s", pkiStatus_names[attrs->pkiStatus]);	}	attr = attributes->get_attribute(attributes, OID_PKI_FAIL_INFO);	if (attr.ptr)	{		if (attr.len == 1 && *attr.ptr >= '0' && *attr.ptr <= '4')		{			attrs->failInfo = (failInfo_t)(*attr.ptr - '0');		}		if (attrs->failInfo != SCEP_unknown_REASON)		{			DBG1(DBG_APP, "failInfo:     %s", failInfo_reasons[attrs->failInfo]);		}	}	attrs->senderNonce = attributes->get_attribute(attributes,											OID_PKI_SENDER_NONCE);	attrs->recipientNonce = attributes->get_attribute(attributes,											OID_PKI_RECIPIENT_NONCE);	attrs->transID = attributes->get_attribute(attributes,											OID_PKI_TRANS_ID);}

usbMsgLen_t usbFunctionSetup(uchar data[8]){    usbRequest_t    *rq = (void *)data;    static uchar    dataBuffer[4];  /* buffer must stay valid when usbFunctionSetup returns, therefore static */    uint8_t         msgLen = 0;     /* default for not implemented requests: return no data back to host */        DBG1(0x03, &rq->bRequest, 1);    DBG1(0x04, &rq->wValue.bytes[0], 2);        switch (rq->bRequest) {        case CUSTOM_RQ_ECHO:            dataBuffer[0] = rq->wValue.bytes[0];            dataBuffer[1] = rq->wValue.bytes[1];            dataBuffer[2] = rq->wIndex.bytes[0];            dataBuffer[3] = rq->wIndex.bytes[1];            msgLen = 4;            break;                case CUSTOM_RQ_SET_STATUS:            if(rq->wValue.bytes[0] & 1){    /* set LED */                led_on(LED_RED);            }else{                                          led_off(LED_RED);           /* clear LED */            }                        break;                    case CUSTOM_RQ_GET_STATUS:            dataBuffer[0] = (led_status(LED_RED) != 0);            msgLen = 1;                     /* tell the driver to send 1 byte */            break;                case CUSTOM_RQ_GET_TEMPERATURE:            sht1x_measure(SHT_CMD_MEASURE_TEMPERATURE, &dataBuffer[0]);            //sser_getWord(SHT_CMD_MEASURE_TEMPERATURE, &dataBuffer[0]);            msgLen = 2;            DBG2(0x05, &dataBuffer[0], 2);            break;        case CUSTOM_RQ_GET_HUMIDITY:            sht1x_measure(SHT_CMD_MEASURE_HUMIDITY, &dataBuffer[0]);            //sser_getWord(SHT_CMD_MEASURE_HUMIDITY, &dataBuffer[0]);            msgLen = 2;            DBG2(0x05, &dataBuffer[0], 2);            break;                    default:            break;    }    usbMsgPtr = dataBuffer;         /* tell the driver which data to return */    return msgLen;                  /* tell the driver lenght of data to send */}

void BuzzMDKHelper::SetInputChannels(char const *szMachine, bool bStereo) {	DBG2("(szMachine=%s,bStereo=%d)/n",szMachine,bStereo);/*	CMachine * pMachine = pmi->pCB->GetMachine(szMachine);	if (!pMachine)	{		// machine doesn't exist!		return;	}//	if (!(pMachine->cMachineInfo->Flags & MIF_MONO_TO_STEREO) )//	{//		// machine can't do stereo so leave this input channel as mono//		bStereo = false;//	}//	else	{		for (INPUTITERATOR i = Inputs.begin(); i != Inputs.end(); ++i)		{			if (i->strName.compare(szMachine) == 0)			{				i->bStereo = bStereo;				break;			}		}	}	// change from mono output to stereo output if this input is itself stereo	// and the machine (up until now) would've been mono-output	if (MachineWantsChannels==1)	{		SetOutputMode(bStereo);	}*/}

void    usbSetInterrupt(uchar *data, uchar len){uchar       *p, i;#if USB_CFG_IMPLEMENT_HALT    if(usbTxLen1 == USBPID_STALL)        return;#endif#if 0   /* No runtime checks! Caller is responsible for valid data! */    if(len > 8) /* interrupt transfers are limited to 8 bytes */        len = 8;#endif    i = USBPID_DATA1;    if(usbTxPacketCnt1 & 1)        i = USBPID_DATA0;    if(usbTxLen1 & 0x10){       /* packet buffer was empty */        usbTxPacketCnt1++;    }else{        usbTxLen1 = USBPID_NAK; /* avoid sending incomplete interrupt data */    }    p = usbTxBuf1;    *p++ = i;    for(i=len;i--;)        *p++ = *data++;    usbCrc16Append(&usbTxBuf1[1], len);    usbTxLen1 = len + 4;    /* len must be given including sync byte */    DBG2(0x21, usbTxBuf1, len + 3);}

voidadd_ml_var(MLVars *ml_vars, mxArray *array, const char *vname){    _MLVar *node = mxMalloc(sizeof(_MLVar));    char *varName = mxMalloc(sizeof(char) * (strlen(vname)+1));	mxAssert(ml_vars, "NULL ML Variable list");    strcpy(varName, vname);    /* Make the new node */    node->_array = array;    node->_vname = varName;    node->_next = NULL;    DBG2(msg("add_new_ml_var: %s, node: %d/n",varName,node));    /* If the list is empty, this is the `base' */    if (ml_vars->_base == NULL)	ml_vars->_base = node;    /* If the list is not empty, link this to the end */    if (ml_vars->_end != NULL)	ml_vars->_end->_next = node;    /* Make this the end node */    ml_vars->_end = node;    /* Do bookkeeping */    ml_vars->_length++;    ml_vars->_current = node;}

int get_random_value(unsigned char *data, int length){  static const char *random_device = "/dev/urandom";  int rv, fh, l;  DBG2("reading %d random bytes from %s", length, random_device);  fh = open(random_device, O_RDONLY);  if (fh == -1) {    set_error("open() failed: %s", strerror(errno));    return -1;  }  l = 0;  while (l < length) {    rv = read(fh, data + l, length - l);    if (rv <= 0) {      close(fh);      set_error("read() failed: %s", strerror(errno));      return -1;    }    l += rv;  }  close(fh);  DBG5("random-value[%d] = [%02x:%02x:%02x:...:%02x]", length, data[0],      data[1], data[2], data[length - 1]);  return 0;}

/** * Prepend a PT-TLS header to a writer, send data, destroy writer */bool pt_tls_write(tls_socket_t *tls, pt_tls_message_type_t type,				  uint32_t identifier, chunk_t data){	bio_writer_t *writer;	chunk_t out;	ssize_t len;	len = PT_TLS_HEADER_LEN + data.len;	writer = bio_writer_create(len);	/* write PT-TLS header */	writer->write_uint8 (writer, 0);	writer->write_uint24(writer, 0);	writer->write_uint32(writer, type);	writer->write_uint32(writer, len);	writer->write_uint32(writer, identifier);	/* write PT-TLS body */	writer->write_data(writer, data);	DBG2(DBG_TNC, "sending PT-TLS message #%d of type '%N' (%d bytes)",				   identifier, pt_tls_message_type_names, type, len);	out = writer->get_buf(writer);	len = tls->write(tls, out.ptr, out.len);	writer->destroy(writer);	return len == out.len;}

/* * Send channel previously received from the consumer to the UST tracer. * * On success return 0 else a negative value. */int ust_consumer_send_channel_to_ust(struct ust_app *app,		struct ust_app_session *ua_sess, struct ust_app_channel *channel){	int ret;	assert(app);	assert(ua_sess);	assert(channel);	assert(channel->obj);	DBG2("UST app send channel to sock %d pid %d (name: %s, key: %" PRIu64 ")",			app->sock, app->pid, channel->name, channel->tracing_channel_id);	/* Send stream to application. */	pthread_mutex_lock(&app->sock_lock);	ret = ustctl_send_channel_to_ust(app->sock, ua_sess->handle, channel->obj);	pthread_mutex_unlock(&app->sock_lock);	if (ret < 0) {		if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {			ERR("Error ustctl send channel %s to app pid: %d with ret %d",					channel->name, app->pid, ret);		} else {			DBG3("UST app send channel to ust failed. Application is dead.");		}		goto error;	}error:	return ret;}

/* * Send a given stream to UST tracer. * * On success return 0 else a negative value. */int ust_consumer_send_stream_to_ust(struct ust_app *app,		struct ust_app_channel *channel, struct ust_app_stream *stream){	int ret;	assert(app);	assert(stream);	assert(channel);	DBG2("UST consumer send stream to app %d", app->sock);	/* Relay stream to application. */	pthread_mutex_lock(&app->sock_lock);	ret = ustctl_send_stream_to_ust(app->sock, channel->obj, stream->obj);	pthread_mutex_unlock(&app->sock_lock);	if (ret < 0) {		if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {			ERR("ustctl send stream handle %d to app pid: %d with ret %d",					stream->obj->handle, app->pid, ret);		} else {			DBG3("UST app send stream to ust failed. Application is dead.");		}		goto error;	}	channel->handle = channel->obj->handle;error:	return ret;}

/** * Handle expired timer * * @v timer		Retry timer */static void timer_expired ( struct retry_timer *timer ) {	int fail;	/* Stop timer without performing RTT calculations */	DBG2 ( "Timer %p stopped at time %ld on expiry/n",	       timer, currticks() );	assert ( timer->running );	list_del ( &timer->list );	timer->running = 0;	timer->count++;	/* Back off the timeout value */	timer->timeout <<= 1;	if ( timer->max_timeout == 0 ) /* 0 means "use default timeout" */		timer->max_timeout = DEFAULT_MAX_TIMEOUT;	if ( ( fail = ( timer->timeout > timer->max_timeout ) ) )		timer->timeout = timer->max_timeout;	DBG ( "Timer %p timeout backed off to %ld/n",	      timer, timer->timeout );	/* Call expiry callback */	timer->expired ( timer, fail );	ref_put ( timer->refcnt );}

GdkPixmap *fb_bg_get_xroot_pix_for_win(FbBg *bg, GtkWidget *widget){    Window win;    Window dummy;    Pixmap bgpix;    GdkPixmap *gbgpix;    int  width, height ;    int  border, depth, x, y ;    ENTER;    win =  GDK_WINDOW_XWINDOW(widget->window);     if (!XGetGeometry(bg->dpy, win, &dummy, &x, &y, &width, &height, &border, &depth)) {        DBG2("XGetGeometry failed/n");        RET(NULL);    }    XTranslateCoordinates(bg->dpy, win, bg->xroot, 0, 0, &x, &y, &dummy);    DBG("win=%x %dx%d%+d%+d/n", win, width, height, x, y);    gbgpix = gdk_pixmap_new(NULL, width, height, depth);    if (!gbgpix) {        ERR("gdk_pixmap_new failed/n");        RET(NULL);    }    bgpix =  gdk_x11_drawable_get_xid(gbgpix);    XSetTSOrigin(bg->dpy, bg->gc, -x, -y) ;    XFillRectangle(bg->dpy, bgpix, bg->gc, 0, 0, width, height);    RET(gbgpix);}

void    usbSetInterrupt(uchar *data, uchar len){uchar       *p, i;#if USB_CFG_IMPLEMENT_HALT    if(usbHalted1)        return;#endif    if(len > 8) /* interrupt transfers are limited to 8 bytes */        len = 8;    i = USBPID_DATA1;    if(usbTxPacketCnt1 & 1)        i = USBPID_DATA0;    if(usbTxLen1 < 0){      /* packet buffer was empty */        usbTxPacketCnt1++;    }else{        usbTxLen1 = -1;     /* avoid sending incomplete interrupt data */    }    p = usbTxBuf1;    *p++ = i;    for(i=len;i--;)        *p++ = *data++;    usbCrc16Append(&usbTxBuf1[1], len);    usbTxLen1 = len + 4;    /* len must be given including sync byte */#if DEBUG_LEVEL > 1    DBG2(0x21, usbTxBuf1, usbTxLen1-1);#else    DBG1(0x21, usbTxBuf1 + 1, 2);#endif}

static void usbBuildTxBlock(void){uchar       wantLen, len, txLen, token;    wantLen = usbMsgLen;    if(wantLen > 8)        wantLen = 8;    usbMsgLen -= wantLen;    token = USBPID_DATA1;    if(usbMsgFlags & USB_FLG_TX_PACKET)        token = USBPID_DATA0;    usbMsgFlags++;    len = usbRead(usbTxBuf + 1, wantLen);    if(len <= 8){           /* valid data packet */        usbCrc16Append(usbTxBuf + 1, len);        txLen = len + 4;    /* length including sync byte */        if(len < 8)         /* a partial package identifies end of message */            usbMsgLen = 0xff;    }else{        token = USBPID_STALL;        txLen = 2;          /* length including sync byte */        usbMsgLen = 0xff;    }    usbTxBuf[0] = token;    usbTxLen = txLen;#if DEBUG_LEVEL > 1    DBG2(0x20, usbTxBuf, txLen-1);#else    DBG1(0x20, usbTxBuf + 1, 2);#endif}

/* * vdds_mod_init -- one time initialization. */voidvdds_mod_init(void){	int i;	int rv;	uint64_t minor = 0;	/*	 * Try register one by one from niu_hsvc.	 */	for (i = 0; i < (sizeof (niu_hsvc) / sizeof (hsvc_info_t)); i++) {		rv = hsvc_register(&niu_hsvc[i], &minor);		if (rv == 0) {			if (minor == niu_hsvc[i].hsvc_minor) {				vdds_hv_hio_capable = B_TRUE;				niu_hsvc_index = i;				break;			} else {				(void) hsvc_unregister(&niu_hsvc[i]);			}		}	}	mutex_init(&vdds_dev_lock, NULL, MUTEX_DRIVER, NULL);	DBG2(NULL, "HV HIO capable=%d ver(%ld.%ld)", vdds_hv_hio_capable,	    (niu_hsvc_index == -1) ? 0 : niu_hsvc[niu_hsvc_index].hsvc_major,	    minor);}