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

	bool AddSeg(seg_t *seg)	{		FGLSectionLine &line = SectionLines[SectionLines.Reserve(1)];		bool firstline = loop->numlines == 0;		if (ISDONE(seg-segs, processed_segs))		{			// should never happen!			DPrintf("Tried to add seg %d to Sections twice. Cannot create Sections./n", seg-segs);			return false;		}		SETDONE(seg-segs, processed_segs);		section_for_segs[seg-segs] = Sections.Size()-1;		line.start = seg->v1;		line.end = seg->v2;		line.sidedef = seg->sidedef;		line.linedef = seg->linedef;		line.refseg = seg;		line.polysub = NULL;		line.otherside = -1;		if (loop->numlines == 0)		{			v1_l1 = seg->v1;			v2_l1 = seg->v2;		}		loop->numlines++;		return true;	}

/*todo: sta based statistics need to be implemented in wlan driver*/static int wapimib_get_stastats_from_driver(char* ifname, char* macaddr, struct ieee80211req_sta_stats* stats){	struct iwreq iwr;		int sock = socket(AF_INET, SOCK_DGRAM, 0);	if(sock<0)	{			return -1;	}	(void) memset(&iwr, 0, sizeof(iwr));	(void) strncpy(iwr.ifr_name, ifname, sizeof(iwr.ifr_name));	iwr.u.data.pointer = (void *) stats;	iwr.u.data.length = sizeof(struct ieee80211req_sta_stats);	memcpy(stats->is_u.macaddr, macaddr, 6);	DPrintf("[WAPID]::get stastats from %s, chars %d, ioctl 0x%x: 0x%x/n",			iwr.ifr_name, strlen(iwr.ifr_name),IEEE80211_IOCTL_STA_STATS, SIOCDEVPRIVATE);	if (ioctl(sock, IEEE80211_IOCTL_STA_STATS, &iwr) < 0)	{		close(sock);		return -1;	}	close(sock);	return 0;}

bool CTXVirtQueue::PrepareBuffers(){    auto NumBuffers = min(m_MaxBuffers, GetRingSize());    for (m_TotalDescriptors = 0; m_TotalDescriptors < NumBuffers; m_TotalDescriptors++)    {        auto TXDescr = new (m_Context->MiniportHandle) CTXDescriptor();        if (TXDescr == nullptr)        {            break;        }        if (!TXDescr->Create(m_DrvHandle,            m_HeaderSize,            m_SGTable,            m_SGTableCapacity,            m_Context->bUseIndirect ? true : false,            m_Context->bAnyLayout ? true : false))        {            CTXDescriptor::Destroy(TXDescr, m_Context->MiniportHandle);            break;        }        m_Descriptors.Push(TXDescr);    }    m_FreeHWBuffers = m_TotalHWBuffers = NumBuffers;    DPrintf(0, "[%s] available %d Tx descriptors/n", __FUNCTION__, m_TotalDescriptors);    return m_TotalDescriptors > 0;}

void CParaNdisRX::PopulateQueue(){    LIST_ENTRY TempList;    TPassiveSpinLocker autoLock(m_Lock);    InitializeListHead(&TempList);    while (!IsListEmpty(&m_NetReceiveBuffers))    {        pRxNetDescriptor pBufferDescriptor =            (pRxNetDescriptor)RemoveHeadList(&m_NetReceiveBuffers);        InsertTailList(&TempList, &pBufferDescriptor->listEntry);    }    m_NetNofReceiveBuffers = 0;    while (!IsListEmpty(&TempList))    {        pRxNetDescriptor pBufferDescriptor =            (pRxNetDescriptor)RemoveHeadList(&TempList);        if (AddRxBufferToQueue(pBufferDescriptor))        {            InsertTailList(&m_NetReceiveBuffers, &pBufferDescriptor->listEntry);            m_NetNofReceiveBuffers++;        }        else        {            /* TODO - NetMaxReceiveBuffers should take into account all queues */            DPrintf(0, "FAILED TO REUSE THE BUFFER!!!!/n");            ParaNdis_FreeRxBufferDescriptor(m_Context, pBufferDescriptor);            m_Context->NetMaxReceiveBuffers--;        }    }    m_Reinsert = true;}

int CParaNdisRX::PrepareReceiveBuffers(){    int nRet = 0;    UINT i;    DEBUG_ENTRY(4);    for (i = 0; i < m_Context->NetMaxReceiveBuffers; ++i)    {        pRxNetDescriptor pBuffersDescriptor = CreateRxDescriptorOnInit();        if (!pBuffersDescriptor) break;        pBuffersDescriptor->Queue = this;        if (!AddRxBufferToQueue(pBuffersDescriptor))        {            ParaNdis_FreeRxBufferDescriptor(m_Context, pBuffersDescriptor);            break;        }        InsertTailList(&m_NetReceiveBuffers, &pBuffersDescriptor->listEntry);        m_NetNofReceiveBuffers++;    }    /* TODO - NetMaxReceiveBuffers should take into account all queues */    m_Context->NetMaxReceiveBuffers = m_NetNofReceiveBuffers;    DPrintf(0, "[%s] MaxReceiveBuffers %d/n", __FUNCTION__, m_Context->NetMaxReceiveBuffers);    m_Reinsert = true;    return nRet;}

static VOID PostLinkState(PARANDIS_ADAPTER *pContext, NDIS_MEDIA_CONNECT_STATE connectState){    NDIS_STATUS_INDICATION  indication;    NDIS_LINK_STATE         state;    NdisZeroMemory(&state, sizeof(state));    state.Header.Revision = NDIS_LINK_STATE_REVISION_1;    state.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;    state.Header.Size = NDIS_SIZEOF_LINK_STATE_REVISION_1;    state.MediaConnectState = connectState;    state.MediaDuplexState = MediaDuplexStateFull;    state.RcvLinkSpeed = state.XmitLinkSpeed =        connectState == MediaConnectStateConnected ?            PARANDIS_MAXIMUM_RECEIVE_SPEED :            NDIS_LINK_SPEED_UNKNOWN;    state.PauseFunctions = NdisPauseFunctionsUnsupported;    NdisZeroMemory(&indication, sizeof(indication));    indication.Header.Type = NDIS_OBJECT_TYPE_STATUS_INDICATION;    indication.Header.Revision = NDIS_STATUS_INDICATION_REVISION_1;    indication.Header.Size = NDIS_SIZEOF_STATUS_INDICATION_REVISION_1;    indication.SourceHandle = pContext->MiniportHandle;    indication.StatusCode = NDIS_STATUS_LINK_STATE;    indication.StatusBuffer = &state;    indication.StatusBufferSize = sizeof(state);    DPrintf(0, ("Indicating %s/n", ConnectStateName(connectState)));    ParaNdis_DebugHistory(pContext, hopConnectIndication, NULL, connectState, 0, 0);    NdisMIndicateStatusEx(pContext->MiniportHandle , &indication);}

static NDIS_STATUS ReadGlobalConfigurationEntry(NDIS_HANDLE cfg, const char *_name, PULONG pValue){    NDIS_STATUS status;    PNDIS_CONFIGURATION_PARAMETER pParam = NULL;    NDIS_STRING name = {0};    const char *statusName;    NDIS_PARAMETER_TYPE ParameterType = NdisParameterInteger;    NdisInitializeString(&name, (PUCHAR)_name);#pragma warning(push)#pragma warning(disable:6102)    NdisReadConfiguration(        &status,        &pParam,        cfg,        &name,        ParameterType);    if (status == NDIS_STATUS_SUCCESS)    {        *pValue = pParam->ParameterData.IntegerData;        statusName = "value";    }    else    {        statusName = "nothing";    }#pragma warning(pop)    DPrintf(2, ("[%s] %s read for %s - 0x%x/n", __FUNCTION__, statusName, _name, *pValue));    if (name.Buffer) NdisFreeString(name);    return status;}

int CParaNdisRX::PrepareReceiveBuffers(){    UINT i;    DEBUG_ENTRY(4);    NdisZeroMemory(m_ReservedRxBufferMemory, sizeof(m_ReservedRxBufferMemory));    m_RxBufferIndex = 0;    m_RxBufferOffset = 0;    for (i = 0; i < m_Context->NetMaxReceiveBuffers; ++i)    {        pRxNetDescriptor pBuffersDescriptor = CreateRxDescriptorOnInit();        if (!pBuffersDescriptor) break;        pBuffersDescriptor->Queue = this;        if (!AddRxBufferToQueue(pBuffersDescriptor))        {            ParaNdis_FreeRxBufferDescriptor(m_Context, pBuffersDescriptor);            break;        }        InsertTailList(&m_NetReceiveBuffers, &pBuffersDescriptor->listEntry);        m_NetNofReceiveBuffers++;    }    /* TODO - NetMaxReceiveBuffers should take into account all queues */    m_Context->NetMaxReceiveBuffers = m_NetNofReceiveBuffers;    DPrintf(0, ("[%s] MaxReceiveBuffers %d/n", __FUNCTION__, m_Context->NetMaxReceiveBuffers));    m_Reinsert = true;    m_VirtQueue.Kick();    return m_NetNofReceiveBuffers;}

XMISong::XMISong (FileReader &reader, EMidiDevice type, const char *args): MIDIStreamer(type, args), MusHeader(0), Songs(0){	SongLen = reader.GetLength();	MusHeader = new uint8_t[SongLen];	if (reader.Read(MusHeader, SongLen) != SongLen)		return;	// Find all the songs in this file.	NumSongs = FindXMIDforms(MusHeader, SongLen, NULL);	if (NumSongs == 0)	{		return;	}	// XMIDI files are played with a constant 120 Hz clock rate. While the	// song may contain tempo events, these are vestigial remnants from the	// original MIDI file that were not removed by the converter and should	// be ignored.	//	// We can use any combination of Division and Tempo values that work out	// to be 120 Hz.	Division = 60;	InitialTempo = 500000;	Songs = new TrackInfo[NumSongs];	memset(Songs, 0, sizeof(*Songs) * NumSongs);	FindXMIDforms(MusHeader, SongLen, Songs);	CurrSong = Songs;	DPrintf(DMSG_SPAMMY, "XMI song count: %d/n", NumSongs);}

bool PClass::ReadAllFields(FSerializer &ar, void *addr) const{	bool readsomething = false;	bool foundsomething = false;	const char *key;	key = ar.GetKey();	if (strcmp(key, "classtype"))	{		// this does not represent a DObject		Printf(TEXTCOLOR_RED "trying to read user variables but got a non-object (first key is '%s')", key);		ar.mErrors++;		return false;	}	while ((key = ar.GetKey()))	{		if (strncmp(key, "class:", 6))		{			// We have read all user variable blocks.			break;		}		foundsomething = true;		PClass *type = PClass::FindClass(key + 6);		if (type != nullptr)		{			// Only read it if the type is related to this one.			if (IsDescendantOf(type))			{				if (ar.BeginObject(nullptr))				{					readsomething |= type->VMType->Symbols.ReadFields(ar, addr, type->TypeName.GetChars());					ar.EndObject();				}			}			else			{				DPrintf(DMSG_ERROR, "Unknown superclass %s of class %s/n",					type->TypeName.GetChars(), TypeName.GetChars());			}		}		else		{			DPrintf(DMSG_ERROR, "Unknown superclass %s of class %s/n",				key+6, TypeName.GetChars());		}	}	return readsomething || !foundsomething;}

/* The notify function used when creating a virt queue, common to both modern * and legacy (the difference is in how vq->priv is set up). */bool vp_notify(struct virtqueue *vq){    /* we write the queue's selector into the notification register to     * signal the other end */    iowrite16(vq->vdev, (unsigned short)vq->index, vq->priv);    DPrintf(0, ("virtio: vp_notify vq->index = %x/n", vq->index));    return true;}

NDIS_STATUS ParaNdis_ConfigureMSIXVectors(PARANDIS_ADAPTER *pContext){    NDIS_STATUS status = NDIS_STATUS_RESOURCES;    UINT i;    PIO_INTERRUPT_MESSAGE_INFO pTable = pContext->pMSIXInfoTable;    if (pTable && pTable->MessageCount)    {        status = NDIS_STATUS_SUCCESS;        DPrintf(0, ("[%s] Using MSIX interrupts (%d messages, irql %d)/n",            __FUNCTION__, pTable->MessageCount, pTable->UnifiedIrql));        for (i = 0; i < pContext->pMSIXInfoTable->MessageCount; ++i)        {            DPrintf(0, ("[%s] MSIX message%d=%08X=>%I64X/n",                __FUNCTION__, i,                pTable->MessageInfo[i].MessageData,                pTable->MessageInfo[i].MessageAddress));        }        for (UINT j = 0; j < pContext->nPathBundles && status == NDIS_STATUS_SUCCESS; ++j)        {            status = pContext->pPathBundles[j].rxPath.SetupMessageIndex(2 * u16(j) + 1);            status = pContext->pPathBundles[j].txPath.SetupMessageIndex(2 * u16(j));            DPrintf(0, ("[%s] Using messages %u/%u for RX/TX queue %u/n", __FUNCTION__,                        pContext->pPathBundles[j].rxPath.getMessageIndex(),                        pContext->pPathBundles[j].txPath.getMessageIndex(),                        j));        }        if (status == NDIS_STATUS_SUCCESS && pContext->bCXPathCreated)        {            /* We need own vector for control queue. If one is not available, fail the initialization */            if (pContext->nPathBundles * 2 > pTable->MessageCount - 1)            {                DPrintf(0, ("[%s] Not enough vectors for control queue!/n", __FUNCTION__));                status = NDIS_STATUS_RESOURCES;            }            else            {                status = pContext->CXPath.SetupMessageIndex(2 * u16(pContext->nPathBundles));                DPrintf(0, ("[%s] Using message %u for controls/n", __FUNCTION__, pContext->CXPath.getMessageIndex()));            }        }    }    DEBUG_EXIT_STATUS(0, status);    return status;}

void CM_ProcessRecData (DATA_StructType *msg){	static uint8_t size;	switch (msg->count-1){		case QIZHI1:			if(msg->byte[QIZHI1] != COM_QIZHI1){				CM_ClearCount (msg);				DPrintf ("error1/r/n");			}			break;		case QIZHI2:			if(msg->byte[QIZHI2] != COM_QIZHI2){				CM_ClearCount (msg);				DPrintf ("error2/r/n");			}			break;		case MAINPCB:			if(msg->byte[MAINPCB] != COM_MAINPCB){				CM_ClearCount (msg);				DPrintf ("error3/r/n");			}			break;		case SLPCB:			if(msg->byte[SLPCB] != COM_SLPCB){				CM_ClearCount (msg);				DPrintf ("error4/r/n");			}			break;		case SIZE:			size = msg->byte[SIZE];			break;		case CMD:			if(size != 0){				size --;			}			break;		default:			if(size != 0){				size --;			}else{				CM_SetSuccess(msg);			}			break;	}}

/**********************************************************NDIS required procedure of OID SETJust passes all the supported oids to common set procedureReturn value:	NDIS_STATUS					as returned from set procedure	NDIS_STATUS_NOT_SUPPORTED	if support not defined in the table***********************************************************/NDIS_STATUS ParaNdis5_SetOID(IN NDIS_HANDLE MiniportAdapterContext,								  IN NDIS_OID Oid,								  IN PVOID InformationBuffer,								  IN ULONG InformationBufferLength,								  OUT PULONG BytesRead,								  OUT PULONG BytesNeeded){	NDIS_STATUS  status = NDIS_STATUS_NOT_SUPPORTED;	tOidWhatToDo Rules;	PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)MiniportAdapterContext;	tOidDesc _oid;	ParaNdis_GetOidSupportRules(Oid, &Rules, OidsDB);	_oid.ulToDoFlags = Rules.Flags;	*BytesRead = 0;	*BytesNeeded = 0;	ParaNdis_DebugHistory(pContext, hopOidRequest, NULL, Oid, 1, 1);	DPrintf(Rules.nEntryLevel, ("[%s], id 0x%X(%s) of %d", __FUNCTION__,				Oid,				Rules.name,				InformationBufferLength));	_oid.Oid = Oid;	_oid.InformationBuffer = InformationBuffer;	_oid.InformationBufferLength = InformationBufferLength;	_oid.pBytesNeeded = BytesNeeded;	_oid.pBytesRead   = BytesRead;	_oid.pBytesWritten = BytesRead;	if (pContext->bSurprizeRemoved) status = NDIS_STATUS_NOT_ACCEPTED;	else if (Rules.Flags & ohfSet)	{		if (Rules.OidSetProc) status = Rules.OidSetProc(pContext, &_oid);		else		{			DPrintf(0, ("[%s] ERROR in OID redirection table", __FUNCTION__));			status = NDIS_STATUS_INVALID_OID;		}	}	ParaNdis_DebugHistory(pContext, hopOidRequest, NULL, Oid, status, 0);	if  (status != NDIS_STATUS_PENDING)	{		DPrintf((status != NDIS_STATUS_SUCCESS) ? Rules.nExitFailLevel : Rules.nExitOKLevel,			("[%s] , id 0x%X(%s) (%X), read %d, needed %d", __FUNCTION__,			Rules.oid, Rules.name, status, *BytesRead, *BytesNeeded));	}	return status;}

static void *vring_get_buf(struct virtqueue *_vq, unsigned int *len){	struct vring_virtqueue *vq = to_vvq(_vq);	void *ret;    struct vring_used_elem *u;	unsigned int i;	if (!more_used(vq)) {		DPrintf(4, ("No more buffers in queue: last_used_idx %d vring.used->idx %d/n",			vq->last_used_idx,			vq->vring.used->idx));		return NULL;	}	/* Only get used array entries after they have been exposed by host. */	rmb();	u = &vq->vring.used->ring[vq->last_used_idx % vq->vring.num];	i = u->id;	*len = u->len;	DPrintf(4, ("%s>>> id %d, len %d/n", __FUNCTION__, i, *len) );	if (i >= vq->vring.num) {		DPrintf(0, ("id %u out of range/n", i) );		return NULL;	}	if (!vq->data[i]) {		DPrintf(0, ("id %u is not a head!/n", i) );		return NULL;	}	/* detach_buf clears data, so grab it now. */	ret = vq->data[i];	detach_buf(vq, i);	++vq->last_used_idx;	if (!(vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT)) {		*vq->vring.vring_last_used_ptr = vq->last_used_idx;		mb();	}	return ret;}

VOID ParaNdis_Resume(PARANDIS_ADAPTER *pContext){    DPrintf(0, ("[%s] %s/n", __FUNCTION__, pContext->bFastSuspendInProcess ? " Resuming TX and RX" : "(nothing to do)"));    if (pContext->bFastSuspendInProcess)    {        ParaNdis6_SendPauseRestart(pContext, FALSE, NULL);        ParaNdis6_ReceivePauseRestart(pContext, FALSE, NULL);    }}

int FPlayList::Advance (){	if (++Position >= Songs.Size())	{		Position = 0;	}	DPrintf (DMSG_NOTIFY, "Playlist advanced to song %d/n", Position);	return Position;}

/*解除链路验证*/int sta_deauth(u8 *addr, int reason_code, apdata_info *pap){	struct ieee80211req_mlme mlme;	DPrintf("[WAPID]:: deauth STA("MACSTR")/n", MAC2STR(addr));	mlme.im_op = IEEE80211_MLME_DEAUTH;	mlme.im_reason = reason_code;	memcpy(mlme.im_macaddr, addr, WLAN_ADDR_LEN);	return set80211priv(pap, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme));}

SystemWrapper::library_t *SystemWrapper::GetLibrary(char *name){	char fixedname[MAX_PATH];	Q_strlcpy(fixedname, name);	COM_FixSlashes(fixedname);	library_t *lib = (library_t *)m_Libraries.GetFirst();	while (lib)	{		if (Q_stricmp(lib->name, name) == 0) {			return lib;		}		lib = (library_t *)m_Libraries.GetNext();	}	lib = (library_t *)Mem_Malloc(sizeof(library_t));	if (!lib) {		DPrintf("ERROR! System::GetLibrary: out of memory (%s)./n", name);		return nullptr;	}	Q_snprintf(lib->name, sizeof(lib->name), "%s." LIBRARY_PREFIX, fixedname);	FS_GetLocalCopy(lib->name);	lib->handle = (CSysModule *)Sys_LoadModule(lib->name);	if (!lib->handle) {		DPrintf("ERROR! System::GetLibrary: coulnd't load library (%s)./n", lib->name);		Mem_Free(lib);		return nullptr;	}	lib->createInterfaceFn = (CreateInterfaceFn)Sys_GetFactory(lib->handle);	if (!lib->createInterfaceFn) {		DPrintf("ERROR! System::GetLibrary: coulnd't get object factory(%s)./n", lib->name);		Mem_Free(lib);		return nullptr;	}	m_Libraries.Add(lib);	DPrintf("Loaded library %s./n", lib->name);	return lib;}

void ParaNdis_DebugInitialize(PVOID DriverObject,PVOID RegistryPath){	NDIS_STRING usRegister, usDeregister, usPrint;	PVOID pr, pd;	BOOLEAN res;	WPP_INIT_TRACING(DriverObject, RegistryPath);	NdisAllocateSpinLock(&CrashLock);	KeInitializeCallbackRecord(&CallbackRecord);	ParaNdis_PrepareBugCheckData();	NdisInitUnicodeString(&usPrint, L"vDbgPrintEx");	NdisInitUnicodeString(&usRegister, L"KeRegisterBugCheckReasonCallback");	NdisInitUnicodeString(&usDeregister, L"KeDeregisterBugCheckReasonCallback");	pd = MmGetSystemRoutineAddress(&usPrint);	if (pd) PrintProcedure = (vDbgPrintExType)pd;	pr = MmGetSystemRoutineAddress(&usRegister);	pd = MmGetSystemRoutineAddress(&usDeregister);	if (pr && pd)	{		BugCheckRegisterCallback = (KeRegisterBugCheckReasonCallbackType)pr;		BugCheckDeregisterCallback = (KeDeregisterBugCheckReasonCallbackType)pd;	}	res = BugCheckRegisterCallback(&CallbackRecord, ParaNdis_OnBugCheck, KbCallbackSecondaryDumpData, "NetKvm");	DPrintf(0, ("[%s] Crash callback %sregistered", __FUNCTION__, res ? "" : "NOT "));#ifdef OVERRIDE_DEBUG_BREAK	if (sizeof(PVOID) == sizeof(ULONG))	{		UCHAR replace[5] = {0xe9,0,0,0,0};		ULONG replacement;		NDIS_STRING usDbgBreakPointName;		NdisInitUnicodeString(&usDbgBreakPointName, L"DbgBreakPoint");		pDbgBreakPoint = (PUCHAR)MmGetSystemRoutineAddress(&usDbgBreakPointName);		if (pDbgBreakPoint)		{			DPrintf(0, ("Replacing original BP handler at %p", pDbgBreakPoint));			replacement = RtlPointerToOffset(pDbgBreakPoint + 5, AnotherDbgBreak);			RtlCopyMemory(replace + 1, &replacement, sizeof(replacement));			RtlCopyMemory(DbgBreakPointChunk, pDbgBreakPoint, sizeof(DbgBreakPointChunk));			RtlCopyMemory(pDbgBreakPoint, replace, sizeof(replace));		}	}#endif}

voidGetXferSegment (const ADAPTER_PTR HA, IO_REQ_PTR Req, SegmentDescr *SGDescr,    U32 Offset, BOOLEAN DemandPhysicalAddr){  TRACE(4, ("GetXferSegment(): Offset = %d/n", Offset));  TRACE(4, ("GetXferSegment(): Non-S/G request, ReqDataCount = %d/n", ReqDataCount(Req)));  if (Offset < ReqDataCount(Req)) {              // Make sure we don't over run    SGDescr->SegmentLength = ReqDataCount(Req) - Offset;    SGDescr->SegmentPtr = (U32)ReqDataPtr(Req) + Offset;  } else {    SGDescr->SegmentLength = 0;               // No data left    SGDescr->SegmentPtr = 0;    BreakPoint(HA);  }  TRACE(4, ("GetXferSegment(): %d bytes remain in segment at %08x (offset %d)/n",      SGDescr->SegmentLength, SGDescr->SegmentPtr, Offset));  SGDescr->Flags.IsPhysical = FALSE;  if (DemandPhysicalAddr) {    if (ReqState(Req).InternalRequest) {      TRACE(5, ("GetXferSegment(): Mapping internal request/n"));      MapToPhysical(HA, SGDescr);    } else {      ULONG Size = SGDescr->SegmentLength;      SGDescr->SegmentPtr = (U32)ScsiPortConvertPhysicalAddressToUlong(	  ScsiPortGetPhysicalAddress(HA, Req,	  (PVOID)((U32)ReqDataPtr(Req) + Offset) /*(SGDescr->SegmentPtr)*/,	  &Size));      if (Size < SGDescr->SegmentLength)	SGDescr->SegmentLength = Size;      DEBUG(5, {	if (SGDescr->SegmentLength < (ReqDataCount(Req) - Offset))	  DPrintf("Segment length is %d out of %d/n",	      SGDescr->SegmentLength, ReqDataCount(Req) - Offset);});	      SGDescr->Flags.IsPhysical = TRUE;      TRACE(5, ("GetXferSegment(): Mapped to 0x%lx for %lu bytes/n",	  SGDescr->SegmentPtr, Size));    }  }

/*保存证书状态*/int save_cert_status(char *fileconfig, char *cert_flag){	int res = 0;	res = !save_global_conf(SEP_EQUAL,fileconfig,"",  "CERT_STATUS",cert_flag);	if(res != 0)	{		DPrintf("open file %s error/n", fileconfig);	}	return res;}

/**********************************************************NDIS required procedure of OID QUERYJust passes all the supported oids to common query procedureReturn value:	NDIS_STATUS					as returned from common code	NDIS_STATUS_NOT_SUPPORTED	if suppressed in the table***********************************************************/NDIS_STATUS ParaNdis5_QueryOID(IN NDIS_HANDLE MiniportAdapterContext,									IN NDIS_OID Oid,									IN PVOID InformationBuffer,									IN ULONG InformationBufferLength,									OUT PULONG BytesWritten,									OUT PULONG BytesNeeded){	NDIS_STATUS  status = NDIS_STATUS_NOT_SUPPORTED;	int debugLevel;	tOidWhatToDo Rules;	PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)MiniportAdapterContext;	tOidDesc _oid;	ParaNdis_GetOidSupportRules(Oid, &Rules, OidsDB);	_oid.ulToDoFlags = Rules.Flags;	*BytesWritten = 0;	*BytesNeeded  = 0;	ParaNdis_DebugHistory(pContext, hopOidRequest, NULL, Oid, 0, 1);	DPrintf(Rules.nEntryLevel, ("[%s], id 0x%X(%s) of %d", __FUNCTION__,				Oid,				Rules.name,				InformationBufferLength));	_oid.Oid = Oid;	_oid.InformationBuffer = InformationBuffer;	_oid.InformationBufferLength = InformationBufferLength;	_oid.pBytesNeeded = BytesNeeded;	_oid.pBytesRead   = BytesWritten;	_oid.pBytesWritten = BytesWritten;	if (pContext->bSurprizeRemoved) status = NDIS_STATUS_NOT_ACCEPTED;	else if (Rules.Flags & ohfQuery) status = ParaNdis_OidQuery(pContext, &_oid);	ParaNdis_DebugHistory(pContext, hopOidRequest, NULL, Oid, status, 0);	DPrintf((status != NDIS_STATUS_SUCCESS) ? Rules.nExitFailLevel : Rules.nExitOKLevel,		("[%s] , id 0x%X(%s) (%X), written %d, needed %d",		__FUNCTION__,		Rules.oid,		Rules.name,		status,		*BytesWritten,		*BytesNeeded));	return status;}

static VOID MiniportEnableMSIInterrupt(    IN PVOID  MiniportInterruptContext,    IN ULONG  MessageId    ){    PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)MiniportInterruptContext;    ULONG interruptSource = MessageToInterruptSource(pContext, MessageId);    DPrintf(0, ("[%s] (Message %d)/n", __FUNCTION__, MessageId));    ParaNdis_VirtIOEnableIrqSynchronized(pContext, interruptSource);}

static BOOL APIENTRY SetVSync( int vsync ){#if defined (__APPLE__)	DPrintf(TEXTCOLOR_CYAN "Vertical synchronization is turned %s/n", vsync > 0 ? "on" : "off");	return kCGLNoError == CGLSetParameter( CGLGetCurrentContext(), kCGLCPSwapInterval, &vsync );#else // !__APPLE__	// empty placeholder	return false;#endif // __APPLE__}

VOID ParaNdis_OnBugCheck(    IN KBUGCHECK_CALLBACK_REASON Reason,    IN PKBUGCHECK_REASON_CALLBACK_RECORD Record,    IN OUT PVOID ReasonSpecificData,    IN ULONG ReasonSpecificDataLength    ){    KBUGCHECK_SECONDARY_DUMP_DATA *pDump = (KBUGCHECK_SECONDARY_DUMP_DATA *)ReasonSpecificData;    UNREFERENCED_PARAMETER(Record);    if (KbCallbackSecondaryDumpData == Reason && ReasonSpecificDataLength >= sizeof(*pDump))    {        ULONG dumpSize = sizeof(BugCheckData.Location);        if (!pDump->OutBuffer)        {            UINT nSaved;            nSaved = FillDataOnBugCheck();            if (pDump->InBufferLength >= dumpSize)            {                pDump->OutBuffer = pDump->InBuffer;                pDump->OutBufferLength = dumpSize;            }            else            {                pDump->OutBuffer = &BugCheckData.Location;                pDump->OutBufferLength = dumpSize;                bNative = FALSE;            }            DPrintf(0, ("[%s] system buffer of %d, saving data for %d NIC/n", __FUNCTION__,pDump->InBufferLength, nSaved));            DPrintf(0, ("[%s] using %s buffer/n", __FUNCTION__, bNative ? "native" : "own"));        }        else if (pDump->OutBuffer == pDump->InBuffer)        {            RtlCopyMemory(&pDump->Guid, &ParaNdis_CrashGuid, sizeof(pDump->Guid));            RtlCopyMemory(pDump->InBuffer, &BugCheckData.Location, dumpSize);            pDump->OutBufferLength = dumpSize;            DPrintf(0, ("[%s] written %d to %p/n", __FUNCTION__, (ULONG)BugCheckData.Location.Size, (UINT_PTR)BugCheckData.Location.Address ));            DPrintf(0, ("[%s] dump data (%d) at %p/n", __FUNCTION__, pDump->OutBufferLength, pDump->OutBuffer));        }    }}

static NDIS_STATUS ParaNdis6x_DirectOidRequest(IN  NDIS_HANDLE miniportAdapterContext,  IN  PNDIS_OID_REQUEST OidRequest){    NDIS_STATUS  status = NDIS_STATUS_NOT_SUPPORTED;    PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)miniportAdapterContext;    if (pContext->bSurprizeRemoved) status = NDIS_STATUS_NOT_ACCEPTED;    DPrintf(1, ("[%s] came %s/n", __FUNCTION__, ParaNdis_OidName(OidRequest->DATA.SET_INFORMATION.Oid)));    return status;}

static void WaitHaltEvent(PARANDIS_ADAPTER *pContext, const char *Reason){	UINT ms = 5000;	if (!NdisWaitEvent(&pContext->HaltEvent, 1))	{		while (!NdisWaitEvent(&pContext->HaltEvent, ms))		{			DPrintf(0, ("[%s]", __FUNCTION__));		}	}}

void I_LoadSound (struct sfxinfo_struct *sfx){	if (!sound_initialized)		return;		if (!sfx->data)	{		DPrintf ("loading sound /"%s/" (%d)/n", sfx->name, sfx->lumpnum);		getsfx (sfx);	}}