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();
}
