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

// Constructor. Initializes to a handle.ClsDC::ClsDC( HDC hDC ){	_ASSERT_VALID( hDC ); // Must be valid.	// Clear handle.	m_hDC = NULL;	// Attach the handle.	Attach( hDC );	// Add us to the global list.	global_dc_list.AddHead( this );}

CSysImageList::CSysImageList(){	SHFILEINFO ssfi;	TCHAR windir[MAX_PATH];	GetWindowsDirectory(windir, _countof(windir));  // MAX_PATH ok.	HIMAGELIST hSystemImageList =		(HIMAGELIST)SHGetFileInfo(			windir,			0,			&ssfi, sizeof ssfi,			SHGFI_SYSICONINDEX | SHGFI_SMALLICON);	Attach(hSystemImageList);}

void Transmogrify::Spawn(float duration, int targetUUID){	mDuration = duration;	for (Explorer& e : Factory<Explorer>())	{		// Only affects clients who are not the target		if (e.mNetworkID->mUUID == targetUUID && !e.mNetworkID->mHasAuthority)		{			Attach(&e);		}	}}

SOCKET Socket::CreateSocket(int af,int type, const std::string& protocol){	struct protoent *p = NULL;	SOCKET s;#ifdef ENABLE_POOL	m_socket_type = type;	m_socket_protocol = protocol;#endif	if (protocol.size())	{		p = getprotobyname( protocol.c_str() );		if (!p)		{			Handler().LogError(this, "getprotobyname", Errno, StrError(Errno), LOG_LEVEL_FATAL);			SetCloseAndDelete();#ifdef ENABLE_EXCEPTIONS			throw Exception(std::string("getprotobyname() failed: ") + StrError(Errno));#endif			return INVALID_SOCKET;		}	}	int protno = p ? p -> p_proto : 0;	s = socket(af, type, protno);	if (s == INVALID_SOCKET)	{		Handler().LogError(this, "socket", Errno, StrError(Errno), LOG_LEVEL_FATAL);		SetCloseAndDelete();#ifdef ENABLE_EXCEPTIONS		throw Exception(std::string("socket() failed: ") + StrError(Errno));#endif		return INVALID_SOCKET;	}	Attach(s);	OnOptions(af, type, protno, s);	Attach(INVALID_SOCKET);	return s;}

HRESULT Kernel::GetWaitChainInfo(WaitSnapshot& snapshot){	_pCurrentSnapshot = &snapshot;	HRESULT hr = Attach();	if(SUCCEEDED(hr))	{		snapshot.Initialize(_KProcess, _OSProcessId);		hr = ProcessHandles();		hr = ProcessThreadWaitList();	}	_pCurrentSnapshot = NULL;	return hr;}

void LKWindowSurface::Create(Window& Wnd){#ifdef WIN32    HWND hWnd = Wnd.Handle();    LKASSERT(hWnd);    LKASSERT(::IsWindow(hWnd));    if(!Attach(::GetDC(hWnd))) {        LKASSERT(false);    }#else    _pCanvas = new WindowCanvas(Wnd);#endif}

// open the filebool wxFile::Open(const wxChar *szFileName, OpenMode mode, int accessMode){    int flags = O_BINARY;    switch ( mode )    {        case read:            flags |= O_RDONLY;            break;        case write_append:            if ( wxFile::Exists(szFileName) )            {                flags |= O_WRONLY | O_APPEND;                break;            }            //else: fall through as write_append is the same as write if the            //      file doesn't exist        case write:            flags |= O_WRONLY | O_CREAT | O_TRUNC;            break;        case write_excl:            flags |= O_WRONLY | O_CREAT | O_EXCL;            break;        case read_write:            flags |= O_RDWR;            break;    }#ifdef __WINDOWS__    // only read/write bits for "all" are supported by this function under    // Windows, and VC++ 8 returns EINVAL if any other bits are used in    // accessMode, so clear them as they have at best no effect anyhow    accessMode &= wxS_IRUSR | wxS_IWUSR;#endif // __WINDOWS__    int fd = wxOpen( szFileName, flags ACCESS(accessMode));    if ( fd == -1 )    {        wxLogSysError(_("can't open file '%s'"), szFileName);        return false;    }    else {        Attach(fd);        return true;    }}

    Handle& Handle::operator=(Handle& h)    {        if (mHandle_ != h)        {            if (NULL != mHandle_)            {                Close();            }            Attach(h.Detach());        }        return *this;    }

///////////////////////////////////////////////////////////////////////////////// AttachFromVariant: Attach a Variant SafeArraybool CSafeArrayHelper::AttachFromVariant(VARIANT* pVariant){	if (NULL != pVariant)	{		if (pVariant->vt & VT_ARRAY)		{			LPSAFEARRAY psa = pVariant->parray;			if (pVariant->vt & VT_BYREF)	// VB use this...				psa = *pVariant->pparray;			return Attach( psa );		}	}	return false;}

DemoEntity::DemoEntity(DemoEntityManager& world, const dScene* scene, dScene::dTreeNode* rootSceneNode, dTree<DemoMesh*, dScene::dTreeNode*>& 	 	meshCache, DemoEntityManager::EntityDictionary& entityDictionary, DemoEntity* parent)	:dClassInfo()	,dHierarchy<DemoEntity>() 	,m_matrix(GetIdentityMatrix()) 	,m_curPosition (0.0f, 0.0f, 0.0f, 1.0f)	,m_nextPosition (0.0f, 0.0f, 0.0f, 1.0f)	,m_curRotation (1.0f, 0.0f, 0.0f, 0.0f)	,m_nextRotation (1.0f, 0.0f, 0.0f, 0.0f)	,m_lock (0)	,m_mesh (NULL){	// add this entity to the dictionary	entityDictionary.Insert(this, rootSceneNode);	// if this is a child mesh set it as child of th entity	dMatrix parentMatrix (GetIdentityMatrix());	if (parent) {		Attach (parent);		dScene::dTreeNode* parentNode = scene->FindParentByType(rootSceneNode, dSceneNodeInfo::GetRttiType());		dSceneNodeInfo* parentInfo = (dSceneNodeInfo*) parentNode;		parentMatrix = parentInfo->GetTransform();	}	dSceneNodeInfo* info = (dSceneNodeInfo*) scene->GetInfoFromNode (rootSceneNode);//	SetMatrix(info->GetTransform() * parentMatrix.Inverse4x4());	dMatrix matrix (info->GetTransform() * parentMatrix.Inverse4x4());	dQuaternion rot (matrix);	// set the matrix twice in oder to get cur and next position	SetMatrix(world, rot, matrix.m_posit);	SetMatrix(world, rot, matrix.m_posit);	// if this node has a mesh, find it and attach it to this entity	dScene::dTreeNode* meshNode = scene->FindChildByType(rootSceneNode, dMeshNodeInfo::GetRttiType());	if (meshNode) {		DemoMesh* mesh = meshCache.Find(meshNode)->GetInfo();		SetMesh(mesh);	}	// add all of the children nodes as child nodes	for (void* child = scene->GetFirstChild(rootSceneNode); child; child = scene->GetNextChild (rootSceneNode, child)) {		dScene::dTreeNode* node = scene->GetNodeFromLink(child);		dNodeInfo* info = scene->GetInfoFromNode(node);		if (info->GetTypeId() == dSceneNodeInfo::GetRttiType()) {			new DemoEntity (world, scene, node, meshCache, entityDictionary, this);		}	}}

    __checkReturn HRESULT Create(__in DWORD threadCount)    {        Attach(::CreateIoCompletionPort(INVALID_HANDLE_VALUE,                                        0, // no existing port                                        0, // ignored                                        threadCount));        if (0 == m_h)        {            return HRESULT_FROM_WIN32(::GetLastError());        }        return S_OK;    }

bool CMutex::Create() {#if ( configUSE_MUTEXES == 1 )	SemaphoreHandle_t handle;	handle = xSemaphoreCreateMutex();	if (handle != NULL)		Attach(handle);#endif	return IsValid();}

    ///////////////////////////////////////////////////////////////////////    ///  Function: AttachBlackOfScreen    ///    ///    Author: $author$    ///      Date: 2/8/2013    ///////////////////////////////////////////////////////////////////////    virtual XosError AttachBlackOfScreen(Screen* xScreen, bool onlyFreed=false)     {        XosError error = XOS_ERROR_FAILED;        XosError error2;        if ((error2 = Freed(onlyFreed)))            return error2;        if ((xScreen)) {            Attach(XBlackPixelOfScreen(xScreen));            error = XOS_ERROR_NONE;        }        return error;    }

int ProfilerHandler::Load() {  amx_path_ = fileutils::ToUnixPath(amx_path_finder_->Find(amx()));  amx_name_ = fileutils::GetDirectory(amx_path_)            + "/"            + fileutils::GetBaseName(amx_path_);  if (amx_path_.empty()) {    Printf("Could not find AMX file (try setting AMX_PATH?)");  }  if (ShouldBeProfiled(amx_path_)) {    Attach();  }  return AMX_ERR_NONE;}

    HRESULT Initialize(PCWSTR serverName,                       INTERNET_PORT portNumber,                       const WinHttpSession& session)    {        if (!Attach(::WinHttpConnect(session.m_handle,                                     serverName,                                     portNumber,                                     0))) // reserved        {            return HRESULT_FROM_WIN32(::GetLastError());        }        return S_OK;    }

SelectionKeyImpl::SelectionKeyImpl(    /* [in] */ IAbstractSelectableChannel* channel,    /* [in] */ Int32 ops,    /* [in] */ IObject* attachment,    /* [in] */ IAbstractSelector* selector){    REFCOUNT_ADD(channel);    this->mChannel = channel;    this->mInterestOps = ops;    REFCOUNT_ADD(selector);    this->mSelector = selector;    AutoPtr<IObject> tempObj;    Attach(attachment, (IObject**)&tempObj);}

void UdpSocket::SendToBuf(SocketAddress& ad, const char *data, int len, int flags){	if (GetSocket() == INVALID_SOCKET)	{		Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));	}	if (GetSocket() != INVALID_SOCKET)	{		SetNonblocking(true);		if ((m_last_size_written = sendto(GetSocket(), data, len, flags, ad, ad)) == -1)		{			Handler().LogError(this, "sendto", Errno, StrError(Errno), LOG_LEVEL_ERROR);		}	}}

		BOOL CULDateTimePicker::Create(HWND hParentWnd,WORD wID,int x,int y,int cx,int cy,DWORD dwStyle)		{			m_hWnd = CreateWindowEx(0,				DATETIMEPICK_CLASS,				NULL,				dwStyle,				x,y,cx,cy,				hParentWnd,				(HMENU)wID,				ULOther::ULGetResourceHandle(),				this);			if(!m_hWnd)				return FALSE;			return Attach(m_hWnd);		}

BOOL CVisualBoyHandler::RefreshAddressList(VOID){	BOOL	bResult = IsValid();	if(!bResult)	{		bResult = Attach();	}	else	{		bResult = SearchForPtrStruct();	}	return bResult;}

CBlockEvaluator::CBlockEvaluator(FlwNode * pNd,                                 DWORD Options,                                 CReactionBase * pRB,                                 CHXBase *pHX,                                 CEnvironHXBase * pEHX,                                 CVLEBase * pVLE,                                 CEvapBase * pEvap) :  CBlockEvalStateSemantics(false)  {  m_pNd             = pNd;  m_Options         = Options;  //m_bAllowStateSemantics = false;    Attach((Options & BEO_StateSemantics)!=0, pRB, pHX, pEHX, pVLE, pEvap);  };

//*******************************************************************************BOOL CMPCPngImage::LoadFromFile(LPCTSTR lpszPath){    BOOL bRes = FALSE;    if (m_pImage == nullptr) {        m_pImage = DEBUG_NEW CImage;        ENSURE(m_pImage != nullptr);    }    if (m_pImage->Load(lpszPath) == S_OK) {        bRes = Attach(m_pImage->Detach());    }    return bRes;}

void COleDataObject::EnsureClipboardObject(){	ASSERT(AfxIsValidAddress(this, sizeof(COleDataObject)));	if (m_bClipboard && m_lpDataObject == NULL)	{		// get clipboard using OLE API		LPDATAOBJECT lpDataObject;		SCODE sc = ::OleGetClipboard(&lpDataObject);		// attach COleDataObject wrapper to IDataObject from clipboard		if (sc == S_OK)			Attach(lpDataObject, TRUE);	}}

cDevice *cServerConnection::GetDevice(const cChannel *Channel, int Priority) {	// turn off the streams of this connection	Detach();	// This call may detach receivers of the device it returns	cDevice *device = cDevice::GetDevice(Channel, Priority, false); 	if (device && !device->IsTunedToTransponder(Channel)			&& UsedByLiveTV(device)) {		// now we would have to switch away live tv...let's see if live tv		// can be handled by another device#if VDRVERSNUM >= 10516		cDevice::SetAvoidDevice(device);		if (!Channels.SwitchTo(cDevice::CurrentChannel())) {			if (StreamdevServerSetup.SuspendMode == smAlways) {				Channels.SwitchTo(Channel->Number());				Skins.QueueMessage(mtInfo, tr("Streaming active"));			}			else {				dsyslog("streamdev: GetDevice: Live TV not suspended");				device = NULL;			}		}#else		const cChannel *current = Channels.GetByNumber(cDevice::CurrentChannel());		cDevice *newdev = current ? CheckDevice(current, 0, true, device) : NULL;		if (newdev) {			dsyslog("streamdev: GetDevice: Trying to move live TV to device %d", newdev->CardIndex());			newdev->SwitchChannel(current, true);		}		else if (StreamdevServerSetup.SuspendMode == smAlways) {			Channels.SwitchTo(Channel->Number());			Skins.QueueMessage(mtInfo, tr("Streaming active"));		}		else {			dsyslog("streamdev: GetDevice: Live TV not suspended");			device = NULL;		}#endif	}	if (!device) {		// can't switch - continue the current stream		Attach();		dsyslog("streamdev: GetDevice failed for channel %d (%s) at priority %d (PrimaryDevice=%d, ActualDevice=%d)", Channel->Number(), Channel->Name(), Priority, cDevice::PrimaryDevice()->CardIndex(), cDevice::ActualDevice()->CardIndex());	}	return device;}

void VoxelTerrain::OnUpdate(){	//Make some chunks	if (m_vChunks.size() == 0) {		Wish_Asset_LoadTexture("wald", "./data/textures/wald.png");		for (size_t x = 0; x < 8; x++) {			for (size_t y = 0; y < 8; y++) {				VoxelChunk* pChunk = new VoxelChunk(x, y);				m_vChunks.push_back(0);				Attach(pChunk);				printf("Attached transform.");				pChunk->Build();			}		}	}}

void TaskManager::UpdateProcesses(Uint32 deltaMs){    TaskPtr next;    for (auto current : task_list) {        if (current->IsDead()) {            next = current->GetNext();            if (next) {                current->SetNext(TaskPtr(nullptr));                Attach(next);            }            Detach(current);        } else if (current->IsActive() && !current->IsPaused()) {            current->OnUpdate(deltaMs);        }    }}

 void TerminalDisplay::DisplayInfo(const std::vector<std::string>& Options) {   char infoColIdx = 0;   if (GetContext()->GetColorizer()) {      infoColIdx = GetContext()->GetColorizer()->GetInfoColor();   }   WriteRawString("/n", 1);   for (size_t i = 0, n = Options.size(); i < n; ++i) {     Text t(Options[i], infoColIdx);     WriteWrappedElement(t, 0, 0, (size_t) -1);     WriteRawString("/n", 1);   }   // Reset position   Detach();   Attach(); }

FX_BOOL CFX_QuartzDevice::Create(FX_INT32 width, FX_INT32 height, FXDIB_Format format){    if ((FX_BYTE)format < 32) {        return FALSE;    }    CFX_DIBitmap* pBitmap = FX_NEW CFX_DIBitmap;    if (!pBitmap) {        return FALSE;    }    if (!pBitmap->Create(width, height, format)) {        delete pBitmap;        return FALSE;    }    m_bOwnedBitmap = TRUE;    return Attach(pBitmap);}

// Constructor.SpaceVisualizer::SpaceVisualizer(beScene::ResourceManager &resources, beScene::EffectDrivenRenderer &renderer)	: m_world( new_resource bees::World("WidgetWorld") ),	m_simulation( new_resource bees::Simulation("WidgetSimulation") ){	m_data[WidgetType::Arrow] = createWidgetData("Static/UI/TranslateWidget.mesh", "Materials/Widget.fx", "", resources, renderer);	m_data[WidgetType::Circle] = createWidgetData("Static/UI/RotateWidget.mesh", "Materials/Widget.fx", "DARKEN_SPHERE_BACK", resources, renderer);	m_data[WidgetType::Plug] = createWidgetData("Static/UI/ScaleWidget.mesh", "Materials/Widget.fx", "", resources, renderer);	m_scene = new besc::RenderingController(renderer.Pipeline, nullptr);	m_world->Controllers().AddControllerKeep(m_scene);	m_meshes = besc::CreateMeshControllers(&m_world->PersistentIDs()).detach();	m_world->Controllers().AddControllerKeep(m_meshes);	Attach(m_world, m_simulation);}

void CInventoryItem::OnEvent (NET_Packet& P, u16 type){	switch (type)	{	case GE_ADDON_ATTACH:		{			u32 ItemID;			P.r_u32			(ItemID);			CInventoryItem*	 ItemToAttach	= smart_cast<CInventoryItem*>(Level().Objects.net_Find(ItemID));			if (!ItemToAttach) break;			Attach(ItemToAttach,true);			CActor* pActor = smart_cast<CActor*>(object().H_Parent());			if (pActor && pActor->inventory().ActiveItem() == this)			{				pActor->inventory().SetPrevActiveSlot(pActor->inventory().GetActiveSlot());				pActor->inventory().Activate(NO_ACTIVE_SLOT);							}		}break;	case GE_ADDON_DETACH:		{			string64			i_name;			P.r_stringZ			(i_name);			Detach(i_name, true);			CActor* pActor = smart_cast<CActor*>(object().H_Parent());			if (pActor && pActor->inventory().ActiveItem() == this)			{				pActor->inventory().SetPrevActiveSlot(pActor->inventory().GetActiveSlot());				pActor->inventory().Activate(NO_ACTIVE_SLOT);			};		}break;		case GE_CHANGE_POS:		{			Fvector p; 			P.r_vec3(p);			CPHSynchronize* pSyncObj = NULL;			pSyncObj = object().PHGetSyncItem(0);			if (!pSyncObj) return;			SPHNetState state;			pSyncObj->get_State(state);			state.position = p;			state.previous_position = p;			pSyncObj->set_State(state);		}break;	}}

int main(int argc, char *argv[]){	HIJACK *hijack;	FUNC *func;	unsigned long addr;	PLT *plts, *plt;		if (argc != 2)		usage(argv[0]);		hijack = InitHijack();    ToggleFlag(hijack, F_DEBUG);    ToggleFlag(hijack, F_DEBUG_VERBOSE);	AssignPid(hijack, atoi(argv[1]));		if (Attach(hijack) != ERROR_NONE)	{		fprintf(stderr, "[-] Couldn't attach!/n");		exit(EXIT_FAILURE);	}	if (LocateAllFunctions(hijack) != ERROR_NONE)	{		fprintf(stderr, "[-] Couldn't locate all functions!/n");		exit(EXIT_FAILURE);	}    if (LocateSystemCall(hijack) != ERROR_NONE) {        fprintf(stderr, "[-] Couldn't locate system call!/n");        exit(EXIT_FAILURE);    }    addr = MapMemory(hijack, NULL, 8192, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_ANON | MAP_SHARED);    if (GetErrorCode(hijack) != ERROR_NONE) {        fprintf(stderr, "[-] %s/n", GetErrorString(hijack));        perror("ptrace");    }		printf("[*] PLT/GOT @ 0x%016lx/n", hijack->pltgot);	printf("[*] Baseaddr @ 0x%016lx/n", hijack->baseaddr);    printf("[*] Syscall @ 0x%016lx/n", hijack->syscalladdr);    printf("[*] addr @ 0x%016lx/n", addr);	Detach(hijack);		return 0;}