OpenClonk
C4Network2IO.cpp
Go to the documentation of this file.
1 /*
2  * OpenClonk, http://www.openclonk.org
3  *
4  * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
5  * Copyright (c) 2009-2016, The OpenClonk Team and contributors
6  *
7  * Distributed under the terms of the ISC license; see accompanying file
8  * "COPYING" for details.
9  *
10  * "Clonk" is a registered trademark of Matthes Bender, used with permission.
11  * See accompanying file "TRADEMARK" for details.
12  *
13  * To redistribute this file separately, substitute the full license texts
14  * for the above references.
15  */
16 #include "C4Include.h"
17 #include "network/C4Network2IO.h"
18 
19 #include "control/C4GameControl.h"
20 #include "game/C4Application.h"
23 #include "network/C4Network2UPnP.h"
24 
25 #ifndef HAVE_WINSOCK
26 #include <sys/socket.h>
27 #include <netinet/in.h>
28 #include <arpa/inet.h>
29 #endif
30 
31 // internal structures
33 {
36 };
37 
38 // compile options
39 #define C4NET2IO_DUMP_LEVEL 1
40 
41 // *** C4Network2IO
42 
44  : tLastExecute(0), tLastPing(0), tLastStatistic(0)
45 {
46 }
47 
49 {
50  Clear();
51 }
52 
53 bool C4Network2IO::Init(int16_t iPortTCP, int16_t iPortUDP, int16_t iPortDiscover, int16_t iPortRefServer, bool fBroadcast, bool enable_upnp) // by main thread
54 {
55  // Already initialized? Clear first
56  if (pNetIO_TCP || pNetIO_UDP) Clear();
57 
58  // init members
62 
63  // init event callback
65  Thread.SetCallback(Ev_Net_Conn, this);
66  Thread.SetCallback(Ev_Net_Disconn, this);
67  Thread.SetCallback(Ev_Net_Packet, this);
68 
69  // initialize UPnP manager
70  if (enable_upnp && (iPortTCP > 0 || iPortUDP > 0))
71  {
72  assert(!UPnPMgr);
73  UPnPMgr = new C4Network2UPnP;
74  }
75 
76  // initialize net i/o classes: TCP first
77  if (iPortTCP > 0)
78  {
79  // create
80  pNetIO_TCP = new C4NetIOTCP();
81  // init
82  if (!pNetIO_TCP->Init(iPortTCP))
83  {
84  LogF("Network: could not init TCP i/o (%s)", pNetIO_TCP->GetError() ? pNetIO_TCP->GetError() : "");
85  delete pNetIO_TCP; pNetIO_TCP = nullptr;
86  }
87  else
88  LogSilentF("Network: TCP initialized on port %d", iPortTCP);
89 
90  // add to thread, set callback
91  if (pNetIO_TCP)
92  {
93  Thread.AddProc(pNetIO_TCP);
94  pNetIO_TCP->SetCallback(this);
95  if (UPnPMgr) UPnPMgr->AddMapping(P_TCP, iPortTCP, iPortTCP);
96  }
97 
98  }
99  // then UDP
100  if (iPortUDP > 0)
101  {
102  // create
103  pNetIO_UDP = new C4NetIOUDP();
104  // init
105  if (!pNetIO_UDP->Init(iPortUDP))
106  {
107  LogF("Network: could not init UDP i/o (%s)", pNetIO_UDP->GetError() ? pNetIO_UDP->GetError() : "");
108  delete pNetIO_UDP; pNetIO_UDP = nullptr;
109  }
110  else
111  LogSilentF("Network: UDP initialized on port %d", iPortUDP);
112 
113  // add to thread, set callback
114  if (pNetIO_UDP)
115  {
116  Thread.AddProc(pNetIO_UDP);
117  pNetIO_UDP->SetCallback(this);
118  if (UPnPMgr) UPnPMgr->AddMapping(P_UDP, iPortUDP, iPortUDP);
119  }
120  }
121 
122  // no protocols?
123  if (!pNetIO_TCP && !pNetIO_UDP)
124  {
125  LogFatal("Network: fatal - no protocols available!");
126  Thread.ClearCallback(Ev_Net_Conn, this);
127  Thread.ClearCallback(Ev_Net_Disconn, this);
128  Thread.ClearCallback(Ev_Net_Packet, this);
129  return false;
130  }
131 
132  // discovery last
133  if (iPortDiscover > 0)
134  {
135  // create
136  pNetIODiscover = new C4Network2IODiscover(iPortRefServer);
138  // init
139  if (!pNetIODiscover->Init(iPortDiscover))
140  {
141  LogF("Network: could not init discovery (%s)", pNetIODiscover->GetError() ? pNetIODiscover->GetError() : "");
142  delete pNetIODiscover; pNetIODiscover = nullptr;
143  }
144  else
145  LogSilentF("Network: discovery initialized on port %d", iPortDiscover);
146  // add to thread
147  if (pNetIODiscover)
148  Thread.AddProc(pNetIODiscover);
149  }
150 
151  // plus reference server
152  if (iPortRefServer > 0)
153  {
154  // create
156  // init
157  if (!pRefServer->Init(iPortRefServer))
158  {
159  LogF("Network: could not init reference server (%s)", pNetIO_UDP->GetError() ? pNetIO_UDP->GetError() : "");
160  delete pRefServer; pRefServer = nullptr;
161  }
162  else
163  LogSilentF("Network: reference server initialized on port %d", iPortRefServer);
164  // add to thread
165  if (pRefServer)
166  Thread.AddProc(pRefServer);
167  }
168 
169  // own timer
171  Thread.AddProc(this);
172 
173  // ok
174  return true;
175 }
176 
177 void C4Network2IO::Clear() // by main thread
178 {
179  // process remaining events
181  Thread.ProcessEvents();
182  // clear event callbacks
183  Thread.ClearCallback(Ev_Net_Conn, this);
184  Thread.ClearCallback(Ev_Net_Disconn, this);
185  Thread.ClearCallback(Ev_Net_Packet, this);
186  // close all connections
187  CStdLock ConnListLock(&ConnListCSec);
188  for (C4Network2IOConnection *pConn = pConnList, *pNext; pConn; pConn = pNext)
189  {
190  pNext = pConn->pNext;
191  // close
192  pConn->Close();
193  RemoveConnection(pConn);
194  }
195  // reset list
196  pConnList = nullptr;
197  ConnListLock.Clear();
198  // close net i/o classes
199  Thread.RemoveProc(this);
200  if (pNetIODiscover) { Thread.RemoveProc(pNetIODiscover); delete pNetIODiscover; pNetIODiscover = nullptr; }
201  if (pNetIO_TCP) { Thread.RemoveProc(pNetIO_TCP); delete pNetIO_TCP; pNetIO_TCP = nullptr; }
202  if (pNetIO_UDP) { Thread.RemoveProc(pNetIO_UDP); delete pNetIO_UDP; pNetIO_UDP = nullptr; }
203  if (pRefServer) { Thread.RemoveProc(pRefServer); delete pRefServer; pRefServer = nullptr; }
204  if (UPnPMgr) { delete UPnPMgr; UPnPMgr = nullptr; }
205  // remove auto-accepts
206  ClearAutoAccept();
207  // reset flags
208  fAllowConnect = fExclusiveConn = false;
209  // reset connection ID
210  iNextConnID = 0;
211 }
212 
214 {
215  CStdLock LCCoreLock(&LCCoreCSec);
216  LCCore = nCCore;
217 }
218 
220 {
221  if (pNetIO_UDP) return pNetIO_UDP;
222  if (pNetIO_TCP) return pNetIO_TCP;
223  return nullptr;
224 }
225 
227 {
228  if (pNetIO_TCP) return pNetIO_TCP;
229  if (pNetIO_UDP) return pNetIO_UDP;
230  return nullptr;
231 }
232 
233 bool C4Network2IO::Connect(const C4NetIO::addr_t &addr, C4Network2IOProtocol eProt, const C4ClientCore &nCCore, const char *szPassword) // by main thread
234 {
235  return ConnectWithSocket(addr, eProt, nCCore, nullptr, szPassword);
236 }
237 
238 
239 bool C4Network2IO::ConnectWithSocket(const C4NetIO::addr_t &addr, C4Network2IOProtocol eProt, const C4ClientCore &nCCore, std::unique_ptr<C4NetIOTCP::Socket> socket, const char *szPassword) // by main thread
240 {
241  // get network class
242  C4NetIO *pNetIO = getNetIO(eProt);
243  if (!pNetIO) return false;
244  // already connected/connecting?
245  if (GetConnectionByConnAddr(addr, pNetIO)) return true;
246  // assign new connection ID, peer address isn't known yet
247  uint32_t iConnID = iNextConnID++;
248  C4NetIO::addr_t paddr;
249  // create connection object and add to list
251  pConn->Set(pNetIO, eProt, paddr, addr, CS_Connect, szPassword, iConnID);
252  pConn->SetCCore(nCCore);
253  if (socket)
254  pConn->SetSocket(std::move(socket));
255  AddConnection(pConn);
256  // connect
257  if (!pConn->Connect())
258  {
259  // show error
260  LogSilentF("Network: could not connect to %s using %s: %s", addr.ToString().getData(),
261  getNetIOName(pNetIO), pNetIO->GetError() ? pNetIO->GetError() : "");
262  pNetIO->ResetError();
263  // remove class
264  RemoveConnection(pConn);
265  return false;
266  }
267  // ok, wait for connection
268  return true;
269 }
270 
271 void C4Network2IO::SetAcceptMode(bool fnAllowConnect) // by main thread
272 {
273  fAllowConnect = fnAllowConnect;
274  // Allow connect? Allow discovery of this host
275  if (fAllowConnect)
276  {
277  if (pNetIODiscover)
278  {
281  }
282  }
283 }
284 
285 void C4Network2IO::SetExclusiveConnMode(bool fnExclusiveConn) // by main thread
286 {
287  if (fExclusiveConn == fnExclusiveConn)
288  return;
289  // Set flag
290  fExclusiveConn = fnExclusiveConn;
291  // Allowed? Send all pending welcome packets
292  if (!fExclusiveConn)
293  SendConnPackets();
294 }
295 
296 int C4Network2IO::getConnectionCount() // by main thread
297 {
298  int iCount = 0;
299  CStdLock ConnListLock(&ConnListCSec);
300  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
301  if (!pConn->isClosed())
302  iCount++;
303  return iCount;
304 }
305 
306 void C4Network2IO::ClearAutoAccept() // by main thread
307 {
308  CStdLock AALock(&AutoAcceptCSec);
309  // delete
310  while (pAutoAcceptList)
311  {
312  // remove
313  AutoAccept *pAcc = pAutoAcceptList;
314  pAutoAcceptList = pAcc->Next;
315  // delete
316  delete pAcc;
317  }
318 }
319 
320 void C4Network2IO::AddAutoAccept(const C4ClientCore &CCore) // by main thread
321 {
322  CStdLock AALock(&AutoAcceptCSec);
323  // create
324  AutoAccept *pAcc = new AutoAccept();
325  pAcc->CCore = CCore;
326  // add
327  pAcc->Next = pAutoAcceptList;
328  pAutoAcceptList = pAcc;
329 }
330 
331 void C4Network2IO::RemoveAutoAccept(const C4ClientCore &CCore) // by main thread
332 {
333  CStdLock AALock(&AutoAcceptCSec);
334  // find & remove
335  AutoAccept *pAcc = pAutoAcceptList, *pLast = nullptr;
336  while (pAcc)
337  if (pAcc->CCore.getDiffLevel(CCore) <= C4ClientCoreDL_IDMatch)
338  {
339  // unlink
340  AutoAccept *pDelete = pAcc;
341  pAcc = pAcc->Next;
342  (pLast ? pLast->Next : pAutoAcceptList) = pAcc;
343  // delete
344  delete pDelete;
345  }
346  else
347  {
348  // next peer
349  pLast = pAcc;
350  pAcc = pAcc->Next;
351  }
352 }
353 
355 {
356  CStdLock ConnListLock(&ConnListCSec);
357  C4Network2IOConnection *pRes = nullptr;
358  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
359  if (pConn->isAccepted())
360  if (pConn->getClientID() == iClientID)
361  if (pConn->getProtocol() == P_UDP || !pRes)
362  pRes = pConn;
363  // add reference
364  if (pRes) pRes->AddRef();
365  return pRes;
366 }
367 
369 {
370  CStdLock ConnListLock(&ConnListCSec);
371  C4Network2IOConnection *pRes = nullptr;
372  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
373  if (pConn->isAccepted())
374  if (pConn->getClientID() == iClientID)
375  if (pConn->getProtocol() == P_TCP || !pRes)
376  pRes = pConn;
377  // add reference
378  if (pRes) pRes->AddRef();
379  return pRes;
380 }
381 
382 void C4Network2IO::BeginBroadcast(bool fSelectAll)
383 {
384  // lock
386  // reset all broadcast flags
387  CStdLock ConnListLock(&ConnListCSec);
388  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
389  if (pConn->isOpen())
390  pConn->SetBroadcastTarget(fSelectAll);
391 }
392 
394 {
395  // unlock
397 }
398 
400 {
401  bool fSuccess = true;
402  // There is no broadcasting atm, emulate it
403  CStdLock ConnListLock(&ConnListCSec);
404  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
405  if (pConn->isOpen() && pConn->isBroadcastTarget())
406  fSuccess &= pConn->Send(rPkt);
407  if(!fSuccess)
408  Log("Network: Warning! Broadcast failed.");
409  return fSuccess;
410 }
411 
412 bool C4Network2IO::SendMsgToClient(C4NetIOPacket &rPkt, int iClient) // by both
413 {
414  // find msg connection
415  C4Network2IOConnection *pConn = GetMsgConnection(iClient);
416  if (!pConn) return false;
417  // send
418  bool fSuccess = pConn->Send(rPkt);
419  pConn->DelRef();
420  return fSuccess;
421 }
422 
423 bool C4Network2IO::BroadcastMsg(const C4NetIOPacket &rPkt) // by both
424 {
425  // TODO: ugly algorithm. do better
426 
427  // begin broadcast
428  BeginBroadcast(false);
429  // select one connection per reachable client
430  CStdLock ConnListLock(&ConnListCSec);
431  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
432  if (pConn->isAccepted())
433  {
434  if (pConn->getProtocol() == P_UDP)
435  pConn->SetBroadcastTarget(true);
436  else if (pConn->getProtocol() == P_TCP)
437  {
438  C4Network2IOConnection *pConn2 = GetMsgConnection(pConn->getClientID());
439  if (pConn == pConn2)
440  pConn->SetBroadcastTarget(true);
441  pConn2->DelRef();
442  }
443  }
444  // send
445  bool fSuccess = Broadcast(rPkt);
446  // end broadcast
447  EndBroadcast();
448  // return
449  return fSuccess;
450 }
451 
453 {
454  // UDP must be initialized
455  if (!pNetIO_UDP)
456  return false;
457  // save address
458  switch (nPuncherAddr.GetFamily())
459  {
461  PuncherAddrIPv4 = nPuncherAddr;
462  break;
464  PuncherAddrIPv6 = nPuncherAddr;
465  break;
467  assert(!"Unexpected address family");
468  }
469  // let's punch
470  return pNetIO_UDP->Connect(nPuncherAddr);
471 }
472 
473 void C4Network2IO::Punch(const C4NetIO::addr_t &punchee_addr)
474 {
475  if (!pNetIO_UDP)
476  return;
477  C4PacketPing PktPeng;
478  dynamic_cast<C4NetIOUDP*>(pNetIO_UDP)->SendDirect(MkC4NetIOPacket(PID_Pong, PktPeng, punchee_addr));
479 }
480 
482 {
483  if (!pNetIO_UDP) return;
486  else if (family == C4NetIO::HostAddress::IPv6 && !PuncherAddrIPv6.IsNull())
488 }
489 
491 {
492  return (!PuncherAddrIPv4.IsNull() && PuncherAddrIPv4 == addr)
493  || (!PuncherAddrIPv6.IsNull() && PuncherAddrIPv6 == addr);
494 }
495 
496 // C4NetIO interface
497 bool C4Network2IO::OnConn(const C4NetIO::addr_t &PeerAddr, const C4NetIO::addr_t &ConnectAddr, const C4NetIO::addr_t *pOwnAddr, C4NetIO *pNetIO)
498 {
499  // puncher answer?
500  if (pNetIO == pNetIO_UDP && IsPuncherAddr(ConnectAddr))
501  {
502  // got an address?
503  if (pOwnAddr)
504  ::Network.OnPuncherConnect(*pOwnAddr);
505  return true;
506  }
507 
508 #if(C4NET2IO_DUMP_LEVEL > 1)
509  Application.InteractiveThread.ThreadLogS("OnConn: %s %s",
510  C4TimeMilliseconds::Now().AsString().getData(),
511  getNetIOName(pNetIO));
512 #endif
513  // search connection
514  C4Network2IOConnection *pConn = nullptr;
515  if (!ConnectAddr.IsNull())
516  pConn = GetConnectionByConnAddr(ConnectAddr, pNetIO);
517  // not found?
518  if (!pConn)
519  {
520  // allow connect?
521  if (!fAllowConnect) return false;
522  // create new connection object
523  uint32_t iConnID = iNextConnID++;
524  pConn = new C4Network2IOConnection();
525  pConn->Set(pNetIO, getNetIOProt(pNetIO), PeerAddr, ConnectAddr, CS_Connected, nullptr, iConnID);
526  // add to list
527  AddConnection(pConn);
528  }
529  else
530  {
531  // already closed this connection (attempt)?
532  if (pConn->isClosed())
533  return false;
534  if (!pConn->isOpen())
535  {
536  // change status
537  pConn->SetStatus(CS_Connected);
538  pConn->SetPeerAddr(PeerAddr);
539  }
540  }
541  // send welcome packet, if appropriate
542  SendConnPackets();
543 #if(C4NET2IO_DUMP_LEVEL > 0)
544  // log
545  Application.InteractiveThread.ThreadLogS("Network: got %s connection from %s", getNetIOName(pNetIO), PeerAddr.ToString().getData());
546 #endif
547  // do event (disabled - unused)
548  // pConn->AddRef(); PushNetEv(NE_Conn, pConn);
549  // ok
550  return true;
551 }
552 
553 void C4Network2IO::OnDisconn(const C4NetIO::addr_t &addr, C4NetIO *pNetIO, const char *szReason)
554 {
555  // punch?
556  if (pNetIO == pNetIO_UDP && IsPuncherAddr(addr))
557  {
558  if (PuncherAddrIPv4 == addr)
560  else
562  return;
563  }
564 #if(C4NET2IO_DUMP_LEVEL > 1)
565  Application.InteractiveThread.ThreadLogS("OnDisconn: %s %s",
566  C4TimeMilliseconds::Now().AsString().getData(),
567  getNetIOName(pNetIO));
568 #endif
569  // find connection
570  C4Network2IOConnection *pConn = GetConnection(addr, pNetIO);
571  if (!pConn) pConn = GetConnectionByConnAddr(addr, pNetIO);
572  if (!pConn) return;
573 #if(C4NET2IO_DUMP_LEVEL > 0)
574  // log
575  Application.InteractiveThread.ThreadLogS("Network: %s connection to %s %s (%s)",
576  getNetIOName(pNetIO), addr.ToString().getData(), pConn->isConnecting() ? "failed" : "closed" , szReason);
577 #endif
578  // already closed? ignore
579  if (!pConn->isClosed())
580  // not accepted yet? count as connection failure
581  pConn->SetStatus(pConn->isHalfAccepted() ? CS_Closed : CS_ConnectFail);
582  // keep connection for main thread message
583  pConn->AddRef();
584  // check for pending welcome packets
585  SendConnPackets();
586  // signal to main thread
588  // don't remove connection from list - wait for postmortem or timeout
589 }
590 
591 void C4Network2IO::OnPacket(const class C4NetIOPacket &rPacket, C4NetIO *pNetIO)
592 {
593 #if C4NET2IO_DUMP_LEVEL > 1
594  auto tTime = C4TimeMilliseconds::Now();
595 #endif
596 #if(C4NET2IO_DUMP_LEVEL > 1)
597  Application.InteractiveThread.ThreadLogS("OnPacket: %s status %02x %s",
598  C4TimeMilliseconds::Now().AsString().getData(),
599  rPacket.getStatus(), getNetIOName(pNetIO));
600 #endif
601  if (pNetIO == pNetIO_UDP && IsPuncherAddr(rPacket.getAddr()))
602  {
603  HandlePuncherPacket(rPacket);
604  return;
605  }
606  if (!rPacket.getSize()) return;
607  // find connection
608  C4Network2IOConnection *pConn = GetConnection(rPacket.getAddr(), pNetIO);
609  if (!pConn)
610  {
611  Application.InteractiveThread.ThreadLog("Network: could not find connection for %s packet (status %02x) from %s!", getNetIOName(pNetIO), rPacket.getStatus(), rPacket.getAddr().ToString().getData());
612  return;
613  }
614 #if(C4NET2IO_DUMP_LEVEL > 2)
615  uint32_t iFindConnectionBlocked = C4TimeMilliseconds::Now() - tTime;
616  if (iFindConnectionBlocked > 100)
617  Application.InteractiveThread.ThreadLogS("OnPacket: ... blocked %d ms for finding the connection!", iFindConnectionBlocked);
618 #endif
619  // notify
620  pConn->OnPacketReceived(rPacket.getStatus());
621  // handle packet
622  HandlePacket(rPacket, pConn, true);
623  // log time
624 #if(C4NET2IO_DUMP_LEVEL > 1)
625  uint32_t iHandlingBlocked = C4TimeMilliseconds::Now() - tTime;
626  if (iHandlingBlocked > 100)
627  Application.InteractiveThread.ThreadLogS("OnPacket: ... blocked %d ms for handling!", iHandlingBlocked);
628 #endif
629 }
630 
631 void C4Network2IO::OnError(const char *strError, C4NetIO *pNetIO)
632 {
633  // let's log it
634  Application.InteractiveThread.ThreadLog("Network: %s error: %s", getNetIOName(pNetIO), strError);
635 }
636 
637 bool C4Network2IO::Execute(int iTimeout, pollfd *)
638 {
640 
641  // check for timeout
642  CheckTimeout();
643 
644  // ping all open connections
646  {
647  Ping();
649  }
650 
651  // do statistics
653  {
656  }
657 
658  // resources
660 
661  // ok
662  return true;
663 }
664 
666 {
667  return tLastExecute + C4NetTimer;
668 }
669 
670 void C4Network2IO::OnThreadEvent(C4InteractiveEventType eEvent, void *pEventData) // by main thread
671 {
672  switch (eEvent)
673  {
674  case Ev_Net_Conn: // got a connection
675  {
676  C4Network2IOConnection *pConn = reinterpret_cast<C4Network2IOConnection *>(pEventData);
677  // do callback
678  ::Network.OnConn(pConn);
679  // remove reference
680  pConn->DelRef();
681  }
682  break;
683 
684  case Ev_Net_Disconn: // connection closed
685  {
686  C4Network2IOConnection *pConn = reinterpret_cast<C4Network2IOConnection *>(pEventData);
687  assert(pConn->isClosed());
688  // do callback
689  ::Network.OnDisconn(pConn);
690  // remove reference
691  pConn->DelRef();
692  }
693  break;
694 
695  case Ev_Net_Packet: // got packet
696  {
697  NetEvPacketData *pData = reinterpret_cast<NetEvPacketData *>(pEventData);
698  // handle
699  HandlePacket(pData->Packet, pData->Conn, false);
700  // clear up
701  pData->Conn->DelRef();
702  delete pData;
703  }
704  break;
705 
706  default:
707  // TODO
708  break;
709  }
710 }
711 
713 {
714  switch (eProt)
715  {
716  case P_UDP: return pNetIO_UDP;
717  case P_TCP: return pNetIO_TCP;
718  default: return nullptr;
719  }
720 }
721 
723 {
724  if (!pNetIO) return "nullptr";
725  if (pNetIO == pNetIO_TCP) return "TCP";
726  if (pNetIO == pNetIO_UDP) return "UDP";
727  return "UNKNOWN";
728 }
729 
731 {
732  if (!pNetIO) return P_NONE;
733  if (pNetIO == pNetIO_TCP) return P_TCP;
734  if (pNetIO == pNetIO_UDP) return P_UDP;
735  return P_NONE;
736 }
737 
739 {
740  CStdLock ConnListLock(&ConnListCSec);
741  // add reference
742  pConn->AddRef();
743  // add to list
744  pConn->pNext = pConnList; pConnList = pConn;
745 }
746 
748 {
749  CStdLock ConnListLock(&ConnListCSec);
750  // search & remove
751  if (pConnList == pConn)
752  pConnList = pConn->pNext;
753  else
754  {
756  for (pAct = pConnList; pAct; pAct = pAct->pNext)
757  if (pAct->pNext == pConn)
758  break;
759  if (pAct)
760  pAct->pNext = pConn->pNext;
761  else
762  return;
763  }
764  // remove reference
765  pConn->pNext = nullptr; pConn->DelRef();
766 }
767 
769 {
770  CStdLock ConnListLock(&ConnListCSec);
771  // search
772  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
773  if (pConn->getNetClass() == pNetIO && pConn->getPeerAddr() == addr)
774  return pConn;
775  return nullptr;
776 }
777 
779 {
780  CStdLock ConnListLock(&ConnListCSec);
781  // search
782  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
783  if (pConn->getNetClass() == pNetIO && pConn->getConnectAddr() == addr)
784  return pConn;
785  return nullptr;
786 }
787 
789 {
790  CStdLock ConnListLock(&ConnListCSec);
791  // search
792  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
793  if (pConn->getID() == iConnID)
794  return pConn;
795  return nullptr;
796 }
797 
799 {
800  if (pRefServer)
801  pRefServer->SetReference(pReference);
802  else
803  delete pReference;
804 }
805 
807 {
808  return !!pRefServer;
809 }
810 
812 {
813  CStdLock AALock(&AutoAcceptCSec);
814  // check if connection with the given client should be allowed
815  for (AutoAccept *pAcc = pAutoAcceptList; pAcc; pAcc = pAcc->Next)
816  // core match?
817  if (CCore.getDiffLevel(pAcc->CCore) <= C4ClientCoreDL_IDMatch)
818  {
819  // check: already got another connection for this client? Peer IP must match, then.
820  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
821  if (pConn->isAccepted() &&
822  pConn->getCCore().getDiffLevel(CCore) <= C4ClientCoreDL_IDMatch &&
823  pConn->getPeerAddr().GetHost() != Conn.getPeerAddr().GetHost())
824  return false;
825  // not found or IP matches? Let pass
826  return true;
827  }
828  return false;
829 }
830 
831 bool C4Network2IO::HandlePacket(const C4NetIOPacket &rPacket, C4Network2IOConnection *pConn, bool fThread)
832 {
833  // security: add connection reference
834  if (!pConn) return false;
835  pConn->AddRef();
836 
837  // accept only PID_Conn and PID_Ping on non-accepted connections
838  if(!pConn->isHalfAccepted())
839  if(rPacket.getStatus() != PID_Conn && rPacket.getStatus() != PID_Ping && rPacket.getStatus() != PID_ConnRe)
840  return false;
841 
842  // unpack packet (yet another no-idea-why-it's-needed-cast)
843  C4IDPacket Pkt; C4PacketBase &PktB = Pkt;
844  try
845  {
846  PktB.unpack(rPacket);
847  }
848  catch (StdCompiler::Exception *pExc)
849  {
850  Application.InteractiveThread.ThreadLog("Network: error: Failed to unpack packet id %02x: %s", rPacket.getStatus(), pExc->Msg.getData());
851  delete pExc;
852 #ifndef _DEBUG
853  pConn->Close();
854 #endif
855  return false;
856  }
857 
858  // dump packet (network thread only)
859 #if(C4NET2IO_DUMP_LEVEL > 0)
860  if (Config.Network.PacketLogging && fThread && Pkt.getPktType() != PID_Ping && Pkt.getPktType() != PID_Pong && Pkt.getPktType() != PID_NetResData)
861  {
862  // StdStrBuf PacketDump = DecompileToBuf<StdCompilerINIWrite>(mkNamingAdaptrPacket);
863  StdStrBuf PacketHeader = FormatString("HandlePacket: %s by %s (%lu bytes, counter %d)",
864  C4TimeMilliseconds::Now().AsString().getData(),
865  pConn->getPeerAddr().ToString().getData(),
866  static_cast<unsigned long>(rPacket.getSize()), pConn->getInPacketCounter());
867  StdStrBuf Dump = DecompileToBuf<StdCompilerINIWrite>(mkNamingAdapt(Pkt, PacketHeader.getData()));
868  // Put it directly. The standard functions behind StdBuf.Format seem to choke when you pass them too much data.
870  }
871 #endif
872 
873  // search packet handling data
874  bool fSendToMainThread = false, fHandled = false;
875  for (const C4PktHandlingData *pHData = PktHandlingData; pHData->ID != PID_None; pHData++)
876  if (pHData->ID == rPacket.getStatus())
877  {
878  // correct thread?
879  if (!pHData->ProcByThread == !fThread)
880  {
881  // connection accepted?
882  if (pHData->AcceptedOnly || pConn->isAccepted() || pConn->isClosed())
883  {
884  fHandled = true;
885 #if(C4NET2IO_DUMP_LEVEL > 2)
887 #endif
888 
889  // call handler(s)
890  CallHandlers(pHData->HandlerID, &Pkt, pConn, fThread);
891 
892 #if(C4NET2IO_DUMP_LEVEL > 2)
893  uint32_t iBlockedTime = C4TimeMilliseconds::Now() - tStart;
894  if (fThread && iBlockedTime > 100)
895  {
896  Application.InteractiveThread.ThreadLogS("HandlePacket: ... blocked for %u ms!", iBlockedTime);
897  }
898 #endif
899 
900  }
901  }
902  // transfer to main thread?
903  else if (!pHData->ProcByThread && fThread)
904  {
905  fHandled = true;
906  fSendToMainThread = true;
907  }
908  }
909 
910  // send to main thread?
911  if (fSendToMainThread)
912  {
913  // create data
914  NetEvPacketData *pEvData = new NetEvPacketData;
915  pEvData->Packet.Take(rPacket.Duplicate());
916  pEvData->Conn = pConn; pConn->AddRef();
917  // trigger event
919  Application.InteractiveThread.ThreadLogS("...push event ");
920  }
921 
922  // unhandled?
923  if (!fHandled && !pConn->isClosed())
924  Application.InteractiveThread.ThreadLog("Network: Unhandled packet (status %02x)", rPacket.getStatus());
925 
926  // remove connection reference
927  pConn->DelRef();
928  return fHandled;
929 }
930 
931 void C4Network2IO::CallHandlers(int iHandlerID, const C4IDPacket *pPkt, C4Network2IOConnection *pConn, bool fThread)
932 {
933  // emulate old callbacks
934  char cStatus = pPkt->getPktType();
935  const C4PacketBase *pPacket = pPkt->getPkt();
936  // this class (network thread)
937  if (iHandlerID & PH_C4Network2IO)
938  {
939  assert(fThread);
940  HandlePacket(cStatus, pPacket, pConn);
941  }
942  // main network class (main thread)
943  if (iHandlerID & PH_C4Network2)
944  {
945  assert(!fThread);
946  ::Network.HandlePacket(cStatus, pPacket, pConn);
947  }
948  // fullscreen lobby
949  if (iHandlerID & PH_C4GUIMainDlg)
950  {
951  assert(!fThread);
952  ::Network.HandleLobbyPacket(cStatus, pPacket, pConn);
953  }
954  // client list class (main thread)
955  if (iHandlerID & PH_C4Network2ClientList)
956  {
957  assert(!fThread);
958  ::Network.Clients.HandlePacket(cStatus, pPacket, pConn);
959  }
960  // player list class (main thread)
961  if (iHandlerID & PH_C4Network2Players)
962  {
963  assert(!fThread);
964  ::Network.Players.HandlePacket(cStatus, pPacket, pConn);
965  }
966  // resource list class (network thread)
967  if (iHandlerID & PH_C4Network2ResList)
968  {
969  assert(fThread);
970  ::Network.ResList.HandlePacket(cStatus, pPacket, pConn);
971  }
972  // network control (mixed)
973  if (iHandlerID & PH_C4GameControlNetwork)
974  {
975  ::Control.Network.HandlePacket(cStatus, pPacket, pConn);
976  }
977 }
978 
979 void C4Network2IO::HandlePacket(char cStatus, const C4PacketBase *pPacket, C4Network2IOConnection *pConn)
980 {
981  // security
982  if (!pConn) return;
983 
984 #define GETPKT(type, name) \
985  assert(pPacket); const type &name = \
986  static_cast<const type &>(*pPacket);
987 
988  switch (cStatus)
989  {
990 
991  case PID_Conn: // connection request
992  {
993  if (!pConn->isOpen()) break;
994  // get packet
995  GETPKT(C4PacketConn, rPkt)
996  // set connection ID
997  pConn->SetRemoteID(rPkt.getConnID());
998  // check auto-accept
999  if (doAutoAccept(rPkt.getCCore(), *pConn))
1000  {
1001  // send answer back
1002  C4PacketConnRe pcr(true, false, "auto accept");
1003  if (!pConn->Send(MkC4NetIOPacket(PID_ConnRe, pcr)))
1004  pConn->Close();
1005  // accept
1006  pConn->SetStatus(CS_HalfAccepted);
1007  pConn->SetCCore(rPkt.getCCore());
1008  pConn->SetAutoAccepted();
1009  }
1010  // note that this packet will get processed by C4Network2, too (main thread)
1011  }
1012  break;
1013 
1014  case PID_ConnRe: // connection request reply
1015  {
1016  if (!pConn->isOpen()) break;
1017  // conn not sent? That's fishy.
1018  // FIXME: Note this happens if the peer has exclusive connection mode on.
1019  if (!pConn->isConnSent())
1020  {
1021  pConn->Close();
1022  break;
1023  }
1024  // get packet
1025  GETPKT(C4PacketConnRe, rPkt)
1026  // auto accept connection
1027  if (rPkt.isOK())
1028  {
1029  if (pConn->isHalfAccepted() && pConn->isAutoAccepted())
1030  pConn->SetAccepted();
1031  }
1032  }
1033  break;
1034 
1035  case PID_Ping:
1036  {
1037  if (!pConn->isOpen()) break;
1038  GETPKT(C4PacketPing, rPkt)
1039  // pong
1040  C4PacketPing PktPong = rPkt;
1041  pConn->Send(MkC4NetIOPacket(PID_Pong, PktPong));
1042  // remove received packets from log
1043  pConn->ClearPacketLog(rPkt.getPacketCounter());
1044  }
1045  break;
1046 
1047  case PID_Pong:
1048  {
1049  if (!pConn->isOpen()) break;
1050  GETPKT(C4PacketPing, rPkt);
1051  // save
1052  pConn->SetPingTime(rPkt.getTravelTime());
1053  }
1054  break;
1055 
1056  case PID_FwdReq:
1057  {
1058  GETPKT(C4PacketFwd, rPkt);
1059  HandleFwdReq(rPkt, pConn);
1060  }
1061  break;
1062 
1063  case PID_Fwd:
1064  {
1065  GETPKT(C4PacketFwd, rPkt);
1066  // only received accidently?
1067  if (!rPkt.DoFwdTo(LCCore.getID())) break;
1068  // handle
1069  C4NetIOPacket Packet(rPkt.getData(), pConn->getPeerAddr());
1070  HandlePacket(Packet, pConn, true);
1071  }
1072  break;
1073 
1074  case PID_PostMortem:
1075  {
1076  GETPKT(C4PacketPostMortem, rPkt);
1077  // Get connection
1078  C4Network2IOConnection *pConn = GetConnectionByID(rPkt.getConnID());
1079  if (!pConn) return;
1080  // Handle all packets
1081  uint32_t iCounter;
1082  for (iCounter = pConn->getInPacketCounter(); ; iCounter++)
1083  {
1084  // Get packet
1085  const C4NetIOPacket *pPkt = rPkt.getPacket(iCounter);
1086  if (!pPkt) break;
1087  // Handle it
1088  HandlePacket(*pPkt, pConn, true);
1089  }
1090  // Log
1091  if (iCounter > pConn->getInPacketCounter())
1092  Application.InteractiveThread.ThreadLogS("Network: Recovered %d packets", iCounter - pConn->getInPacketCounter());
1093  // Remove the connection from our list
1094  if (!pConn->isClosed())
1095  pConn->Close();
1096  RemoveConnection(pConn);
1097  }
1098  break;
1099 
1100  }
1101 
1102 #undef GETPKT
1103 }
1104 
1106 {
1107  CStdLock ConnListLock(&ConnListCSec);
1108  // init packet
1109  C4PacketFwd nFwd;
1110  nFwd.SetListType(false);
1111  // find all clients the message should be forwarded to
1112  int iClientID; C4Network2IOConnection *pConn;
1113  for (pConn = pConnList; pConn; pConn = pConn->pNext)
1114  if (pConn->isAccepted())
1115  if ((iClientID = pConn->getClientID()) >= 0)
1116  if (iClientID != pBy->getClientID())
1117  if (rFwd.DoFwdTo(iClientID) && !nFwd.DoFwdTo(iClientID))
1118  nFwd.AddClient(iClientID);
1119  // check count (hardcoded: broadcast for > 2 clients)
1120  if (nFwd.getClientCnt() <= 2)
1121  {
1122  C4NetIOPacket Pkt(rFwd.getData(), C4NetIO::addr_t());
1123  for (int i = 0; i < nFwd.getClientCnt(); i++)
1124  if ((pConn = GetMsgConnection(nFwd.getClient(i))))
1125  {
1126  pConn->Send(Pkt);
1127  pConn->DelRef();
1128  }
1129  }
1130  else
1131  {
1132  // Temporarily unlock connection list for getting broadcast lock
1133  // (might lead to deathlocks otherwise, as the lock is often taken
1134  // in the opposite order)
1135  ConnListLock.Clear();
1136 
1137  BeginBroadcast();
1138  nFwd.SetData(rFwd.getData());
1139  // add all clients
1140  CStdLock ConnListLock(&ConnListCSec);
1141  for (int i = 0; i < nFwd.getClientCnt(); i++)
1142  if ((pConn = GetMsgConnection(nFwd.getClient(i))))
1143  {
1144  pConn->SetBroadcastTarget(true);
1145  pConn->DelRef();
1146  }
1147  // broadcast
1149  EndBroadcast();
1150  }
1151  // doing a callback here; don't lock!
1152  ConnListLock.Clear();
1153  // forward to self?
1154  if (rFwd.DoFwdTo(LCCore.getID()))
1155  {
1156  C4NetIOPacket Packet(rFwd.getData(), pBy->getPeerAddr());
1157  HandlePacket(Packet, pBy, true);
1158  }
1159 }
1160 
1162 {
1163  auto pkt = C4NetpuncherPacket::Construct(rPacket);
1164  if (pkt && ::Network.HandlePuncherPacket(move(pkt), rPacket.getAddr().GetFamily()));
1165  else
1166  {
1167  assert(pNetIO_UDP);
1168  pNetIO_UDP->Close(rPacket.getAddr());
1169  }
1170 }
1171 
1173 {
1174  bool fSuccess = true;
1175  // ping all connections
1176  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
1177  if (pConn->isOpen())
1178  {
1179  C4PacketPing Ping(pConn->getInPacketCounter(), pConn->getOutPacketCounter());
1180  fSuccess &= pConn->Send(MkC4NetIOPacket(PID_Ping, Ping));
1181  pConn->OnPing();
1182  }
1183  return fSuccess;
1184 }
1185 
1187 {
1188  // acquire lock
1189  CStdLock ConnListLock(&ConnListCSec);
1190  // check all connections for timeout (use deletion-safe iteration method just in case)
1191  for (C4Network2IOConnection *pConn = pConnList, *pNext; pConn; pConn = pNext)
1192  {
1193  pNext = pConn->pNext;
1194  // status timeout
1195  if (!pConn->isClosed() && !pConn->isAccepted())
1196  if (difftime(time(nullptr), pConn->getTimestamp()) > C4NetAcceptTimeout)
1197  {
1198  Application.InteractiveThread.ThreadLogS("Network: connection accept timeout to %s", pConn->getPeerAddr().ToString().getData());
1199  pConn->Close();
1200  }
1201  // ping timeout
1202  if (pConn->isAccepted())
1203  if ((pConn->getLag() != -1 ? pConn->getLag() : 1000 * difftime(time(nullptr), pConn->getTimestamp()))
1204  > C4NetPingTimeout)
1205  {
1206  Application.InteractiveThread.ThreadLogS("%d %d %d", (int)pConn->getLag(), (int)time(nullptr), (int)pConn->getTimestamp());
1207  Application.InteractiveThread.ThreadLogS("Network: ping timeout to %s", pConn->getPeerAddr().ToString().getData());
1208  pConn->Close();
1209  }
1210  // delayed connection removal
1211  if (pConn->isClosed())
1212  if (difftime(time(nullptr), pConn->getTimestamp()) > C4NetAcceptTimeout)
1213  RemoveConnection(pConn);
1214  }
1215 }
1216 
1218 {
1219  int iTCPIRateSum = 0, iTCPORateSum = 0, iUDPIRateSum = 0, iUDPORateSum = 0;
1220 
1221  // acquire lock, get connection statistics
1222  CStdLock ConnListLock(&ConnListCSec);
1223  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
1224  if (pConn->isOpen())
1225  {
1226  bool fTCP = pConn->getNetClass() == pNetIO_TCP;
1227  pConn->DoStatistics(iInterval, fTCP ? &iTCPIRateSum : &iUDPIRateSum,
1228  fTCP ? &iTCPORateSum : &iUDPORateSum);
1229  }
1230  ConnListLock.Clear();
1231 
1232  // get broadcast statistics
1233  int inTCPBCRate = 0, inUDPBCRate = 0;
1234  if (pNetIO_TCP) pNetIO_TCP->GetStatistic(&inTCPBCRate);
1235  if (pNetIO_UDP) pNetIO_UDP->GetStatistic(&inUDPBCRate);
1236 
1237  // normalize everything
1238  iTCPIRateSum = iTCPIRateSum * 1000 / iInterval;
1239  iTCPORateSum = iTCPORateSum * 1000 / iInterval;
1240  iUDPIRateSum = iUDPIRateSum * 1000 / iInterval;
1241  iUDPORateSum = iUDPORateSum * 1000 / iInterval;
1242  inTCPBCRate = inTCPBCRate * 1000 / iInterval;
1243  inUDPBCRate = inUDPBCRate * 1000 / iInterval;
1244 
1245  // clear
1248 
1249  // save back
1250  iTCPIRate = iTCPIRateSum; iTCPORate = iTCPORateSum; iTCPBCRate = inTCPBCRate;
1251  iUDPIRate = iUDPIRateSum; iUDPORate = iUDPORateSum; iUDPBCRate = inUDPBCRate;
1252 }
1253 
1255 {
1256  CStdLock ConnListLock(&ConnListCSec);
1257 
1258  // exlusive conn?
1259  if (fExclusiveConn)
1260  // find a live connection
1261  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
1262  if (pConn->isAccepted() || (!pConn->isClosed() && pConn->isConnSent()))
1263  // do not sent additional conn packets - no other connection should succeed
1264  return;
1265 
1266  // sent pending welcome packet(s)
1267  for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
1268  if (pConn->isOpen() && !pConn->isConnSent())
1269  {
1270  // make packet
1271  CStdLock LCCoreLock(&LCCoreCSec);
1272  C4NetIOPacket Pkt = MkC4NetIOPacket(PID_Conn, C4PacketConn(LCCore, pConn->getID(), pConn->getPassword()));
1273  LCCoreLock.Clear();
1274  // send
1275  if (!pConn->Send(Pkt))
1276  pConn->Close();
1277  else
1278  {
1279  // set flag
1280  pConn->SetConnSent();
1281  // only one conn packet at a time
1282  if (fExclusiveConn)
1283  return;
1284  }
1285  }
1286 
1287 }
1288 
1289 // *** C4Network2IOConnection
1290 
1292  : iID(~0), iRemoteID(~0),
1293 
1294  tLastPing(C4TimeMilliseconds::NegativeInfinity),
1295  tLastPong(C4TimeMilliseconds::NegativeInfinity),
1296 
1297  iRefCnt(0)
1298 {
1299 }
1300 
1302 {
1303  assert(!iRefCnt);
1304  // connection needs to be closed?
1305  if (pNetClass && !isClosed()) Close();
1306  // clear the packet log
1307  ClearPacketLog();
1308 }
1309 
1311 {
1312  if (iPingTime != -1)
1313  {
1314  // Last ping not answered yet?
1315  if(tLastPing > tLastPong)
1316  {
1317  int iPingLag = C4TimeMilliseconds::Now() - tLastPing;
1318  // Use it for lag measurement once it's larger then the last ping time
1319  // (the ping time won't be better than this anyway once the pong's here)
1320  return std::max(iPingLag, iPingTime);
1321  }
1322  }
1323  // Last ping result
1324  return iPingTime;
1325 }
1326 
1327 void C4Network2IOConnection::Set(C4NetIO *pnNetClass, C4Network2IOProtocol enProt, const C4NetIO::addr_t &nPeerAddr, const C4NetIO::addr_t &nConnectAddr, C4Network2IOConnStatus nStatus, const char *szPassword, uint32_t inID)
1328 {
1329  // save data
1330  pNetClass = pnNetClass; eProt = enProt;
1331  PeerAddr = nPeerAddr; ConnectAddr = nConnectAddr;
1332  Status = nStatus;
1333  Password = szPassword;
1334  iID = inID;
1335  // initialize
1336  fBroadcastTarget = false;
1337  iTimestamp = time(nullptr); iPingTime = -1;
1338 }
1339 
1340 void C4Network2IOConnection::SetSocket(std::unique_ptr<C4NetIOTCP::Socket> socket)
1341 {
1342  TcpSimOpenSocket = std::move(socket);
1343 }
1344 
1345 void C4Network2IOConnection::SetRemoteID(uint32_t inRemoteID)
1346 {
1347  iRemoteID = inRemoteID;
1348 }
1349 
1351 {
1352  // just do it
1353  PeerAddr = nPeerAddr;
1354 }
1355 
1357 {
1358  // Still no pong for the last ping?
1359  if (tLastPong < tLastPing)
1360  return;
1361 
1362  // Save time
1364 }
1365 
1367 {
1368  // save it
1369  iPingTime = inPingTime;
1370  // pong received - save timestamp
1372 }
1373 
1375 {
1376  if (nStatus != Status)
1377  {
1378  // Connection can't return from these
1379  assert(!isClosed());
1380  // set status
1381  Status = nStatus;
1382  // reset timestamp for connect/accept/close
1384  iTimestamp = time(nullptr);
1385  }
1386 }
1387 
1389 {
1390  fAutoAccept = true;
1391 }
1392 
1394 {
1395  // Just count them
1396  if (iPacketType >= PID_PacketLogStart)
1397  iInPacketCounter++;
1398 }
1399 
1401 {
1402  // Search position of first packet to delete
1403  PacketLogEntry *pPos, *pPrev = nullptr;
1404  for (pPos = pPacketLog; pPos; pPrev = pPos, pPos = pPos->Next)
1405  if (pPos->Number < iUntilID)
1406  break;
1407  if (pPos)
1408  {
1409  // Remove packets from list
1410  (pPrev ? pPrev->Next : pPacketLog) = nullptr;
1411  // Delete everything
1412  while (pPos)
1413  {
1414  PacketLogEntry *pDelete = pPos;
1415  pPos = pPos->Next;
1416  delete pDelete;
1417  }
1418  }
1419 }
1420 
1422 {
1423  // Security
1424  if (!pPkt) return false;
1425  CStdLock PacketLogLock(&PacketLogCSec);
1426  // Nothing to do?
1427  if (!pPacketLog) return false;
1428  // Already created?
1429  if (fPostMortemSent) return false;
1430  // Set connection ID and packet counter
1431  pPkt->SetConnID(iRemoteID);
1433  // Add packets
1434  for (PacketLogEntry *pEntry = pPacketLog; pEntry; pEntry = pEntry->Next)
1435  pPkt->Add(pEntry->Pkt);
1436  // Okay
1437  fPostMortemSent = true;
1438  return true;
1439 }
1440 
1442 {
1443  CStdLock CCoreLock(&CCoreCSec);
1444  CCore = nCCore;
1445 }
1446 
1448 {
1449  if (!pNetClass) return false;
1450  if (TcpSimOpenSocket)
1451  {
1452  auto pNetTCP = dynamic_cast<C4NetIOTCP*>(pNetClass);
1453  return pNetTCP->Connect(ConnectAddr, std::move(TcpSimOpenSocket));
1454  }
1455  // try connect
1456  return pNetClass->Connect(ConnectAddr);
1457 }
1458 
1460 {
1461  if (!pNetClass || isClosed()) return;
1462  // set status
1464  // close
1466 }
1467 
1469 {
1470  // some packets shouldn't go into the log
1471  if (rPkt.getStatus() < PID_PacketLogStart)
1472  {
1473  assert(isOpen());
1474  C4NetIOPacket Copy(rPkt);
1475  Copy.SetAddr(PeerAddr);
1476  return pNetClass->Send(Copy);
1477  }
1478  CStdLock PacketLogLock(&PacketLogCSec);
1479  // create log entry
1480  PacketLogEntry *pLogEntry = new PacketLogEntry();
1481  pLogEntry->Number = iOutPacketCounter++;
1482  pLogEntry->Pkt = rPkt;
1483  pLogEntry->Next = pPacketLog;
1484  pPacketLog = pLogEntry;
1485  // set address
1486  pLogEntry->Pkt.SetAddr(PeerAddr);
1487  // closed? No sweat, post mortem will reroute it later.
1488  if (!isOpen())
1489  {
1490  // post mortem already sent? This shouldn't happen
1491  if (fPostMortemSent) { assert(false); return false; }
1492  // okay then
1493  return true;
1494  }
1495  // send
1496  bool fSuccess = pNetClass->Send(pLogEntry->Pkt);
1497  if (fSuccess)
1498  assert(!fPostMortemSent);
1499  else {
1500  // Not being able to send a packet is actually a big deal,
1501  // as this means that we will have hole in the packet
1502  // order. Better close the connection - post mortem should
1503  // ideally sort everything out from here.
1504  LogF("Network: Fatal: Send failed (%s)", pNetClass->GetError());
1505  pNetClass->ResetError();
1506  Close();
1507  }
1508  return fSuccess;
1509 }
1510 
1512 {
1513  // Note that each thread will have to make sure that this flag won't be
1514  // changed until Broadcast() is called. See C4Network2IO::BroadcastCSec.
1516  fBroadcastTarget = fSet;
1517 }
1518 
1519 void C4Network2IOConnection::DoStatistics(int iInterval, int *pIRateSum, int *pORateSum)
1520 {
1521  // get C4NetIO statistics
1522  int inIRate, inORate, inLoss;
1523  if (!isOpen() || !pNetClass->GetConnStatistic(PeerAddr, &inIRate, &inORate, &inLoss))
1524  {
1525  iIRate = iORate = iPacketLoss = 0;
1526  return;
1527  }
1528  // normalize
1529  inIRate = inIRate * 1000 / iInterval;
1530  inORate = inORate * 1000 / iInterval;
1531  // set
1532  iIRate = inIRate; iORate = inORate; iPacketLoss = inLoss;
1533  // sum up
1534  if (pIRateSum) *pIRateSum += iIRate;
1535  if (pORateSum) *pORateSum += iORate;
1536 }
1537 
1539 {
1540  ++iRefCnt;
1541 }
1542 
1544 {
1545  if (--iRefCnt == 0)
1546  delete this;
1547 }
1548 
1549 
1550 // *** C4PacketPostMortem
1551 
1553  : iConnID(~0),
1554  iPacketCounter(~0)
1555 {
1556 
1557 }
1558 
1560 {
1561  while (pPackets)
1562  {
1563  PacketLink *pDelete = pPackets;
1564  pPackets = pPackets->Next;
1565  delete pDelete;
1566  }
1567  iPacketCount = 0;
1568 }
1569 
1570 const C4NetIOPacket *C4PacketPostMortem::getPacket(uint32_t iNumber) const
1571 {
1572  // Security
1573  if (!Inside(iNumber, iPacketCounter - iPacketCount, iPacketCounter - 1))
1574  return nullptr;
1575  // Calculate position in list
1576  iNumber = iNumber + iPacketCount - iPacketCounter;
1577  // Search for the packet with the given number
1578  PacketLink *pLink = pPackets;
1579  for (; pLink && iNumber; iNumber--)
1580  pLink = pLink->Next;
1581  // Not found?
1582  return pLink ? &pLink->Pkt : nullptr;
1583 }
1584 
1585 void C4PacketPostMortem::SetPacketCounter(uint32_t inPacketCounter)
1586 {
1587  iPacketCounter = inPacketCounter;
1588 }
1589 
1591 {
1592  // Add to head of list (reverse order)
1593  PacketLink *pLink = new PacketLink();
1594  pLink->Pkt = rPkt;
1595  pLink->Next = pPackets;
1596  pPackets = pLink;
1597  iPacketCount++;
1598 }
1599 
1601 {
1602  bool deserializing = pComp->isDeserializer();
1603 
1604  // Connection ID, packet number and packet count
1605  pComp->Value(mkNamingAdapt(iConnID, "ConnID"));
1606  pComp->Value(mkNamingAdapt(iPacketCounter, "PacketCounter"));
1607  pComp->Value(mkNamingAdapt(iPacketCount, "PacketCount"));
1608 
1609  // Packets
1610  if (deserializing)
1611  {
1612  // Read packets
1613  for (uint32_t i = 0; i < iPacketCount; i++)
1614  {
1615  // Create list entry
1616  PacketLink *pLink = new PacketLink();
1617  pLink->Next = pPackets;
1618  pPackets = pLink;
1619  // Compile data
1620  pComp->Value(mkNamingAdapt(pLink->Pkt, "PacketData"));
1621  }
1622  // Reverse order
1623  PacketLink *pPackets2 = pPackets;
1624  pPackets = nullptr;
1625  while (pPackets2)
1626  {
1627  // Get link
1628  PacketLink *pLink = pPackets2;
1629  pPackets2 = pLink->Next;
1630  // Readd to list
1631  pLink->Next = pPackets;
1632  pPackets = pLink;
1633  }
1634  }
1635  else
1636  {
1637  // Write packets
1638  for (PacketLink *pLink = pPackets; pLink; pLink = pLink->Next)
1639  pComp->Value(mkNamingAdapt(pLink->Pkt, "PacketData"));
1640  }
1641 }
const int32_t C4ClientCoreDL_IDMatch
Definition: C4Client.h:30
C4Config Config
Definition: C4Config.cpp:930
C4GameControl Control
C4Application Application
Definition: C4Globals.cpp:44
C4Network2 Network
Definition: C4Globals.cpp:53
C4InteractiveEventType
@ Ev_Net_Conn
@ Ev_Net_Disconn
@ Ev_Net_Packet
@ Ev_LogSilent
bool Log(const char *szMessage)
Definition: C4Log.cpp:204
bool LogSilentF(const char *strMessage,...)
Definition: C4Log.cpp:272
bool LogF(const char *strMessage,...)
Definition: C4Log.cpp:262
bool LogFatal(const char *szMessage)
Definition: C4Log.cpp:239
#define GETPKT(type, name)
const int C4NetTimer
Definition: C4Network2IO.h:34
const int C4NetStatisticsFreq
Definition: C4Network2IO.h:36
C4Network2IOConnStatus
Definition: C4Network2IO.h:205
@ CS_Accepted
Definition: C4Network2IO.h:209
@ CS_Connect
Definition: C4Network2IO.h:206
@ CS_HalfAccepted
Definition: C4Network2IO.h:208
@ CS_ConnectFail
Definition: C4Network2IO.h:211
@ CS_Connected
Definition: C4Network2IO.h:207
@ CS_Closed
Definition: C4Network2IO.h:210
const int C4NetPingTimeout
Definition: C4Network2IO.h:38
const int C4NetAcceptTimeout
Definition: C4Network2IO.h:37
C4Network2IOProtocol
Definition: C4Network2IO.h:30
@ P_NONE
Definition: C4Network2IO.h:31
@ P_UDP
Definition: C4Network2IO.h:31
@ P_TCP
Definition: C4Network2IO.h:31
const int C4NetPingFreq
Definition: C4Network2IO.h:35
const C4PktHandlingData PktHandlingData[]
Definition: C4Packet2.cpp:50
C4NetIOPacket MkC4NetIOPacket(char cStatus, const class C4PacketBase &Pkt, const C4NetIO::addr_t &addr=C4NetIO::addr_t())
Definition: C4PacketBase.h:40
@ PID_PostMortem
Definition: C4PacketBase.h:96
@ PID_Conn
Definition: C4PacketBase.h:88
@ PID_Pong
Definition: C4PacketBase.h:85
@ PID_Fwd
Definition: C4PacketBase.h:93
@ PID_None
Definition: C4PacketBase.h:78
@ PID_FwdReq
Definition: C4PacketBase.h:92
@ PID_PacketLogStart
Definition: C4PacketBase.h:99
@ PID_Ping
Definition: C4PacketBase.h:84
@ PID_ConnRe
Definition: C4PacketBase.h:89
@ PID_NetResData
Definition: C4PacketBase.h:133
@ PH_C4Network2
Definition: C4PacketBase.h:192
@ PH_C4GUIMainDlg
Definition: C4PacketBase.h:193
@ PH_C4Network2Players
Definition: C4PacketBase.h:195
@ PH_C4Network2ResList
Definition: C4PacketBase.h:196
@ PH_C4Network2IO
Definition: C4PacketBase.h:191
@ PH_C4Network2ClientList
Definition: C4PacketBase.h:194
@ PH_C4GameControlNetwork
Definition: C4PacketBase.h:197
bool Inside(T ival, U lbound, V rbound)
Definition: Standard.h:43
StdNamingAdapt< T > mkNamingAdapt(T &&rValue, const char *szName)
Definition: StdAdaptors.h:92
StdStrBuf FormatString(const char *szFmt,...)
Definition: StdBuf.cpp:270
C4InteractiveThread InteractiveThread
Definition: C4Application.h:45
int32_t getDiffLevel(const C4ClientCore &CCore2) const
Definition: C4Client.cpp:75
int32_t getID() const
Definition: C4Client.h:57
C4ConfigNetwork Network
Definition: C4Config.h:259
int32_t PacketLogging
Definition: C4Config.h:171
C4GameControlNetwork Network
Definition: C4GameControl.h:67
void HandlePacket(char cStatus, const C4PacketBase *pPacket, C4Network2IOConnection *pConn)
C4PacketType getPktType() const
Definition: C4PacketBase.h:259
C4PacketBase * getPkt() const
Definition: C4PacketBase.h:260
void RemoveProc(StdSchedulerProc *pProc)
bool ThreadLog(const char *szMessage,...) GNUC_FORMAT_ATTRIBUTE_O
void ClearCallback(C4InteractiveEventType eEvent, Callback *pnNetworkCallback)
bool AddProc(StdSchedulerProc *pProc)
bool ThreadLogS(const char *szMessage,...) GNUC_FORMAT_ATTRIBUTE_O
bool PushEvent(C4InteractiveEventType eEventType, void *pData=nullptr)
void SetCallback(C4InteractiveEventType eEvent, Callback *pnNetworkCallback)
virtual void ClearStatistic()=0
virtual bool SetBroadcast(const addr_t &addr, bool fSet=true)=0
virtual void SetCallback(CBClass *pnCallback)=0
virtual const char * GetError() const
Definition: C4NetIO.h:286
virtual bool Init(uint16_t iPort=addr_t::IPPORT_NONE)=0
virtual bool GetConnStatistic(const addr_t &addr, int *pIRate, int *pORate, int *pLoss)=0
void ResetError()
Definition: C4NetIO.h:287
virtual bool Send(const class C4NetIOPacket &rPacket)=0
virtual bool GetStatistic(int *pBroadcastRate)=0
virtual bool Close()=0
virtual bool Connect(const addr_t &addr)=0
const C4NetIO::addr_t & getAddr() const
Definition: C4NetIO.h:317
void SetAddr(const C4NetIO::addr_t &naddr)
Definition: C4NetIO.h:328
C4NetIOPacket Duplicate() const
Definition: C4NetIO.h:326
uint8_t getStatus() const
Definition: C4NetIO.h:319
bool Init(uint16_t iPort=addr_t::IPPORT_NONE) override
Definition: C4NetIO.cpp:811
bool Connect(const addr_t &addr, std::unique_ptr< Socket > socket)
Definition: C4NetIO.cpp:1207
C4NetIOPacket PackTo(const C4NetIO::addr_t &) const
static std::unique_ptr< C4NetpuncherPacket > Construct(const C4NetIOPacket &rpack)
void HandlePacket(char cStatus, const C4PacketBase *pBasePkt, C4Network2IOConnection *pConn)
C4Network2Players Players
Definition: C4Network2.h:119
void HandleLobbyPacket(char cStatus, const C4PacketBase *pBasePkt, C4Network2IOConnection *pConn)
Definition: C4Network2.cpp:963
C4Network2ResList ResList
Definition: C4Network2.h:113
void OnDisconn(C4Network2IOConnection *pConn)
Definition: C4Network2.cpp:836
void OnPuncherConnect(C4NetIO::addr_t addr)
bool HandlePuncherPacket(C4NetpuncherPacket::uptr, C4NetIO::HostAddress::AddressFamily family)
Definition: C4Network2.cpp:972
void HandlePacket(char cStatus, const C4PacketBase *pBasePkt, C4Network2IOConnection *pConn)
Definition: C4Network2.cpp:879
C4Network2ClientList Clients
Definition: C4Network2.h:116
void OnConn(C4Network2IOConnection *pConn)
Definition: C4Network2.cpp:828
void SetPeerAddr(const C4NetIO::addr_t &nPeerAddr)
bool isConnSent() const
Definition: C4Network2IO.h:281
void SetCCore(const C4ClientCore &nCCore)
C4Network2IOProtocol eProt
Definition: C4Network2IO.h:225
uint32_t getInPacketCounter() const
Definition: C4Network2IO.h:283
C4TimeMilliseconds tLastPong
Definition: C4Network2IO.h:237
const C4NetIO::addr_t & getPeerAddr() const
Definition: C4Network2IO.h:266
bool isHalfAccepted() const
Definition: C4Network2IO.h:288
bool Send(const C4NetIOPacket &rPkt)
void Set(C4NetIO *pnNetClass, C4Network2IOProtocol eProt, const C4NetIO::addr_t &nPeerAddr, const C4NetIO::addr_t &nConnectAddr, C4Network2IOConnStatus nStatus, const char *szPassword, uint32_t iID)
bool isAccepted() const
Definition: C4Network2IO.h:289
void SetBroadcastTarget(bool fSet)
void SetRemoteID(uint32_t iRemoteID)
void ClearPacketLog(uint32_t iStartNumber=~0)
C4TimeMilliseconds tLastPing
Definition: C4Network2IO.h:236
C4NetIO::addr_t PeerAddr
Definition: C4Network2IO.h:226
C4NetIO::addr_t ConnectAddr
Definition: C4Network2IO.h:226
std::unique_ptr< C4NetIOTCP::Socket > TcpSimOpenSocket
Definition: C4Network2IO.h:227
C4Network2IOConnection * pNext
Definition: C4Network2IO.h:258
StdCopyStrBuf Password
Definition: C4Network2IO.h:242
bool isAutoAccepted() const
Definition: C4Network2IO.h:291
C4Network2IOConnStatus Status
Definition: C4Network2IO.h:230
void SetSocket(std::unique_ptr< C4NetIOTCP::Socket > socket)
bool CreatePostMortem(class C4PacketPostMortem *pPkt)
void OnPacketReceived(uint8_t iPacketType)
void DoStatistics(int iInterval, int *pIRateSum, int *pORateSum)
bool isConnecting() const
Definition: C4Network2IO.h:286
void SetStatus(C4Network2IOConnStatus nStatus)
std::atomic_long iRefCnt
Definition: C4Network2IO.h:261
void SetPingTime(int iPingTime)
PacketLogEntry * pPacketLog
Definition: C4Network2IO.h:254
class C4NetIO * pNetClass
Definition: C4Network2IO.h:224
Definition: C4Network2IO.h:249
void SetDiscoverable(bool fnEnabled)
bool Init(uint16_t iPort=C4NetIO::addr_t::IPPORT_NONE) override
void ClearAutoAccept()
void RemoveAutoAccept(const C4ClientCore &CCore)
CStdCSec AutoAcceptCSec
Definition: C4Network2IO.h:87
bool SendMsgToClient(C4NetIOPacket &rPkt, int iClient)
class C4Network2RefServer * pRefServer
Definition: C4Network2IO.h:61
bool ConnectWithSocket(const C4NetIO::addr_t &addr, C4Network2IOProtocol eProt, const C4ClientCore &nCCore, std::unique_ptr< C4NetIOTCP::Socket > socket, const char *szPassword=nullptr)
int getConnectionCount()
void SetLocalCCore(const C4ClientCore &CCore)
void OnDisconn(const C4NetIO::addr_t &addr, C4NetIO *pNetIO, const char *szReason) override
~C4Network2IO() override
void HandlePuncherPacket(const C4NetIOPacket &rPacket)
C4Network2IOConnection * pConnList
Definition: C4Network2IO.h:71
C4NetIO * pNetIO_TCP
Definition: C4Network2IO.h:55
C4NetIO * DataIO()
bool IsReferenceNeeded()
bool Execute(int iTimeout, pollfd *) override
void BeginBroadcast(bool fSelectAll=false)
bool doAutoAccept(const C4ClientCore &CCore, const C4Network2IOConnection &Conn)
void HandleFwdReq(const class C4PacketFwd &rFwd, C4Network2IOConnection *pBy)
void CallHandlers(int iHandlers, const class C4IDPacket *pPacket, C4Network2IOConnection *pConn, bool fThread)
bool fExclusiveConn
Definition: C4Network2IO.h:90
C4TimeMilliseconds tLastExecute
Definition: C4Network2IO.h:93
C4TimeMilliseconds tLastPing
Definition: C4Network2IO.h:94
uint32_t iNextConnID
Definition: C4Network2IO.h:75
C4ClientCore LCCore
Definition: C4Network2IO.h:67
void RemoveConnection(C4Network2IOConnection *pConn)
C4Network2IOProtocol getNetIOProt(C4NetIO *pNetIO)
C4Network2IOConnection * GetConnectionByID(uint32_t iConnID)
C4Network2IOConnection * Conn
class C4Network2IODiscover * pNetIODiscover
Definition: C4Network2IO.h:58
CStdCSec ConnListCSec
Definition: C4Network2IO.h:72
bool BroadcastMsg(const C4NetIOPacket &rPkt)
void SendPuncherPacket(const C4NetpuncherPacket &, C4NetIO::HostAddress::AddressFamily family)
C4TimeMilliseconds GetNextTick(C4TimeMilliseconds tNow) override
class C4Network2UPnP * UPnPMgr
Definition: C4Network2IO.h:64
CStdCSec LCCoreCSec
Definition: C4Network2IO.h:68
C4TimeMilliseconds tLastStatistic
Definition: C4Network2IO.h:97
bool IsPuncherAddr(const C4NetIO::addr_t &addr) const
virtual void OnError(const char *strError, C4NetIO *pNetIO)
bool HandlePacket(const C4NetIOPacket &rPacket, C4Network2IOConnection *pConn, bool fThread)
C4Network2IOConnection * GetMsgConnection(int iClientID)
C4NetIO::addr_t PuncherAddrIPv4
Definition: C4Network2IO.h:102
CStdCSec BroadcastCSec
Definition: C4Network2IO.h:72
bool InitPuncher(C4NetIO::addr_t PuncherAddr)
void SetReference(class C4Network2Reference *pReference)
bool Connect(const C4NetIO::addr_t &addr, C4Network2IOProtocol eProt, const C4ClientCore &nCCore, const char *szPassword=nullptr)
C4NetIO * MsgIO()
void GenerateStatistics(int iInterval)
C4NetIO * pNetIO_UDP
Definition: C4Network2IO.h:55
void SetAcceptMode(bool fAcceptAll)
bool Broadcast(const C4NetIOPacket &rPkt)
C4Network2IOConnection * GetConnection(const C4NetIO::addr_t &addr, C4NetIO *pNetIO)
C4NetIO::addr_t PuncherAddrIPv6
Definition: C4Network2IO.h:102
void SendConnPackets()
C4Network2IOConnection * GetDataConnection(int iClientID)
void Punch(const C4NetIO::addr_t &)
bool OnConn(const C4NetIO::addr_t &addr, const C4NetIO::addr_t &AddrConnect, const C4NetIO::addr_t *pOwnAddr, C4NetIO *pNetIO) override
C4Network2IOConnection * GetConnectionByConnAddr(const C4NetIO::addr_t &addr, C4NetIO *pNetIO)
C4NetIO * getNetIO(C4Network2IOProtocol eProt)
bool fAllowConnect
Definition: C4Network2IO.h:78
void AddAutoAccept(const C4ClientCore &CCore)
void AddConnection(C4Network2IOConnection *pConn)
void EndBroadcast()
const char * getNetIOName(C4NetIO *pNetIO)
void OnThreadEvent(C4InteractiveEventType eEvent, void *pEventData) override
void SetExclusiveConnMode(bool fExclusiveConn)
bool Init(int16_t iPortTCP, int16_t iPortUDP, int16_t iPortDiscovery=-1, int16_t iPortRefServer=-1, bool fBroadcast=false, bool enable_upnp=true)
void OnPacket(const C4NetIOPacket &rPacket, C4NetIO *pNetIO) override
void HandlePacket(char cStatus, const C4PacketBase *pPacket, class C4Network2IOConnection *pConn)
void SetReference(C4Network2Reference *pReference)
void HandlePacket(char cStatus, const C4PacketBase *pPacket, C4Network2IOConnection *pConn)
void AddMapping(enum C4Network2IOProtocol protocol, uint16_t intport, uint16_t extport)
void unpack(const C4NetIOPacket &Pkt, char *pStatus=nullptr)
Definition: C4Packet2.cpp:160
bool DoFwdTo(int32_t iClient) const
Definition: C4Packet2.cpp:445
const StdCopyBuf & getData() const
Definition: C4Network2IO.h:403
int32_t getClientCnt() const
Definition: C4Network2IO.h:406
int32_t getClient(int32_t i) const
Definition: C4Network2IO.h:405
void SetData(const StdBuf &Pkt)
Definition: C4Packet2.cpp:453
void AddClient(int32_t iClient)
Definition: C4Packet2.cpp:463
void SetListType(bool fnNegativeList)
Definition: C4Packet2.cpp:458
Definition: C4Network2IO.h:418
void CompileFunc(StdCompiler *pComp) override
void SetConnID(uint32_t inConnID)
Definition: C4Network2IO.h:437
void Add(const C4NetIOPacket &rPkt)
void SetPacketCounter(uint32_t iPacketCounter)
C4PacketPostMortem()
const C4NetIOPacket * getPacket(uint32_t iNumber) const
~C4PacketPostMortem() override
static C4TimeMilliseconds Now()
virtual void Leave()
Definition: StdSync.h:151
virtual void Enter()
Definition: StdSync.h:150
void Clear()
Definition: StdSync.h:178
size_t getSize() const
Definition: StdBuf.h:101
void Take(void *pnData, size_t inSize)
Definition: StdBuf.h:124
void Value(const T &rStruct)
Definition: StdCompiler.h:161
virtual bool isDeserializer()
Definition: StdCompiler.h:53
const char * getData() const
Definition: StdBuf.h:442
char * GrabPointer()
Definition: StdBuf.h:459
StdStrBuf ToString(int flags=0) const
Definition: C4NetIO.cpp:604
HostAddress GetHost() const
Definition: C4NetIO.h:156
AddressFamily GetFamily() const
Definition: C4NetIO.cpp:520
C4PacketType ID
Definition: C4PacketBase.h:204