00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00031
00032
00033
00034
00035
00036
00037
00038 #include <QUANTA/QUANTAnet_tcpReflector_c.hxx>
00039 #include <QUANTA/QUANTAnet_udpReflector_c.hxx>
00040 #include <QUANTA/QUANTAts_barrier_c.hxx>
00041 #include <QUANTA/QUANTAts_rwlock_c.hxx>
00042 #include <QUANTA/QUANTAts_thread_c.hxx>
00043
00044 #include <signal.h>
00045 #ifdef USE_STL_NAMESPACE
00046 #include <iostream>
00047 using std::cout;
00048 using std::endl;
00049 #else
00050 #include <iostream.h>
00051 #endif
00052
00054 void stopServer(int);
00056 void* tcpThreadFunc(void*);
00057 void* udpThreadFunc(void*);
00058
00059 QUANTAnet_tcpReflector_c* hailingserver;
00060 QUANTAnet_udpReflector_c* trackerserver;
00061
00063
00064
00065 volatile bool keepRunning = true;
00067 QUANTAts_barrier_c* runningBarrier;
00069 QUANTAts_rwlock_c* runningLock;
00071
00072 int
00073 main(int argc, char** argv)
00074 {
00075 QUANTAinit();
00076
00077
00078
00079
00080 short tcpPort = 7000;
00081 if (argc > 1) {
00082 tcpPort = strtol(argv[1], NULL, 0);
00083 }
00084 short udpPort = tcpPort+1;
00085
00086
00087 signal(SIGINT, stopServer);
00088 signal(SIGTERM, stopServer);
00089
00090
00091 runningBarrier = new QUANTAts_barrier_c(2);
00092 runningLock = new QUANTAts_rwlock_c;
00093
00094
00095
00096
00097
00098 hailingserver = new QUANTAnet_tcpReflector_c;
00099 hailingserver->setBlockingTimeout(5);
00100 if (hailingserver->init(tcpPort, 64) != QUANTAnet_tcpReflector_c::OK) {
00101 cout << "avatarserver cannot open TCP listening port" << tcpPort << endl;
00102 exit(1) ;
00103 }
00104
00105 trackerserver = new QUANTAnet_udpReflector_c;
00106 trackerserver->setTimeOutTime(5);
00107 trackerserver->setIncomingPort(udpPort) ;
00108 if (trackerserver->init() != QUANTAnet_udpReflector_c::OK) {
00109 cout << "avatarserver annot open UDP listening port" << udpPort << endl;
00110 exit(1) ;
00111 }
00112
00113
00114
00115 QUANTAts_thread_c tcpThread;
00116 tcpThread.create(tcpThreadFunc, hailingserver);
00117
00118
00119 cout << "avatarserver listening on ports " << tcpPort
00120 << " (TCP) and " << udpPort << " (UDP)." << endl;
00121
00122
00123
00124 runningBarrier->wait();
00125
00126
00127 tcpThread.join();
00128
00129
00130
00131
00132
00133 delete hailingserver;
00134 delete trackerserver;
00135 delete runningBarrier;
00136 delete runningLock;
00137
00138 cout << "avatarserver exiting" << endl;
00139 return 0;
00140 }
00141
00142 void
00143 stopServer(int dummy)
00144 {
00145 cout << "Ctrl-C caught..." << endl;
00146 int retval = runningLock->writeLock();
00147 if (retval == 0) {
00148 cout << "\navatarserver shutting down..." << endl;
00149 keepRunning = false;
00150 runningLock->unlock();
00151 signal(SIGINT, SIG_DFL);
00152 } else {
00153 cout << "\nERROR trying to obtain runningLock! "
00154 << strerror(retval) << endl;
00155 }
00156 }
00157
00158 void*
00159 tcpThreadFunc(void* objPtr)
00160 {
00161
00162
00163
00164
00165 bool runTCP = true;
00166 while (runTCP) {
00167 if (runningLock->readLock() == 0) {
00168 if (keepRunning) {
00169
00170
00171 runningLock->unlock();
00172 reinterpret_cast<QUANTAnet_tcpReflector_c*>(objPtr)->process();
00173 } else {
00174 runTCP = false;
00175 }
00176 }
00177 }
00178
00179
00180
00181 runningBarrier->wait();
00182 return NULL;
00183 }
00184
00185 void*
00186 udpThreadFunc(void* objPtr)
00187 {
00188 #if 1
00189
00190 #else
00191 bool runUDP = true;
00192 while (runUDP) {
00193 if (runningLock->readLock() == 0) {
00194 if (keepRunning) {
00195 runningLock->unlock();
00196 reinterpret_cast<QUANTAnet_udpReflector_c*>(objPtr)->process();
00197 } else {
00198 runUDP = false;
00199 }
00200 }
00201 }
00202 #endif
00203 runningBarrier->wait();
00204 return NULL;
00205 }