C++ (Cpp) OTGetProtAddress Examples

Example #1

File: OTIPEndpoint.cpp Project: MaddTheSane/tntbasic

NMErr
OTIPEndpoint::GetIdentifier(char* outIdStr, NMSInt16 inMaxSize)
{
	char result[256];
    TBind peerAddr;
    
	op_vassert_return((mStreamEndpoint != NULL),"Stream Endpoint is NIL!",  kNMBadStateErr);

    OSStatus err = OTGetProtAddress(mStreamEndpoint->mEP, NULL, &peerAddr);

    if (err != kNMNoError) {
        return err;
    }
    
	InetAddress *addr = (InetAddress *) peerAddr.addr.buf;
	op_vassert_return((addr->fAddressType == AF_INET),"Bad Endpoint Address Type!",  kNMInternalErr);

   unsigned char *addrp = (unsigned char*)&addr->fHost;

	sprintf(result, "%u.%u.%u.%u", addrp[0], addrp[1], addrp[2], addrp[3]);
	
	strncpy(outIdStr, result, inMaxSize - 1);
    outIdStr[inMaxSize - 1] = 0;

	return (kNMNoError);    
}

Example #2

File: mstcplow.c Project: BygoneWorlds/anet

void TCPLow_Create(TCPINSTANCE* pTcp, u_short* port, TCPPEER* peer, int* status)
{
	TBind boundAddr;
	InetAddress boundInetAddr;
	InetInterfaceInfo inetInfo;
	OSStatus err;

	pTcp->isValid = false;
		
	//	Initialize OpenTransport

	err = InitOpenTransport();
	if (err != noErr) {
		*status = comm_STATUS_BAD;
		return;
	}
	
	//	initialize Internet Services

	pTcp->inetService = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
	if (err != noErr) {
		*status = comm_STATUS_BAD;
		return;
	}
	
	//	open an endpoint for sending and recieving data

	err = CreateAndConfigUDP(&pTcp->udpEndpoint);
	if (err != noErr) {
		ShutDownUDP(pTcp->udpEndpoint);
		*status = comm_STATUS_BAD;
		return;
	}
	pTcp->isValid = true;
			
	//	Get information about Internet
	
	err = OTInetGetInterfaceInfo(&inetInfo, kDefaultInetInterface);
	if (err != noErr) {
		//DebugStr("\pCannot Get Information About Default Interface");
		*status = comm_STATUS_BAD;
		ShutDownUDP(pTcp->udpEndpoint);
		return;
	}

	boundAddr.addr.maxlen = sizeof(boundInetAddr);
	boundAddr.addr.buf = (unsigned char*) &boundInetAddr;;
	err = OTGetProtAddress(pTcp->udpEndpoint,&boundAddr,NULL);
	if (err != noErr) {
		*status = comm_STATUS_BAD;
		ShutDownUDP(pTcp->udpEndpoint);
		return;
	}
	
	peer->addr = inetInfo.fAddress;
	peer->port = *port = boundInetAddr.fPort;
	pTcp->myHandle = dcstReplace(pTcp->handles,pTcp->myHandle,peer);
}

Example #3

// Errors:
// EBADF -- bad socket id
PRInt32 _MD_getsockname(PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen)
{
	PRInt32 osfd = fd->secret->md.osfd;
	OSStatus err;
	EndpointRef endpoint = (EndpointRef) osfd;
	TBind bindReq;
	PRThread *me = _PR_MD_CURRENT_THREAD();

	if (endpoint == NULL) {
		err = kEBADFErr;
		goto ErrorExit;
	}
		
	if (addr == NULL) {
		err = kEFAULTErr;
		goto ErrorExit;
	}

#if !defined(_PR_INET6)		
	addr->inet.family = AF_INET;
#endif
	
	PR_ASSERT(PR_NETADDR_SIZE(addr) >= (*addrlen));

	bindReq.addr.len = *addrlen;
	bindReq.addr.maxlen = *addrlen;
	bindReq.addr.buf = (UInt8*) addr;
	bindReq.qlen = 0;
	
	PrepareThreadForAsyncIO(me, endpoint, osfd);    

	err = OTGetProtAddress(endpoint, &bindReq, NULL);
	if (err != kOTNoError)
		goto ErrorExit;

	WaitOnThisThread(me, PR_INTERVAL_NO_TIMEOUT);

	err = me->md.osErrCode;
	if (err != kOTNoError)
		goto ErrorExit;

	PR_ASSERT(me->md.cookie == &bindReq);

	return kOTNoError;

ErrorExit:
	macsock_map_error(err);
    return -1;
}

Example #4

// Errors:
// EBADF -- bad socket id
PRInt32 _MD_listen(PRFileDesc *fd, PRIntn backlog)
{
#if 0
	PRInt32 osfd = fd->secret->md.osfd;
	OSStatus err;
	EndpointRef endpoint = (EndpointRef) osfd;
	TBind bindReq;
	PRNetAddr addr;
	PRThread *me = _PR_MD_CURRENT_THREAD();

	if (backlog == 0)
		backlog = 1;

	if (endpoint == NULL) {
		err = EBADF;
		goto ErrorExit;
	}
		
	addr.inet.port = addr.inet.ip = 0;

	bindReq.addr.maxlen = PR_NETADDR_SIZE (&addr);
	bindReq.addr.len = 0;
	bindReq.addr.buf = (UInt8*) &addr;
	bindReq.qlen = 0;
	
	PrepareThreadForAsyncIO(me, endpoint, osfd);    

	err = OTGetProtAddress(endpoint, &bindReq, NULL);
	if (err != kOTNoError)
		goto ErrorExit;

	WaitOnThisThread(me, PR_INTERVAL_NO_TIMEOUT);

	err = me->md.osErrCode;
	if (err != kOTNoError)
		goto ErrorExit;

	PrepareThreadForAsyncIO(me, endpoint, osfd);    

	err = OTUnbind(endpoint);
	if (err != kOTNoError)
		goto ErrorExit;

	WaitOnThisThread(me, PR_INTERVAL_NO_TIMEOUT);

	err = me->md.osErrCode;
	if (err != kOTNoError)
		goto ErrorExit;

	bindReq.qlen = backlog;
	
	PrepareThreadForAsyncIO(me, endpoint, osfd);    

	err = OTBind(endpoint, &bindReq, NULL);
	if (err != kOTNoError)
		goto ErrorExit;

	WaitOnThisThread(me, PR_INTERVAL_NO_TIMEOUT);

	err = me->md.osErrCode;
	if (err != kOTNoError)
		goto ErrorExit;

	PR_ASSERT(me->md.cookie == NULL);

	return kOTNoError;

ErrorExit:
	macsock_map_error(err);
    return -1;
#endif

#pragma unused (fd, backlog)	
	return kOTNoError;

}