Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/netp/src/network/ClientConnection.cc @ 2991

Last change on this file since 2991 was 2794, checked in by scheusso, 16 years ago

some optimisations (mostly inlined SynchronisableVariable functions)
trying to track down a bug with enet connections

  • Property svn:eol-style set to native
File size: 7.4 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Oliver Scheuss, (C) 2007
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29//
30// C++ Interface: ClientConnection
31//
32// Description: The Class ClientConnection manages the servers conenctions to the clients.
33// each connection is provided by a new process. communication between master process and
34// connection processes is provided by ...
35//
36//
37// Author:  Oliver Scheuss
38//
39
40#include "ClientConnection.h"
41
42#include <enet/enet.h>
43#include <iostream>
44#include <cassert>
45// boost.thread library for multithreading support
46#include <boost/thread/thread.hpp>
47#include <boost/bind.hpp>
48#include <boost/thread/recursive_mutex.hpp>
49
50#include "util/Sleep.h"
51#include "util/Debug.h"
52
53namespace orxonox
54{
55  //static boost::thread_group network_threads;
56
57  static boost::recursive_mutex enet_mutex_g;
58
59  ClientConnection::ClientConnection(int port, const std::string& address) {
60    quit=false;
61    server=NULL;
62    serverAddress = new ENetAddress();
63    enet_address_set_host(serverAddress, address.c_str());
64    serverAddress->port = port;
65    established=false;
66  }
67
68  ClientConnection::ClientConnection(int port, const char *address) {
69    quit=false;
70    server=NULL;
71    serverAddress = new ENetAddress();
72    enet_address_set_host(serverAddress, address);
73    serverAddress->port = port;
74    established=false;
75  }
76
77  bool ClientConnection::waitEstablished(int milisec) {
78    for(int i=0; i<=milisec && !established; i++)
79      msleep(1);
80
81    return established;
82  }
83
84  ClientConnection::~ClientConnection(){
85    if(established)
86      closeConnection();
87    delete serverAddress; // surely was created
88  }
89
90  ENetEvent *ClientConnection::getEvent(){
91    if(!buffer.isEmpty())
92      return buffer.pop();
93    else
94      return NULL;
95  }
96
97  bool ClientConnection::queueEmpty() {
98    return buffer.isEmpty();
99  }
100
101  bool ClientConnection::createConnection() {
102    receiverThread_ = new boost::thread(boost::bind(&ClientConnection::receiverThread, this));
103    //network_threads.create_thread(boost::bind(boost::mem_fn(&ClientConnection::receiverThread), this));
104    // wait 10 seconds for the connection to be established
105    return waitEstablished(NETWORK_CLIENT_CONNECT_TIMEOUT);
106  }
107
108  bool ClientConnection::closeConnection() {
109    quit=true;
110    //network_threads.join_all();
111    receiverThread_->join();
112    established=false;
113    return true;
114  }
115
116
117  bool ClientConnection::addPacket(ENetPacket *packet) {
118    if(server==NULL)
119      return false;
120    if(packet==NULL){
121      COUT(3) << "Cl.con: addpacket: invalid packet" << std::endl;
122      return false;
123    }
124    boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
125    if(enet_peer_send(server, 0, packet)<0)
126      return false;
127    else
128      return true;
129  }
130
131  bool ClientConnection::sendPackets() {
132    if(server==NULL)
133      return false;
134    boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
135    enet_host_flush(client);
136    lock.unlock();
137    return true;
138  }
139
140  void ClientConnection::receiverThread() {
141    // what about some error-handling here ?
142    atexit(enet_deinitialize);
143    ENetEvent *event;
144    {
145      boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
146      enet_initialize();
147      client = enet_host_create(NULL, NETWORK_CLIENT_MAX_CONNECTIONS, 0, 0);
148      lock.unlock();
149    }
150    if(client==NULL) {
151      COUT(2) << "ClientConnection: could not create client host" << std::endl;
152      // add some error handling here ==========================
153      quit=true;
154    }
155    //connect to the server
156    if(!establishConnection()){
157      COUT(2) << "clientConn: receiver thread: could not establishConnection" << std::endl;
158      quit=true;
159      return;
160    }
161    event = new ENetEvent;
162    //main loop
163    while(!quit){
164      //std::cout << "connection loop" << std::endl;
165      {
166        boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
167        if(enet_host_service(client, event, NETWORK_CLIENT_WAIT_TIME)<0){
168          // we should never reach this point
169                assert(0);
170          quit=true;
171          continue;
172          // add some error handling here ========================
173        }
174        lock.unlock();
175      }
176      switch(event->type){
177        // log handling ================
178      case ENET_EVENT_TYPE_CONNECT:
179        break;
180      case ENET_EVENT_TYPE_RECEIVE:
181        //COUT(5) << "Cl.Con: receiver-Thread while loop: got new packet" << std::endl;
182        if ( !processData(event) ) COUT(2) << "Current packet was not pushed to packetBuffer -> ev ongoing SegFault" << std::endl;
183        //COUT(5) << "Cl.Con: processed Data in receiver-thread while loop" << std::endl;
184        event = new ENetEvent;
185        break;
186      case ENET_EVENT_TYPE_DISCONNECT:
187        quit=true;
188        // server closed the connection
189        return;
190        break;
191      case ENET_EVENT_TYPE_NONE:
192        //receiverThread_->yield();
193        msleep(1);
194        break;
195      }
196    }
197    // now disconnect
198
199    if(!disconnectConnection())
200      // if disconnecting failed destroy conn.
201      boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
202      enet_peer_reset(server);
203    return;
204  }
205
206  bool ClientConnection::disconnectConnection() {
207    ENetEvent event;
208    boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
209    enet_peer_disconnect(server, 0);
210    while(enet_host_service(client, &event, NETWORK_CLIENT_WAIT_TIME) >= 0){
211      switch (event.type)
212      {
213      case ENET_EVENT_TYPE_NONE:
214      case ENET_EVENT_TYPE_CONNECT:
215      case ENET_EVENT_TYPE_RECEIVE:
216        enet_packet_destroy(event.packet);
217        break;
218      case ENET_EVENT_TYPE_DISCONNECT:
219        return true;
220      }
221    }
222    enet_peer_reset(server);
223    return false;
224  }
225
226  bool ClientConnection::establishConnection() {
227    ENetEvent event;
228    // connect to peer (server is type ENetPeer*)
229    boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
230    server = enet_host_connect(client, serverAddress, NETWORK_CLIENT_CHANNELS);
231    if(server==NULL) {
232      COUT(2) << "ClientConnection: server == NULL" << std::endl;
233      // error handling
234      return false;
235    }
236    // handshake
237    while(enet_host_service(client, &event, NETWORK_CLIENT_WAIT_TIME)>=0 && !quit){
238      if( event.type == ENET_EVENT_TYPE_CONNECT ){
239        established=true;
240        return true;
241      }
242    }
243    COUT(2) << "ClientConnection: enet_host_service < 0 or event.type != ENET_EVENT_TYPE_CONNECT # EVENT:" << event.type << std::endl;
244    return false;
245  }
246
247  bool ClientConnection::processData(ENetEvent *event) {
248    COUT(5) << "Cl.Con: got packet, pushing to queue" << std::endl;
249    // just add packet to the buffer
250    // this can be extended with some preprocessing
251    return buffer.push(event);
252  }
253
254}
Note: See TracBrowser for help on using the repository browser.