void PerfSocket::ReportServerSettings( const char* inLocalhost ) { sReporting.Lock(); // print settings printf( seperator_line ); printf( server_port, (mUDP ? "UDP" : (mSettings->mProtocol == 0 ? "TCP" : "SCTP")), mPort); if ( inLocalhost != NULL ) { SocketAddr local = getLocalAddress(); char addr[ REPORT_ADDRLEN ]; local.getHostAddress( addr, sizeof(addr)); printf( bind_address, addr ); if ( local.isMulticast() ) { printf( join_multicast, addr ); } } if ( mUDP ) { printf( server_datagram_size, mSettings->mBufLen ); } ReportWindowSize(); printf( seperator_line ); fflush( stdout ); sReporting.Unlock(); }
bool SocketAddr::operator==(const SocketAddr& other) const { if (m_length != other.length()) return false; if (m_address == other.address()) return true; if (m_address && other.address()) return !::memcmp(m_address,other.address(),m_length); return false; }
// Set IPv6 sin6_scope_id for remote addresses from local address // recvFrom() will set the sin6_scope_id of the remote socket address // This will avoid socket address comparison mismatch (same address, different scope id) static inline void setScopeId(const SocketAddr& local, SocketAddr& sa1, SocketAddr& sa2, SocketAddr* sa3 = 0) { if (local.family() != SocketAddr::IPv6) return; unsigned int val = local.scopeId(); sa1.scopeId(val); sa2.scopeId(val); if (sa3) sa3->scopeId(val); }
bool RTPTransport::localAddr(SocketAddr& addr, bool rtcp) { // check if sockets are already created and bound if (m_rtpSock.valid()) return false; int p = addr.port(); // for RTCP make sure we don't have a port or it's an even one if (rtcp && (p & 1)) return false; m_warnSendErrorRtp = true; m_warnSendErrorRtcp = true; if (m_rtpSock.create(addr.family(),SOCK_DGRAM) && m_rtpSock.bind(addr)) { m_rtpSock.setBlocking(false); if (!rtcp) { // RTCP not requested - we are done m_rtpSock.getSockName(addr); m_localAddr = addr; setScopeId(m_localAddr,m_remoteAddr,m_remotePref); return true; } if (!p) { m_rtpSock.getSockName(addr); p = addr.port(); if (p & 1) { // allocated odd port - have to swap sockets m_rtcpSock.attach(m_rtpSock.detach()); addr.port(p-1); if (m_rtpSock.create(addr.family(),SOCK_DGRAM) && m_rtpSock.bind(addr)) { m_rtpSock.setBlocking(false); m_localAddr = addr; setScopeId(m_localAddr,m_remoteAddr,m_remoteRTCP,&m_remotePref); return true; } DDebug(DebugMild,"RTP Socket failed with code %d",m_rtpSock.error()); m_rtpSock.terminate(); m_rtcpSock.terminate(); return false; } } addr.port(p+1); if (m_rtcpSock.create(addr.family(),SOCK_DGRAM) && m_rtcpSock.bind(addr)) { m_rtcpSock.setBlocking(false); addr.port(p); m_localAddr = addr; setScopeId(m_localAddr,m_remoteAddr,m_remoteRTCP,&m_remotePref); return true; } #ifdef DEBUG else Debug(DebugMild,"RTCP Socket failed with code %d",m_rtcpSock.error()); #endif } #ifdef DEBUG else Debug(DebugMild,"RTP Socket failed with code %d",m_rtpSock.error()); #endif m_rtpSock.terminate(); m_rtcpSock.terminate(); return false; }
int mbed_socket::doconnect(const struct sockaddr *addr, socklen_t addrlen) { (void)addrlen; TCPStream* stream; stream = new TCPStream(SOCKET_STACK_LWIP_IPV4); if (stream == NULL) { set_errno(ENOMEM); return -1; } socket_error_t err; err = stream->open(SOCKET_AF_INET4); if (stream->error_check(err)) { TDLOG(".. doconnect error: open failed %s (%d)", socket_strerror(err), err); set_errno(EBADF); // fix value to connect error no return -1; } set_stream(stream, false); sockaddr_in* inaddr = (sockaddr_in*)addr; socket_addr s_addr; SocketAddr saddr; //char addrstr[20]; //makeaddr4string(addrstr, inaddr); //TDDDLOG(".. connect to %s:%d\r\n", addrstr, inaddr->sin_port); socket_addr_set_ipv4_addr(&s_addr, inaddr->sin_addr.s_addr); saddr.setAddr(&s_addr); stream->setOnError(on_error_t(this, &mbed_socket::on_error)); stream->setOnReadable(on_readable_t(this, &mbed_socket::on_readable)); stream->setOnSent(on_sent_t(this, &mbed_socket::on_sent)); stream->setOnDisconnect(on_disconnect_t(this, &mbed_socket::on_disconnect)); sock_flag_ |= MBED_SOCKET_FLAG_CONNECTING; err = stream->connect(saddr, inaddr->sin_port, on_connect_t(this, &mbed_socket::on_connect)); if (stream->error_check(err)) { TDLOG(".. doconnect error: open failed %s (%d)", socket_strerror(err), err); set_errno(EBADF); // fix value to connect error no return -1; } set_errno(EINPROGRESS); return -1; }
int Socket::recvFrom(void* buffer, int length, SocketAddr& addr, int flags) { char buf[MAX_SOCKLEN]; socklen_t len = sizeof(buf); int res = recvFrom(buffer,length,(struct sockaddr*)buf,&len,flags); if (res != socketError()) addr.assign((struct sockaddr*)buf,len); return res; }
bool Socket::getPeerName(SocketAddr& addr) { char buf[MAX_SOCKLEN]; socklen_t len = sizeof(buf); bool ok = getPeerName((struct sockaddr*)buf,&len); if (ok) addr.assign((struct sockaddr*)buf,len); return ok; }
bool RTPTransport::remoteAddr(SocketAddr& addr, bool sniff) { Lock lock(group()); m_autoRemote = sniff; int p = addr.port(); // make sure we have a valid address and a port // we do not check that it's even numbered as many NAPTs will break that if (p && addr.valid()) { m_warnSendErrorRtp = true; m_warnSendErrorRtcp = true; m_remoteAddr = addr; m_remoteRTCP = addr; m_remoteRTCP.port(addr.port()+1); // if sniffing packets from other sources remember preferred address if (sniff) m_remotePref = addr; setScopeId(m_localAddr,m_remoteAddr,m_remoteRTCP,sniff ? &m_remotePref : 0); return true; } return false; }
// Send data to remote party // Put a debug message on failure // Return true if all bytes were sent static bool sendData(Socket& sock, const SocketAddr& to, const void* data, int len, const char* what, bool& flag) { if (!sock.valid()) return false; if (!to.valid()) { if (flag) { flag = false; SocketAddr local; sock.getSockName(local); Debug(DebugNote,"%s send failed (local=%s): invalid remote address", what,local.addr().c_str()); } return false; } int wr = sock.sendTo(data,len,to); if (wr == Socket::socketError() && flag && !sock.canRetry()) { flag = false; // Retrieve the error before calling getSockName() to avoid reset String s; int e = sock.error(); Thread::errorString(s,e); SocketAddr local; sock.getSockName(local); Debug(DebugNote,"%s send failed (local=%s remote=%s): %d %s", what,local.addr().c_str(),to.addr().c_str(),e,s.c_str()); } return wr == len; }
int Socket::GetLocalAddr(SocketAddr & rAddr) { struct sockaddr_in sockAddr; int nSockAddrLen = sizeof(sockAddr); if (0 != getsockname(_socket, (struct sockaddr*) &sockAddr, &nSockAddrLen)) { return WSAGetLastError(); } rAddr.SetSocketAddr(inet_ntoa(sockAddr.sin_addr), ntohs(sockAddr.sin_port)); return SOCK_OK; }
int mbed_socket::dogetpeername(struct sockaddr* addr, socklen_t* addrlen) { TCPAsynch* async; SocketAddr sockaddr; socket_error_t err; uint16_t sockport = 0; async = tcp_.tcp; err = async->getRemoteAddr(&sockaddr); async->getRemotePort(&sockport); if (async->error_check(err) || !sockaddr.is_v4()) { set_errno(EOPNOTSUPP); return -1; } struct sockaddr_in* inaddr = (struct sockaddr_in*)addr; inaddr->sin_family = AF_INET; inaddr->sin_addr.s_addr = socket_addr_get_ipv4_addr(sockaddr.getAddr()); inaddr->sin_port = sockport; *addrlen = sizeof(struct sockaddr_in); return 0; }
bool SocketAddr::local(const SocketAddr& remote) { if (!remote.valid()) return false; SocketAddr tmp(remote); if (!tmp.port()) tmp.port(16384); Socket sock(tmp.family(),SOCK_DGRAM); if (sock.valid() && sock.connect(tmp) && sock.getSockName(*this)) { port(0); return true; } return false; }
Bool HawkSession::Init(const SocketAddr& sAddr, Int32 iTimeout) { //先关闭 Close(); //连接指定地址 if (!m_sSocket.IsValid() && !m_sSocket.InitTcpClient(sAddr, true, iTimeout)) { #ifdef _DEBUG HawkFmtLog("InitTcpClient Failed, Addr: %s", sAddr.ToString().c_str()); #endif return false; } m_sAddress = sAddr; return true; }
void PerfSocket::ReportPeer( int inSock ) { assert( inSock >= 0 ); SocketAddr local = getLocalAddress(); SocketAddr remote = getRemoteAddress(); // copy the inet_ntoa into temp buffers, to avoid overwriting char local_addr[ REPORT_ADDRLEN ]; local.getHostAddress( local_addr, sizeof(local_addr)); char remote_addr[ REPORT_ADDRLEN ]; remote.getHostAddress( remote_addr, sizeof(remote_addr)); sReporting.Lock(); printf( report_peer, inSock, local_addr, local.getPort(), remote_addr, remote.getPort()); fflush( stdout ); sReporting.Unlock(); }
void CannBallNetworkManager::EstablishPeerConnection(int playerNum) { UDPBroadcast broadcast; broadcast.SetMessage(to_string(CONNECT_MAGIC_NUM) + (playerNum == 1 ? "-PLAY1" : "-PLAY2")); broadcast.SetBroadcastPort(playerNum == 1 ? BROADCAST_PORT_P1 : BROADCAST_PORT_P2); SocketStream& peer = (playerNum == 1 ? m_player1 : m_player2); // TODO: REFACTOR THIS SHIT! broadcast.start(); while(true) // Not needed? Just call broadcast.waitForFinish()??? { if(!broadcast.isRunning()) { broadcast.waitForFinish(); cout << "OffworldNetManager P" << playerNum << ": Broadcast finished." << endl; SocketAddr peerAddr; if(!broadcast.GetPeerAddr(peerAddr)) { cout << "OffworldNetManager P" << playerNum << ": Broadcast failed to find peer." << endl; break; } cout << "OffworldNetManager P" << playerNum << ": Broadcast found peer. Attempting to connect" << endl; SocketAddr peerAddrStreamPort(peerAddr.GetIpAddr(), STREAM_PORT); Sleep(20); // Sleep gives peer time to setup their end. SetThreadAffinityMask(GetHandle(), 2); if(peer.Open(peerAddrStreamPort, 0)) { // managed to connect. cout << "Connection to peer [" << peer.GetPeerAddr().ToString() << "]" << endl; char recvBuffer[100000]; memset(recvBuffer, 0, 100000); if (peer.Recv(recvBuffer, 100000, 0) > 0) { std::stringstream ssBuffer(recvBuffer); std::string head; ssBuffer >> head; if(!head.compare("INIT")) { // Now read in entities. while(!ssBuffer.eof()) { std::string entityId; ssBuffer >> head; if(!head.compare("ENT")) { // Load in entity data. ssBuffer >> entityId; entityId =/* "P" + to_string(playerNum) + */entityId; // What is it? Circle, Square? std::string entityType; ssBuffer >> entityType; if(!entityType.compare("CIRC")) { LoadCircle(ssBuffer, entityId); // Update circle to follow if it matches the player we're following. if (playerNum == m_playerNum) { m_followBallStr = entityId; } // m_followBall = m_scene->GetEntitySafe(entityId); } else if(!entityType.compare("SQR")) { LoadSquare(ssBuffer, entityId); } else if (!entityType.compare("CAN")) { LoadCannon(ssBuffer, entityId); } } } int sentBytes = 0; //while(sentBytes < 3) //{ // Keep trying until sent all the data. Should send straight away without issues though. // NOTE: Probably best to put something like this within the Send buffer. sentBytes = peer.Send("ACK", 3, 0); //} } }
void PerfSocket::Recv_TCP( void ) { extern Mutex clients_mutex; extern Iperf_ListEntry *clients; // get the remote address and remove it later from the set of clients SocketAddr remote = getRemoteAddress(); iperf_sockaddr peer = *(iperf_sockaddr *) (remote.get_sockaddr()); // keep track of read sizes -> gives some indication of MTU size // on SGI this must be dynamically allocated to avoid seg faults int currLen; int *readLenCnt = new int[ mSettings->mBufLen+1 ]; for ( int i = 0; i <= mSettings->mBufLen; i++ ) { readLenCnt[ i ] = 0; } InitTransfer(); #ifndef WIN32 signal (SIGPIPE, SIG_IGN); #endif do { // perform read currLen = read( mSock, mBuf, mSettings->mBufLen ); if ( false ) { DELETE_ARRAY( readLenCnt ); Server_Send_TCP(); return; } mPacketTime.setnow(); // periodically report bandwidths ReportPeriodicBW(); mTotalLen += currLen; // count number of reads of each size if ( currLen <= mSettings->mBufLen ) { readLenCnt[ currLen ]++; } } while ( currLen > 0 && sInterupted == false ); // stop timing mEndTime.setnow(); sReporting.Lock(); ReportBW( mTotalLen, 0.0, mEndTime.subSec( mStartTime )); sReporting.Unlock(); if ( mSettings->mPrintMSS ) { // read the socket option for MSS (maximum segment size) ReportMSS( getsock_tcp_mss( mSock )); // on WANs the most common read length is often the MSS // on fast LANs it is much harder to detect int totalReads = 0; for ( currLen = 0; currLen < mSettings->mBufLen+1; currLen++ ) { totalReads += readLenCnt[ currLen ]; } // print each read length that occured > 5% of reads int thresh = (int) (0.05 * totalReads); printf( report_read_lengths, mSock ); for ( currLen = 0; currLen < mSettings->mBufLen+1; currLen++ ) { if ( readLenCnt[ currLen ] > thresh ) { printf( report_read_length_times, mSock, (int) currLen, readLenCnt[ currLen ], (100.0 * readLenCnt[ currLen ]) / totalReads ); } } } DELETE_ARRAY( readLenCnt ); clients_mutex.Lock(); Iperf_delete ( &peer, &clients ); clients_mutex.Unlock(); }
socket_error_t TCPStream::connect(const SocketAddr &address, const uint16_t port, const ConnectHandler_t &onConnect) { _onConnect = onConnect; socket_error_t err = _socket.api->connect(&_socket, address.getAddr(), port); return err; }
int mbed_socket::doaccept(struct sockaddr *addr, socklen_t *addrlen) { void* impl; impl = incomming_pop(); if (impl == NULL) { set_errno(EINVAL); TDLOG(".. doaccept error: incomming null"); return -1; } TCPListener* listener = get_listener(); if (listener == NULL) { set_errno(EOPNOTSUPP); TDLOG(".. doaccept error: no listener"); return -1; } mbed_socket* socli; socli = new mbed_socket(domain_, type_, protocol_); if (socli == NULL) { set_errno(ENOMEM); TDLOG(".. doaccept error: out of memory"); return -1; } if (socli->get_sock_fd() < 0) { delete socli; TDLOG(".. doaccept error: out of fd"); set_errno(ENOMEM); return -1; } TCPStream* stream; stream = listener->accept(impl); if (stream == NULL) { TDLOG(".. doaccept error: accept failed"); delete socli; set_errno(ENOMEM); return -1; } // it's already connected. there will be no "on_connected" cb called socli->set_stream(stream, true); stream->setOnError(on_error_t(socli, &mbed_socket::on_error)); stream->setOnReadable(on_readable_t(socli, &mbed_socket::on_readable)); stream->setOnSent(on_sent_t(socli, &mbed_socket::on_sent)); stream->setOnDisconnect(on_disconnect_t(socli, &mbed_socket::on_disconnect)); // if (addr && addrlen) { memset(addr, 0, *addrlen); struct sockaddr_in* inaddr = (struct sockaddr_in*)addr; SocketAddr sockaddr; uint16_t sockport; stream->getRemoteAddr(&sockaddr); stream->getRemotePort(&sockport); assert(sockaddr.is_v4()); inaddr = (struct sockaddr_in*)addr; inaddr->sin_family = AF_INET; inaddr->sin_addr.s_addr = socket_addr_get_ipv4_addr(sockaddr.getAddr()); inaddr->sin_port = sockport; *addrlen = sizeof(struct sockaddr_in); } return socli->get_sock_fd(); }