C++ TInetAddr::Port方法代码示例

enum TVerdict CEsockTest19_1::easyTestStepL()
	{
	TInetAddr addr;
	TBuf<39> buf;
	
	// setting the IP address
	
	const TIp6Addr KInet6Addr19_1 = {{{0xff,0xfe,0,0,0,0,0,0,0,0,0,0,0,0,0x29,0xfe}}};
	const TIp6Addr KInet6Addr19_2 = {{{0xff,0xf1,0,1,0,1,0,1,0,1,0,1,0,1,0x29,0xff}}};
	
	// setting the IP address
	
	// set the address
	addr.SetAddress(KInet6Addr19_1);
	
	// check it has been set correctly
	addr.OutputWithScope(buf);
	TESTL(buf==_L("fffe::29fe"));
	
	// check port number initialised to 0
	TESTL(addr.Port()==0);
	
	// change the address
	addr.SetAddress(KInet6Addr19_2);
	
	// check it has been set correctly
	addr.OutputWithScope(buf);
	TESTL(buf==_L("fff1:1:1:1:1:1:1:29ff"));
	
	// check port number is still set to 0
	TESTL(addr.Port()==0);
	
	return EPass;
	}

/**
 * Handle incoming connects
 */
void tcp_sock::tcp_conn_handler()
{
	if (!ctc) {
		DEBUG_WARNING("conn handler: no pending socket\n");
	}

	TInetAddr ia;
	struct sa peer;
	ctc->iSocket.RemoteName(ia);
	sa_set_in(&peer, ia.Address(), ia.Port());

	DEBUG_INFO("conn handler: incoming connect from %J\n", &peer);

	ctc->blank = false;

	/*
	 * Application handler might call tcp_accept(), tcp_reject()
	 * or do nothing
	 */
	if (connh)
		connh(&peer, arg);

	if (ctc) {
		DEBUG_INFO("delete ctc\n");
		delete ctc;
		ctc = NULL;
	}

	/* Create blank socket for the next incoming CONNECT */
	blank_socket();

	cts->Accepting();
}

TSAHostCacheEntry::TSAHostCacheEntry(const TInetAddr& aAddress, TInt aQuality)
{
	iPort = aAddress.Port();
	iAddress = aAddress.Address();

	iQuality = aQuality;
}

TInt CUdpProcess::SendDataL(TDes8& aData, TInetAddr& aAddr, TInt aSize)
    /**
      Send data.
      @return the size of data sent
      */
{
    TRequestStatus status;
    
    TInt port = aAddr.Port();
    iConsole.Printf(_L("Before sending, size = %d, port=%d\n"), aSize, port);
    TSockXfrLength sendSize = 0; //aSize;
    iSocket.SendTo(aData, aAddr, 0, status, sendSize);
    User::WaitForRequest(status);
    iConsole.Printf(_L("Sending result = %d, and sent=%d\n"), status.Int(), sendSize());

    switch(status.Int())
    {
    case KErrEof:
        iConsole.Printf(_L("Connection closed!"));
        return 0;       
    case KErrNone:
        iConsole.Printf(_L("Send successfully.\n"));
        break;
    default:
        User::LeaveIfError(status.Int());
        break;
    }
    return sendSize();
}

SilcUInt16 silc_net_get_remote_port(SilcSocket sock)
{
  SilcSymbianSocket *s = (SilcSymbianSocket *)sock;
  TInetAddr addr;

  s->sock->RemoteName(addr);
  return (SilcUInt16)addr.Port();
}

SilcUInt16 silc_net_get_local_port(SilcSocket sock)
{
  SilcSymbianSocket *s = (SilcSymbianSocket *)sock;
  TInetAddr addr;

  s->sock->LocalName(addr);
  return (SilcUInt16)addr.Port();
}

int udp_sock::local_get(struct sa *local) const
{
	TInetAddr ia;

	cus->iSocket.LocalName(ia);
	sa_set_in(local, ia.Address(), ia.Port());

	return 0;
}

/**
 * Get the local IP address of the device
 *
 * @note Requires at least one IP packet sent in advance!
 */
int net_if_getaddr4(const char *ifname, int af, struct sa *ip)
{
	(void)ifname;

	if (AF_INET != af)
		return EAFNOSUPPORT;

	/* Already cached? */
	if (sa_isset(&local_ip, SA_ADDR)) {
		sa_cpy(ip, &local_ip);
		return 0;
	}

	RSocketServ ss;
	RSocket s;
	TInt ret;

	ret = ss.Connect();
	if (KErrNone != ret) {
		DEBUG_WARNING("connecting to socket server fail (ret=%d)\n",
			      ret);
		return ECONNREFUSED;
	}

	ret = s.Open(ss, KAfInet, KSockDatagram, KProtocolInetUdp);
	if (KErrNone != ret) {
		DEBUG_WARNING("open socket failed (ret=%d)\n", ret);
		return ECONNREFUSED;
	}

	TInetAddr bind;
	bind.SetPort(0);
	bind.SetAddress(KInetAddrAny);

	ret = s.Bind(bind);
	if (KErrNone != ret) {
		DEBUG_WARNING("bind socket failed (ret=%d)\n", ret);
		return ECONNREFUSED;
	}

	TInetAddr local;
	s.LocalName(local);

	s.Close();
	ss.Close();

	sa_set_in(&local_ip, local.Address(), local.Port());

	DEBUG_NOTICE("local IP addr: %j\n", &local_ip);

	if (!sa_isset(&local_ip, SA_ADDR))
		return EINVAL;

	sa_cpy(ip, &local_ip);

	return 0;
}

int tcp_sock_local_get(const struct tcp_sock *ts, struct sa *local)
{
	if (!ts || !local)
		return EINVAL;

	TInetAddr ia;
	ts->cts->iSocket.LocalName(ia);
	sa_set_in(local, ia.Address(), ia.Port());

	return 0;
}

int tcp_conn_peer_get(const struct tcp_conn *tc, struct sa *peer)
{
	if (!tc || !peer)
		return EINVAL;

	TInetAddr ia;
	tc->ctc->iSocket.RemoteName(ia);
	sa_set_in(peer, ia.Address(), ia.Port());

	return 0;
}

int tcp_conn_local_get(const struct tcp_conn *tc, struct sa *local)
{
	if (!tc || !local)
		return EINVAL;

	TInetAddr ia;
	tc->ctc->iSocket.LocalName(ia);
	sa_set_in(local, ia.Address(), ia.Port());

	return 0;
}

int ILibSocketWrapper_recvfrom(int socketObject, char *buffer, int bufferLength, struct sockaddr *src)
{
	RSocket *s = (RSocket*)SocketArray[socketObject];
	TRequestStatus status;
	TInetAddr addr;
	int RetVal=0;
	RBuf8 *buf = new RBuf8();
	
	if(buf->Create(bufferLength)==KErrNone)
	{
		TProtocolDesc aProtocol;
		
		s->Info(aProtocol);
		if(aProtocol.iSockType==KSockStream)
		{
			s->RemoteName(addr);
			((struct in_addr*)src->sa_data)->s_addr = ntohl(addr.Address());
			src->sa_port = htons(addr.Port());
			RetVal = ILibSocketWrapper_recv(socketObject, buffer, bufferLength);
		}
		else
		{
			s->RecvFrom(*buf,addr,(unsigned int)0,status);
			User::WaitForRequest(status);
			if(status!=KErrNone)
			{
				RetVal = 0;
			}
			else
			{
				((struct in_addr*)src->sa_data)->s_addr = ntohl(addr.Address());
				src->sa_port = htons(addr.Port());
				Mem::Copy(buffer,buf->Ptr(),buf->Length());
				RetVal = buf->Length();
			}
		}
	}
	buf->Close();
	delete buf;
	return(RetVal);
}

MFactoryQuery::TMatchResult THttpClientFlowQuery::Compare(TFactoryObjectInfo& aFactoryObjectInfo )
	{
	const CHttpClientFlow* flow = static_cast<const CHttpClientFlow*>(aFactoryObjectInfo.iInfo.iFactoryObject);
	
	// iClientFlags == ECreateNew is handled by factory, other needs to be checked here	
 	TInetAddr remName;
   	flow->RemName( remName );
  	if ( remName.Address ( ) == iSockAddr.iAddr && remName.Port ( ) ==  iSockAddr.iPort && flow->Status( ) == KErrNone )
		{
		return MFactoryQuery::EMatch;
		}
	return MFactoryQuery::EContinue;
	}

int ILibSocketWrapper_getsockname(int socketObject, struct sockaddr* local, int* length)
{
  struct sockaddr_in* localAddr = (struct sockaddr_in*)local;
	RSocket *s = (RSocket*)SocketArray[socketObject];
  TInetAddr sockAddr;

  // get the local name
  s->LocalName(sockAddr);

  // convert from Symbian
  localAddr->sin_family = sockAddr.Family();
  localAddr->sin_port = sockAddr.Port();
  localAddr->sin_addr.s_addr = ntohl(sockAddr.Address());
  
  return 0;
}

void CFTPResolver::SetAddress(TInetAddr& aAddress)
{
	// Get the 1st entry resolved
	iNameRecord = iNameEntry();
	// Save the address (take care not to overwrite the port, might have been already set)
	if (TInetAddr::Cast(iNameRecord.iAddr).Family() == KAfInet)
		aAddress.SetAddress(TInetAddr::Cast(iNameRecord.iAddr).Address());
	else
		aAddress.SetAddress(TInetAddr::Cast(iNameRecord.iAddr).Ip6Address());

#if defined(__FTPPROTDEBUG__)
	TBuf<512> debugBuffer; // A Buffer to output the resolved IP 
	
	aAddress.Output(debugBuffer);
	debugBuffer.Append(_L(","));
	debugBuffer.AppendNum(aAddress.Port(), EDecimal); 
	debugBuffer.Append(_L("\n"));
#endif
	FTPPROTDEBUG(_DBGResolver,_L("Resolved address is:"));
	FTPPROTDEBUG(_DBGResolver,debugBuffer);
}