int CTcpSock::Bind(TInetAddr &ia)
{
TInt ret;
ret = iSocket.Open(ts->cts->iSockServer->iSocketServer, ia.Family(),
KSockStream, KProtocolInetTcp);
if (KErrNone != ret) {
DEBUG_WARNING("bind: Open (ret=%d)\n", ret);
goto error;
}
ret = iSocket.SetOpt(KSoReuseAddr, KSolInetIp, 1);
if (KErrNone != ret) {
DEBUG_WARNING("SetOpt ReuseAddr: ret=%d\n", ret);
}
ret = iSocket.Bind(ia);
if (KErrNone != ret) {
DEBUG_WARNING("bind: Bind (ret=%d)\n", ret);
goto error;
}
error:
return kerr2errno(ret);
}
int CTcpConn::Open(TInetAddr &ia)
{
TInt ret;
if (rconnection) {
DEBUG_INFO("TCP Socket Open: Using RConnection=%p\n",
rconnection);
ret = iSocket.Open(iSockServer->iSocketServer, ia.Family(),
KSockStream, KProtocolInetTcp,
*rconnection);
}
else {
ret = iSocket.Open(iSockServer->iSocketServer, ia.Family(),
KSockStream, KProtocolInetTcp);
}
return kerr2errno(ret);
}
QHostAddress qt_QHostAddressFromTInetAddr(const TInetAddr& addr)
{
if (addr.IsV4Mapped() || addr.Family() == KAfInet) {
//convert v4 host address
return QHostAddress(addr.Address());
} else {
//convert v6 host address
return QHostAddress((quint8 *)(addr.Ip6Address().u.iAddr8));
}
}
//TODO: share this, at least QHostInfo needs to do the same thing
static QHostAddress qt_QHostAddressFromTInetAddr(const TInetAddr& addr)
{
//TODO: do we want to call v4 mapped addresses v4 or v6 outside of this file?
if (addr.IsV4Mapped() || addr.Family() == KAfInet) {
//convert v4 host address
return QHostAddress(addr.Address());
} else {
//convert v6 host address
return QHostAddress((quint8 *)(addr.Ip6Address().u.iAddr8));
}
}
// -----------------------------------------------------------------------------
// CLocalAddrResolver::SetAddr
// -----------------------------------------------------------------------------
//
void CLocalAddrResolver::SetAddr( TInetAddr& aTarget, TInetAddr& aSource )
{
if ( aSource.Family() == KAfInet6 )
{
if(!aSource.IsLinkLocal())
{
aTarget = aSource;
aTarget.SetScope(0);
}
}
else
{
aTarget = aSource;
aTarget.SetScope(0);
}
}
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;
}
// ---------------------------------------------------------------------------
// CNATFWStunConnectionHandler::FetchCandidateL
// ---------------------------------------------------------------------------
//
void CNATFWStunConnectionHandler::FetchCandidateL( TUint aStreamId,
TUint /*aRtoValue*/, TUint /*aAddrFamily*/,
const TInetAddr& aBaseAddr )
{
__STUNPLUGIN( "CNATFWStunConnectionHandler::FetchCandidateL start" )
// Store data in array
TStreamData streamData;
streamData.iStreamId = aStreamId;
CNATFWCandidate* newCandidate = CNATFWCandidate::NewLC();
TInetAddr publicAddr;
if ( KAfInet6 == aBaseAddr.Family() )
{
const TIp6Addr KIp6Addr = {{{1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,1}}};
publicAddr.SetAddress( KIp6Addr );
}
else
{
publicAddr.SetAddress( INET_ADDR( 1,2,3,4 ) );
}
// Set candidate parameters
newCandidate->SetStreamId( aStreamId );
newCandidate->SetType( CNATFWCandidate::EServerReflexive );
newCandidate->SetTransportAddrL( publicAddr );
newCandidate->SetTransportProtocol( KProtocolInetUdp );
TConnectionData connData;
connData.iLocalCandidate = newCandidate;
streamData.iConnArray.AppendL( connData );
iStreamArray.AppendL( streamData );
TCallBackCmd cmd
= TCallBackCmd( aStreamId, EFetchCandidate, 0, newCandidate );
iCallBackCmds.AppendL( cmd );
CleanupStack::Pop( newCandidate );
if ( !IsActive() )
{
After( KWaitTime );
}
// wait MNcmConnectionObserver::ConnectionNotify
__STUNPLUGIN( "CNATFWStunConnectionHandler::FetchCandidateL end" )
}
int CPjSSLSocket::Connect(CPjSSLSocket_cb cb, void *key,
const TInetAddr &local_addr,
const TInetAddr &rem_addr,
const TDesC8 &servername,
const TDesC8 &ciphers)
{
pj_status_t status;
PJ_ASSERT_RETURN(state_ == SSL_STATE_NULL, PJ_EINVALIDOP);
status = pj_sock_socket(rem_addr.Family(), pj_SOCK_STREAM(), 0, &sock_);
if (status != PJ_SUCCESS)
return status;
// Apply QoS
status = pj_sock_apply_qos2(sock_, qos_type_, &qos_params_,
2, THIS_FILE, NULL);
RSocket &rSock = ((CPjSocket*)sock_)->Socket();
local_addr_ = local_addr;
if (!local_addr_.IsUnspecified()) {
TInt err = rSock.Bind(local_addr_);
if (err != KErrNone)
return PJ_RETURN_OS_ERROR(err);
}
cb_ = cb;
key_ = key;
rem_addr_ = rem_addr;
/* Note: the following members only keep the pointer, not the data */
servername_.Set(servername);
ciphers_.Set(ciphers);
rSock.Connect(rem_addr_, iStatus);
SetActive();
state_ = SSL_STATE_CONNECTING;
rSock.LocalName(local_addr_);
return PJ_EPENDING;
}
// -----------------------------------------------------------------------------
// CMceLocalAddrResolver::SetAddressesIfNotSet
// -----------------------------------------------------------------------------
//
void CMceLocalAddrResolver::SetAddressesIfNotSet( const TInetAddr& aAddr )
{
if ( aAddr.Family() == KAfInet )
{
if ( iAddr.IsUnspecified() )
{
iAddr = aAddr;
}
iIPv4Addr = aAddr;
}
else
{
iAddr = aAddr;
}
if ( iIPv4Addr.IsUnspecified() && iAddr.IsV4Mapped() )
{
iIPv4Addr = iAddr;
iIPv4Addr.ConvertToV4();
}
}
// ---------------------------------------------------------------------------
// This static method builds a generic PFKEY API extension data for IPSEC.
// This data contains all parameters needed by the IPSEC to do UDP
// encapsulation/decpsulation for ESP packet. Generic extension data format is
// LID format begining with four bytes extension header. Extension header
// consists two bytes extension length and two bytes extension ID. LID format
// consists from one byte length, one byte ID and parameter data.
// Buffer format: HL,HID,LID,LID,...LID
// Generic extension data buffer handling macros are defined in pfkeyext.h
// (common macros with IPSEC)
// ---------------------------------------------------------------------------
//
EXPORT_C void PFKeyExtDataUtil::BuildUdpEncExtensionData( TDes8& aExtData,
TUint32 aNAT_D_Flags,
TBool aNATDetected,
TBool aNokiaNATProbeUsed,
TUint16 aUdpEncapsPort,
TUint16 aKeepAliveTimeout,
const TInetAddr& aDestinAddr,
const TInetAddr& aOriginalAddr )
{
if ( aNAT_D_Flags )
{
aUdpEncapsPort = FLOATED_IKE_PORT; // for IETF specified ESP UDP encapsulation
if ( ( aNAT_D_Flags & LOCAL_END_NAT ) == 0 )
{
aKeepAliveTimeout = 0; // Local end is not behind NAT, no keepalive needed
}
}
else
{
//
// Nokia specific NAT traversal info (=ESP UDP tunneling)
// If aNATDetected is true connection is over NAT:ted
// network (=local end behind NAT). UDP encapsulation shall
// then be done using configured port iEspUdpPort. If that
// value is undefined default port 9872 shall be used then.
// If aNATDetected is false and aNokiaNATProbeUsed is true
// the NAT probe procedure has confirmed that there is no
// NAT device between. ESP UDP encapsulation port is zeroed
// then to avoid unnecessary ESP UDP encapsulation.
// If aNokiaNATProbeUsed is false ESP UDP encapsulation is done
// without probing, if any aUdpEncapsPort is defined
//
if ( !aNATDetected && aNokiaNATProbeUsed )
{
aUdpEncapsPort = 0;
}
}
if ( aUdpEncapsPort == 0 )
{
aExtData.SetLength(0); // No extension data needed
return;
}
TPfkeyGenExtension NatExtension( aExtData, ESP_UDP_ENCAPSULATION_EXT );
NatExtension.StoreParameter( UDP_ENCAPSULATION_PORT,
2,
(TUint8*)&aUdpEncapsPort );
if ( aKeepAliveTimeout )
{
NatExtension.StoreParameter( NAT_KEEPALIVE_TIMEOUT,
2,
(TUint8*)&aKeepAliveTimeout );
}
if ( aNAT_D_Flags & REMOTE_END_NAT )
{
NatExtension.StoreParameter( DESTINATION_ADDRESS,
sizeof(TInetAddr),
(TUint8*)&aDestinAddr );
}
if ( aOriginalAddr.Family() != KAFUnspec )
{
NatExtension.StoreParameter( PEER_ORIGINAL_ADDRESS,
sizeof(TInetAddr),
(TUint8*)&aOriginalAddr );
}
}
