/** * Called when the context has been activated to set our IP address and get * any other required settings from CommDB. * * @param aConfig The new context config */ void CIPv4Binder::UpdateContextConfigL(const TPacketDataConfigBase& aConfig) { OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CIPV4BINDER_UPDATECONTEXTCONFIGL_1, "CIPv4Binder::UpdateContextConfig"); // Get our IP address from the GPRS context config. TInetAddr address; TBuf<RPacketContext::KMaxPDPAddressLength> tempAddr; const RPacketContext::TProtocolConfigOptionV2* pco; TInt rel = const_cast<TPacketDataConfigBase&>(aConfig).ExtensionId(); if (rel == TPacketDataConfigBase::KConfigGPRS) { tempAddr.Copy(static_cast<const RPacketContext::TContextConfigGPRS&>(aConfig).iPdpAddress); pco = &static_cast<const RPacketContext::TContextConfigGPRS&>(aConfig).iProtocolConfigOption; } else { ASSERT(rel == TPacketDataConfigBase::KConfigRel99Rel4 || rel == TPacketDataConfigBase::KConfigRel5); tempAddr.Copy(static_cast<const RPacketContext::TContextConfigR99_R4&>(aConfig).iPdpAddress); pco = &static_cast<const RPacketContext::TContextConfigR99_R4&>(aConfig).iProtocolConfigOption; } TInt ret = address.Input(tempAddr); // We've got our IP address! Let's save it. if (ret == KErrNone) { iSettings.iLocalAddr = address.Address(); OstTraceDefExt4(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CIPV4BINDER_UPDATECONTEXTCONFIGL_2, "Got local IP address from context = %u.%u.%u.%u",iSettings.iLocalAddr >> 24, (iSettings.iLocalAddr >> 16) & 0xFF, (iSettings.iLocalAddr >> 8) & 0xFF, iSettings.iLocalAddr & 0xFF); iSettings.iDefGateway = address.Address(); OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CIPV4BINDER_UPDATECONTEXTCONFIGL_3, "Set Default Gateway to local IP address"); }
// --------------------------------------------------------------------------- // SdpUtil::SetDefaultNetTypeAndAddrType // Sets network type and address type to their "default" values // --------------------------------------------------------------------------- // void SdpUtil::SetDefaultNetTypeAndAddrType( RStringPool aPool, const TInetAddr& aAddress, RStringF& aNetType, RStringF& aAddressType ) { // Sets network type to IN aNetType.Close(); aNetType = aPool.StringF( SdpCodecStringConstants::ENetType, SdpCodecStringConstants::Table ).Copy(); // Address type aAddressType.Close(); TBuf16 <KMaxAddressLength> output; aAddress.Output(output); //addresstype for IPv4 if((aAddress.Address() && !aAddress.IsV4Mapped()) || (!aAddress.Address() && aAddress.IsWildAddr() && output.Match(KWildAddr) == 0)) { aAddressType = aPool.StringF( SdpCodecStringConstants::EAddressTypeIP4, SdpCodecStringConstants::Table ).Copy(); } else { //addresstype for IPv4-Mapped IPv6 && IPv6 aAddressType = aPool.StringF( SdpCodecStringConstants::EAddressType, SdpCodecStringConstants::Table ).Copy(); } }
/** * 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; }
void UT_CTBCPFloorControlImpl::UT_CTBCPFloorControlImpl_SetAddressLL( ) { TBuf<KBufLength> addressbuffer; TInetAddr addr; addr.Input(KAddr2); addr.Output(addressbuffer); iPlugIn->SetAddressL(addressbuffer, KPort1); EUNIT_ASSERT( iPlugIn->iRemoteAddr.Address()==addr.Address()); }
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; }
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)); } }
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 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; }
//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)); } }
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); }
/* * Convert text to IPv4/IPv6 address. */ PJ_DEF(pj_status_t) pj_inet_pton(int af, const pj_str_t *src, void *dst) { char tempaddr[PJ_INET6_ADDRSTRLEN]; PJ_ASSERT_RETURN(af==PJ_AF_INET || af==PJ_AF_INET6, PJ_EINVAL); PJ_ASSERT_RETURN(src && src->slen && dst, PJ_EINVAL); /* Initialize output with PJ_IN_ADDR_NONE for IPv4 (to be * compatible with pj_inet_aton() */ if (af==PJ_AF_INET) { ((pj_in_addr*)dst)->s_addr = PJ_INADDR_NONE; } /* Caution: * this function might be called with cp->slen >= 46 * (i.e. when called with hostname to check if it's an IP addr). */ if (src->slen >= PJ_INET6_ADDRSTRLEN) { return PJ_ENAMETOOLONG; } pj_memcpy(tempaddr, src->ptr, src->slen); tempaddr[src->slen] = '\0'; wchar_t tempaddr16[PJ_INET6_ADDRSTRLEN]; pj_ansi_to_unicode(tempaddr, pj_ansi_strlen(tempaddr), tempaddr16, sizeof(tempaddr16)); TBuf<PJ_INET6_ADDRSTRLEN> ip_addr((const TText*)tempaddr16); TInetAddr addr; addr.Init(KAfInet6); if (addr.Input(ip_addr) == KErrNone) { if (af==PJ_AF_INET) { /* Success (Symbian IP address is in host byte order) */ pj_uint32_t ip = pj_htonl(addr.Address()); pj_memcpy(dst, &ip, 4); } else if (af==PJ_AF_INET6) { const TIp6Addr & ip6 = addr.Ip6Address(); pj_memcpy(dst, ip6.u.iAddr8, 16); } else { pj_assert(!"Unexpected!"); return PJ_EBUG; } return PJ_SUCCESS; } else { /* Error */ return PJ_EINVAL; } }
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; }
TBool CSTTorrentManager::AcceptSocketL(RSocket* aSocket, TUint /*aPort*/, CNetworkConnection& aConnection, TInt aConnIndex) { TBool isLocal = (aConnIndex == 1); if (isLocal && (aConnection.Type() == CNetworkConnection::ERConnectionBased)) { TInetAddr localAddress; iNetworkManager->GetLocalAddress(aConnIndex, localAddress); TInetAddr remoteAddress; aSocket->RemoteName(remoteAddress); if (localAddress.Address() == remoteAddress.Address()) { LWRITELN(iLog, _L("[TorrentMgr] Connected to ourselves via local connection, closing")); return EFalse; } } RegisterIncomingConnectionL(aSocket, isLocal); return ETrue; }
// ----------------------------------------------------------------------------- // CSdpOriginField::TypeMatchesWithFormat // Checks if address type is aligned with the address format // ----------------------------------------------------------------------------- // TBool CSdpOriginField::TypeMatchesWithFormat( const TDesC8& aAddress, const TDesC8& aType, RStringPool aPool ) const { RStringF addrTypeIP4 = aPool.StringF( SdpCodecStringConstants::EAddressTypeIP4, SdpCodecStringConstants::Table ); RStringF addrTypeIP6 = aPool.StringF( SdpCodecStringConstants::EAddressType, SdpCodecStringConstants::Table ); TBool valid( ETrue ); // Check that address type and address matches together TInetAddr addr; TBuf<KMaxAddressLength> address16; address16.Copy( aAddress ); TInt err = addr.Input( address16 ); if ( err == KErrNone && !addr.IsUnspecified()) { TBool ip4Type = ( addrTypeIP4.DesC().CompareF( aType ) == 0 ); TBool ip6Type = ( addrTypeIP6.DesC().CompareF( aType ) == 0 ); if ( ip4Type || ip6Type ) { if ( ( addr.Address() && !addr.IsV4Mapped() && !ip4Type ) || (addr.Address() && addr.IsV4Mapped() && !ip6Type) || ( !addr.Address() && !ip6Type ) ) { valid = EFalse; } } } return valid; }
// ----------------------------------------------------------------------------- // CSdpConnectionField::IsValidAddress // Checks if the given address is valid // ----------------------------------------------------------------------------- // TInt CSdpConnectionField::IsValidAddress( const TInetAddr& aAddress, TInt aTTL, TUint aNumOfAddress ) const { TInt err( KErrSdpCodecConnectionField ); // 0 <= TTL <= 255 or KErrNotFound if not defined // Number of addresses > 0 if ( ( aTTL == KErrNotFound || ( aTTL >= 0 && aTTL <= 255 ) ) && aNumOfAddress > 0 ) { TBuf16 <KMaxAddressLength> output; aAddress.Output(output); // Address has to be either of type IP4 or IP6 // If IP4 and multicast then it must contain TTL attribute // If IP4 and unicast then it must NOT contain TTL and must have 1 address // If IP6 and multicast then it must NOT contain TTL // If IP6 and unicast then it must NOT contain TTL and must have 1 address if ( ( aAddress.Address() && ( ( aAddress.IsMulticast() && aTTL != KErrNotFound ) || ( aAddress.IsUnicast() && aTTL == KErrNotFound && aNumOfAddress == 1 ) ) ) || ( !aAddress.Address() && ( ( aAddress.IsMulticast() && aTTL == KErrNotFound ) || ( aAddress.IsUnicast() && aTTL == KErrNotFound && aNumOfAddress == 1 ) ) || ( aAddress.IsWildAddr() && ( output.Match(KWildAddr) == 0|| output.Match(KWildAddrIPv6) == 0 )) ) ) { err = KErrNone; } } return err; }
void CSender::DoInitL(const TInetAddr& anAddr, const TInt aPort) #endif { iRemote.SetV4MappedAddress(anAddr.Address()); iRemote.SetPort(aPort); TInt err = iSock.Open(iSS, KAfInet, KSockStream, KProtocolInetTcp); User::LeaveIfError(err); #ifdef _USE_QOS if (parameters) { iQosParams = new(ELeave) CQoSParameters; iQosParams->CopyL(*parameters); } #endif }
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; }
// ----------------------------------------------------------------------------- // CSdpOriginField::SetIPAddressType // ----------------------------------------------------------------------------- // void CSdpOriginField::SetIPAddressType( const TInetAddr& aAddr ) { iAddressType.Close(); if ( aAddr.Address() || aAddr.IsUnspecified() ) { //IPv4, IPv4-Mapped IPv6 and 0.0.0.0 iAddressType = iPool.StringF( SdpCodecStringConstants::EAddressTypeIP4, SdpCodecStringConstants::Table ).Copy(); } else { //IPv6 iAddressType = iPool.StringF( SdpCodecStringConstants::EAddressType, SdpCodecStringConstants::Table ).Copy(); } }
// --------------------------------------------------------------------------- // Build internal address info object from internal address information. // --------------------------------------------------------------------------- // EXPORT_C void VPNAddrInfo::BuildVPNAddrInfo( const CInternalAddress* aInternalAddr, const TInetAddr& aDnsServerAddr, TVPNAddress& aVPNAddress, MIkeDebug& aDebug ) { __ASSERT_DEBUG( aInternalAddr != NULL, User::Invariant() ); aVPNAddress.iVPNIfAddr = aInternalAddr->iClientIntAddr; // // Add DNS address(es) to the virtual TVPNAddress object // TInt dnsCount = aInternalAddr->Count(); if ( dnsCount ) { aVPNAddress.iVPNIfDNS1 = *(aInternalAddr->At(0)); if ( dnsCount > 1 ) { aVPNAddress.iVPNIfDNS2 = *(aInternalAddr->At(1)); } } else { if ( aDnsServerAddr.Address() != KAFUnspec ) { #ifdef _DEBUG TBuf<39> addrBuf; aDnsServerAddr.OutputWithScope( addrBuf ); aDebug.LogWriteF(_L("DNS Server Address in IKE data %S"), &addrBuf); #endif //_DEBUG aVPNAddress.iVPNIfDNS1 = aDnsServerAddr; } else { #ifdef _DEBUG aDebug.LogWrite(_L("DNS server not defined in policy")); #endif // _DEBUG } } }
/* * This function converts the Internet host address cp from the standard * numbers-and-dots notation into binary data and stores it in the structure * that inp points to. */ PJ_DEF(int) pj_inet_aton(const pj_str_t *cp, struct pj_in_addr *inp) { enum { MAXIPLEN = PJ_INET_ADDRSTRLEN }; /* Initialize output with PJ_INADDR_NONE. * Some apps relies on this instead of the return value * (and anyway the return value is quite confusing!) */ inp->s_addr = PJ_INADDR_NONE; /* Caution: * this function might be called with cp->slen >= 16 * (i.e. when called with hostname to check if it's an IP addr). */ PJ_ASSERT_RETURN(cp && cp->slen && inp, 0); if (cp->slen >= 16) { return 0; } char tempaddr8[MAXIPLEN]; pj_memcpy(tempaddr8, cp->ptr, cp->slen); tempaddr8[cp->slen] = '\0'; wchar_t tempaddr16[MAXIPLEN]; pj_ansi_to_unicode(tempaddr8, pj_ansi_strlen(tempaddr8), tempaddr16, sizeof(tempaddr16)); TBuf<MAXIPLEN> ip_addr((const TText*)tempaddr16); TInetAddr addr; addr.Init(KAfInet); if (addr.Input(ip_addr) == KErrNone) { /* Success (Symbian IP address is in host byte order) */ inp->s_addr = pj_htonl(addr.Address()); return 1; } else { /* Error */ return 0; } }
// ----------------------------------------------------------------------------- // CSdpConnectionField::SetInetAddressL // Sets address from TInetAddr // ----------------------------------------------------------------------------- // EXPORT_C void CSdpConnectionField::SetInetAddressL( const TInetAddr& aAddress, TInt aTTL, TUint aNumOfAddress ) { __TEST_INVARIANT; if ( IsValidAddress( aAddress, aTTL, aNumOfAddress ) == KErrNone ) { TBuf<KMaxAddressLength> addr16; //If aAddress IPv4-Mapped IPv6, result of Output IPv4 aAddress.Output( addr16 ); HBufC8* tempBuf = HBufC8::NewL( addr16.Length() ); tempBuf->Des().Copy( addr16 ); SdpUtil::SetDefaultNetTypeAndAddrType( iPool, aAddress, iNetType, iAddressType ); if(aAddress.Address() && aAddress.IsV4Mapped()) { iAddressType.Close(); iAddressType = iPool.StringF( SdpCodecStringConstants::EAddressTypeIP4, SdpCodecStringConstants::Table ).Copy(); } // Set address delete iAddress; iAddress = tempBuf; // Set attributes for address iTTL = aTTL; iNumOfAddress = aNumOfAddress; } else { User::Leave( KErrSdpCodecConnectionField ); } __TEST_INVARIANT; }
// ----------------------------------------------------------------------------- // CUpnpSecurityDbConnection::DeleteIpAddressL // Delete ip address to DB. // ----------------------------------------------------------------------------- // void CUpnpSecurityDbConnection::DeleteIpAddressL( const TInetAddr& aIpAddress ) { ExecStatementL( KUpnpSecSqlDeleteIpAddress, aIpAddress.Address() ); }
// ----------------------------------------------------------------------------- // CUpnpSecurityDbConnection::AddIpAddressL // Add ip address to DB. // ----------------------------------------------------------------------------- // void CUpnpSecurityDbConnection::AddIpAddressL( const TInetAddr& aIpAddress ) { EnsureDiskSpaceL(); ExecStatementL( KUpnpSecSqlInsertIpAddress, aIpAddress.Address() ); }
void CSTTorrentManager::OnLocalUDPReceiveL(TInetAddr aSender, const TDesC8& aData) { HLWRITELN(iLog, _L("[TorrentManager] OnLocalUDPReceiveL begin")); TInetAddr localAddress; iNetworkManager->GetLocalAddress(1, localAddress); if (localAddress.Address() == aSender.Address()) { HLWRITELN(iLog, _L("[TorrentManager] Throwing away own message")); return; } #ifdef LOG_TO_FILE LWRITE(iLog, _L("[TorrentManager] UDP sender: ")); TBuf<128> addressBuf; if (aSender.Address() == 0) { addressBuf = _L("? (could not get local address)"); } else { aSender.Output(addressBuf); addressBuf.Append(_L(":")); TBuf<16> portBuf; portBuf.Num(localAddress.Port()); addressBuf.Append(portBuf); } HLWRITELN(iLog, addressBuf); #endif //HLWRITEL(iLog, _L("[TorrentManager] Data received: ")); //HLWRITELN(iLog, aData); // TODO handle multiple torrents if (iTorrents.Count() == 0) return; if (aData.Size() >= 4) { TUint messageLength = NSTUtils::ReadInt32(aData); LWRITE(iLog, _L("[TorrentManager] Datagram length: ")); LWRITELN(iLog, aData.Size()); LWRITE(iLog, _L("[TorrentManager] Message length: ")); LWRITELN(iLog, messageLength); if ((TUint(aData.Size()) >= (4 + messageLength)) && (aData[4] == KMessageIdPiece)) { TInt index = NSTUtils::ReadInt32(aData.Mid(5)); TInt begin = NSTUtils::ReadInt32(aData.Mid(9)); TBool pendingRequestFound = EFalse; // check if the incoming local piece is requested by this peer for (TInt i=0; i<iTorrents[0]->PeerCount(); i++) { if ((iTorrents[0]->Peer(i)->IsLocal()) && (iTorrents[0]->Peer(i)->Connection()) && (iTorrents[0]->Peer(i)->Connection()->State() == EPeerPwConnected)) { pendingRequestFound = iTorrents[0]->Peer(i)->Connection()->HandleIncomingLocalPieceL(index, begin, aData.Mid(13, messageLength - 9)); if (pendingRequestFound) break; } } if (!pendingRequestFound) { if ((iTorrents[0]->PieceCount() > index) && (!iTorrents[0]->Piece(index)->IsDownloaded())) { HLWRITELN(iLog, _L("[TorrentManager] Received unrequested piece")); CSTPiece* piece = iTorrents[0]->Piece(index); CSTPeer* peer = iTorrents[0]->GetPeer(aSender); if (piece->InsertBlockL(begin, aData.Mid(13, messageLength - 9), peer) != KErrNone) { LWRITELN(iLog, _L8("CRITICAL FAULT, Writing to piece failed")); // CRITICAL FAULT } else { HLWRITELN(iLog, _L("[TorrentManager] Writing piece complete")); if (iTorrents[0]->EndGame()) iTorrents[0]->EndGamePieceReceivedL(piece, peer); } iTorrents[0]->iLocalSubPiecesNotRequested++; iTorrents[0]->iLocalSubPiecesNotRequestedSize += aData.Size(); // TODO remove commented part if the code above is working /*if (piece->DownloadedSize() == begin) { CSTPeer* peer = iTorrents[0]->GetPeer(aSender); if (piece->AppendBlockL(aData, peer) != KErrNone) { LWRITELN(iLog, _L8("CRITICAL FAULT, Writing to piece failed")); // CRITICAL FAULT } else { HLWRITELN(iLog, _L("[TorrentManager] Writing piece complete")); if (iTorrents[0]->EndGame()) iTorrents[0]->EndGamePieceReceivedL(piece, peer); } iTorrents[0]->iLocalSubPiecesNotRequested++; } else iTorrents[0]->iLocalSubPiecesReceivedNotMatchPieceBeginning++;*/ } else { iTorrents[0]->iLocalSubPiecesReceivedAlreadyDownloaded++; iTorrents[0]->iLocalSubPiecesReceivedAlreadyDownloadedSize += aData.Size(); } } } } HLWRITELN(iLog, _L("[TorrentManager] OnLocalUDPReceiveL end")); }
void CDHCPMessageHeaderIP4::FinishL(TDesC8& aClientId) /** * Put finishing touches to message for sending * Basically copies in the magic cookie (99.130.83.99) * and the end marker then set the length of the descriptor * as we have been pushing data into the descriptor manually * * @param aClientId The client ID string to be added to the message * @see RFC 2131 for explanation of the magic cookie! * * @internalTechnology */ #endif //SYMBIAN_NETWORKING_DHCP_MSG_HEADERS { __CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPMessageBase::FinishL"))); #ifdef SYMBIAN_NETWORKING_DHCPSERVER if(!iDHCPServerImpl) { #endif // SYMBIAN_NETWORKING_DHCPSERVER TUint8 reqListArray[KDhcpParameterRequestListLen] = {EDHCPHostName, EDHCPDomainNameServer, EDHCPDomainName, EDHCPSubnetMask, EDHCPRouter, EDHCPBroadcastAddr, EDHCPSIPServers}; TPtr8 ptr(reqListArray, KDhcpParameterRequestListLen, KDhcpParameterRequestListLen); // +++++++++++++++++++++++ Client ID +++++++++++++++++++++++++++++++++++++++++/ AddOptionL(EDHCPClientID, aClientId.Length())->GetBodyDes().Copy(aClientId); #ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS RBuf8 appendOpCodeList; appendOpCodeList.CreateL(ptr); if (aOptionsPtr) { TInt optLen=aOptionsPtr->Length(); appendOpCodeList.ReAllocL(KDhcpParameterRequestListLen+optLen); appendOpCodeList.Append(aOptionsPtr->Ptr(),optLen); } AddOptionL(EDHCPParameterReqList, appendOpCodeList.Length())->GetBodyDes().Copy(appendOpCodeList); appendOpCodeList.Close(); #else // +++++++++++++++++++++++ Parameter Request List ++++++++++++++++++++++++++++/ AddOptionL(EDHCPParameterReqList, ptr.Length())->GetBodyDes().Copy(ptr); #endif // +++++++++++++++++++++++ Maximum message size (2 bytes) ++++++++++++++++++++/ AddOptionL(EDHCPMaxMsgSize, 2)->SetBigEndian(KDhcpMaxMsgSizeIP4); #ifdef SYMBIAN_NETWORKING_DHCPSERVER } #endif // SYMBIAN_NETWORKING_DHCPSERVER TInetAddr magic; _LIT(magicCookie, "99.83.130.99"); User::LeaveIfError(magic.Input(magicCookie)); // essential the magic cookie is correct iCookie.SetLittleEndian(magic.Address()); ASSERT(!iOptions.FindOption(EDHCPEnd)); AddOptionL(EDHCPEnd, 0); //add padding if msg shorter than 300 bytes TInt len=iMsg->Length(); TPtr8 des=iMsg->Des(); if (len<300) { des.AppendFill(EDHCPPad, 300-len); } }
static QList<QNetworkInterfacePrivate *> interfaceListing() { TInt err(KErrNone); QList<QNetworkInterfacePrivate *> interfaces; QList<QHostAddress> addressesWithEstimatedNetmasks; // Open dummy socket for interface queries RSocket socket; err = socket.Open(qt_symbianGetSocketServer(), _L("udp")); if (err) { return interfaces; } // Ask socket to start enumerating interfaces err = socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl); if (err) { socket.Close(); return interfaces; } int ifindex = 0; TPckgBuf<TSoInetInterfaceInfo> infoPckg; TSoInetInterfaceInfo &info = infoPckg(); while (socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, infoPckg) == KErrNone) { if (info.iName != KNullDesC) { TName address; QNetworkAddressEntry entry; QNetworkInterfacePrivate *iface = 0; iface = new QNetworkInterfacePrivate; iface->index = ifindex++; interfaces << iface; iface->name = qt_TDesC2QString(info.iName); iface->flags = convertFlags(info); if (/*info.iFeatures&KIfHasHardwareAddr &&*/ info.iHwAddr.Family() != KAFUnspec) { for (TInt i = sizeof(SSockAddr); i < sizeof(SSockAddr) + info.iHwAddr.GetUserLen(); i++) { address.AppendNumFixedWidth(info.iHwAddr[i], EHex, 2); if ((i + 1) < sizeof(SSockAddr) + info.iHwAddr.GetUserLen()) address.Append(_L(":")); } address.UpperCase(); iface->hardwareAddress = qt_TDesC2QString(address); } // Get the address of the interface entry.setIp(qt_QHostAddressFromTInetAddr(info.iAddress)); #if defined(QNETWORKINTERFACE_DEBUG) qDebug() << "address is" << info.iAddress.Family() << entry.ip(); qDebug() << "netmask is" << info.iNetMask.Family() << qt_QHostAddressFromTInetAddr( info.iNetMask ); #endif // Get the interface netmask if (info.iNetMask.IsUnspecified()) { // For some reason netmask is always 0.0.0.0 for IPv4 interfaces // and loopback interfaces (which we statically know) if (info.iAddress.IsV4Mapped()) { if (info.iFeatures & KIfIsLoopback) { entry.setPrefixLength(32); } else { // Workaround: Let Symbian determine netmask based on IP address class (IPv4 only API) TInetAddr netmask; netmask.NetMask(info.iAddress); entry.setNetmask(QHostAddress(netmask.Address())); //binary convert v4 address addressesWithEstimatedNetmasks << entry.ip(); #if defined(QNETWORKINTERFACE_DEBUG) qDebug() << "address class determined netmask" << entry.netmask(); #endif } } else { // For IPv6 interfaces if (info.iFeatures & KIfIsLoopback) { entry.setPrefixLength(128); } else if (info.iNetMask.IsUnspecified()) { //Don't see this error for IPv6, but try to handle it if it happens entry.setPrefixLength(64); //most common #if defined(QNETWORKINTERFACE_DEBUG) qDebug() << "total guess netmask" << entry.netmask(); #endif addressesWithEstimatedNetmasks << entry.ip(); } } } else { //Expected code path for IPv6 non loopback interfaces (IPv4 could come here if symbian is fixed) entry.setNetmask(qt_QHostAddressFromTInetAddr(info.iNetMask)); #if defined(QNETWORKINTERFACE_DEBUG) qDebug() << "reported netmask" << entry.netmask(); #endif } // broadcast address is determined from the netmask in postProcess() // Add new entry to interface address entries iface->addressEntries << entry; #if defined(QNETWORKINTERFACE_DEBUG) qDebug("\n Found network interface %s, interface flags:\n\ IsUp = %d, IsRunning = %d, CanBroadcast = %d,\n\ IsLoopBack = %d, IsPointToPoint = %d, CanMulticast = %d, \n\ ip = %s, netmask = %s, broadcast = %s,\n\ hwaddress = %s", iface->name.toLatin1().constData(), iface->flags & QNetworkInterface::IsUp, iface->flags & QNetworkInterface::IsRunning, iface->flags & QNetworkInterface::CanBroadcast, iface->flags & QNetworkInterface::IsLoopBack, iface->flags & QNetworkInterface::IsPointToPoint, iface->flags & QNetworkInterface::CanMulticast, entry.ip().toString().toLatin1().constData(), entry.netmask().toString().toLatin1().constData(), entry.broadcast().toString().toLatin1().constData(), iface->hardwareAddress.toLatin1().constData()); #endif } }
void CConfigControl::GetDbServiceParamsL() /** * Retrieves the required service parameters. * * @internalComponent * * @leave If any of the called methods leaves. */ { TInt rc; TBuf<255> address; iService->RefreshL(*iSession); iDaemonConfiguration = iService->iIwfName; address = iService->iIpAddr; rc = iAddress.Input(address); if (rc != KErrNone) { __FLOG_STATIC(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigControl::GetDbServiceParamsL - Invalid IP address format")); User::Leave(rc); } // So we know that we're not just picking up a static address. iAddress.SetAddress(iAddress.Address() + 1); address = iService->iIpNetMask; rc = iSubnetMask.Input(address); if (rc != KErrNone) { __FLOG_STATIC1(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigControl::GetDbServiceParamsL - Invalid netmask format [%d]"), rc); User::Leave(rc); } address = iService->iIpGateway; rc = iDefGateway.Input(address); if (rc != KErrNone) { __FLOG_STATIC1(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigControl::GetDbServiceParamsL - Invalid default gateway format [%d]"), rc); User::Leave(rc); } address = iService->iIpNameServer1; rc = iNameServer1.Input(address); if (rc != KErrNone) { __FLOG_STATIC1(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigControl::GetDbServiceParamsL - Invalid name server format [%d]"), rc); User::Leave(rc); } address = iService->iIpNameServer2; rc = iNameServer2.Input(address); if (rc != KErrNone) { __FLOG_STATIC1(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigControl::GetDbServiceParamsL - Invalid name server format [%d]"), rc); User::Leave(rc); } // set up the broadcast address TInetAddr broadcast; broadcast.SubNetBroadcast(iAddress, iSubnetMask); iBroadcastAddress = broadcast.Address(); }