libs/neuronet/server.c

   1 /* server.c
   2  * Module : Server
   3  */
   4
   5 /*-------------------- Extern Headers Including --------------------*/
   6 #ifndef WIN32
   7 #include <sys/socket.h>
   8 #include <netinet/in.h> /* htons */
   9
  10 #include <fcntl.h> /* fcntl (control of the sockets) */
  11 #include <unistd.h> /* close */
  12
  13 #else /* WIN32 */
  14
  15 #include <windows.h> /* (winsock2 functions) */
  16 #define MSG_DONTWAIT 0
  17
  18 #endif /* WIN32 */
  19
  20 #include <string.h> /* memcpy */
  21
  22 #include <neuro/NEURO.h>
  23
  24 /*-------------------- Local Headers Including ---------------------*/
  25 #include <global.h>
  26 #include "common.h"
  27
  28 #include "slave.h"
  29 #include "master.h"
  30 #include "client.h"
  31 #include "status.h"
  32 #include "util.h"
  33
  34 /*-------------------- Main Module Header --------------------------*/
  35 #include "server.h"
  36
  37 /*--------------------      Other       ----------------------------*/
  38
  39 NEURO_MODULE_CHANNEL("netserver");
  40
  41 /*-------------------- Global Variables ----------------------------*/
  42
  43 /*-------------------- Static Variables ----------------------------*/
  44
  45 /*-------------------- Static Prototypes ---------------------------*/
  46
  47
  48
  49 /*-------------------- Static Functions ----------------------------*/
  50
  51 static void
  52 clean_connection(void *src)
  53 {
  54         Slave *tmp;
  55
  56         tmp = src;
  57
  58         if (!tmp)
  59                 return;
  60
  61         Slave_Clean(tmp);
  62 }
  63
  64 /* 0 is the same, 1 is different */
  65 static int
  66 sockaddrCompare(struct sockaddr_in *a, struct sockaddr_in *b)
  67 {
  68         int i = 0;
  69         int size = sizeof(struct sockaddr_in);
  70         char *bA, *bB;
  71
  72         bA = (char *)a;
  73         bB = (char *)b;
  74
  75         while( i < size)
  76         {
  77                 if (bA[i] == bB[i])
  78                 {
  79                         i++;
  80                         continue;
  81                 }
  82
  83                 return 1;
  84         }
  85         return 0;
  86 }
  87
  88 static Slave *
  89 getSlaveByConnectAddr(EBUF *connections, struct sockaddr_in *connect_addr)
  90 {
  91         int total = 0;
  92         Slave *buf = NULL;
  93
  94         if (Neuro_EBufIsEmpty(connections))
  95                 return NULL;
  96
  97         total = Neuro_GiveEBufCount(connections) + 1;
  98
  99         while (total-- > 0)
 100         {
 101                 buf = Neuro_GiveEBuf(connections, total);
 102
 103                 if (!sockaddrCompare(connect_addr, &buf->c_address))
 104                         return buf;
 105         }
 106
 107         return NULL;
 108 }
 109
 110 /*-------------------- Global Functions ----------------------------*/
 111
 112 void
 113 Server_DisconnectClient(Slave *slv)
 114 {
 115         EBUF *connections;
 116 #if old
 117         EBUF *ce;
 118 #endif /* old */
 119
 120         if (slv)
 121                 TRACE(Neuro_s("Attempting to disconnect the slave %x", (int)slv));
 122
 123         if (!slv || !slv->master || !slv->master->slave)
 124         {
 125                 ERROR("Invalid slave trying to be disconnected");
 126                 return;
 127         }
 128
 129         if (slv->master->slave->cType.server == NULL || slv->master->slave->cType.client == NULL)
 130         {
 131                 ERROR("The client attempted to disconnect a client that was already disconnected!");
 132                 return;
 133         }
 134
 135         connections = slv->master->slave->cType.server->connections;
 136
 137         if (Neuro_EBufIsEmpty(connections))
 138                 return;
 139
 140 #if old
 141         ce = slv->master->cevents;
 142
 143         /* delete all the remaining events for the slave client, if any */
 144         if (!Neuro_EBufIsEmpty(ce))
 145         {
 146                 int total = 0;
 147                 Event *tmp;
 148
 149                 total = Neuro_GiveEBufCount(ce) + 1;
 150
 151                 while (total-- > 0)
 152                 {
 153                         tmp = Neuro_GiveEBuf(ce, total);
 154
 155                         if (tmp->slave == slv)
 156                         {
 157                                 Util_SCleanEBuf(ce, tmp);
 158                         }
 159                 }
 160         }
 161
 162         /* delete all the remaining statuses for the slave client, if any */
 163         if (!Neuro_EBufIsEmpty(slv->master->statuses))
 164         {
 165                 int total = 0;
 166                 Status *tmp;
 167
 168                 total = Neuro_GiveEBufCount(slv->master->statuses) + 1;
 169
 170                 while (total-- > 0)
 171                 {
 172                         tmp = Neuro_GiveEBuf(slv->master->statuses, total);
 173
 174                         if (tmp->connection == slv)
 175                         {
 176                                 Util_SCleanEBuf(slv->master->statuses, tmp);
 177                         }
 178                 }
 179         }
 180 #endif /* old */
 181
 182         TRACE(Neuro_s("Disconnected client %x", slv));
 183
 184         Status_PurgeSlave(slv->master, slv);
 185
 186         Neuro_SCleanEBuf(connections, slv);
 187 }
 188
 189 /*-------------------- Poll ----------------------------------------*/
 190
 191 int
 192 Server_Poll(Slave *slv)
 193 {
 194         struct sockaddr_in connect_addr; /* new connection's address */
 195 #ifndef WIN32
 196         u32 addrlen = 0;
 197 #else /* WIN32 */
 198         i32 addrlen = 0;
 199 #endif /* WIN32 */
 200         i32 _err = 0;
 201         int sigmask = 0;
 202         Server *server;
 203
 204         if (!slv)
 205         {
 206                 return 1;
 207         }
 208
 209         server = slv->cType.server;
 210         sigmask = slv->sigmask;
 211
 212 #if old
 213         /* only read events are handled for now */
 214         if ((sigmask & 1) != 1)
 215         {
 216                 return 0;
 217         }
 218 #endif /* old */
 219
 220         addrlen = sizeof(struct sockaddr_in);
 221
 222         switch (slv->master->protocolType)
 223         {
 224                 case SOCK_STREAM:
 225                 {
 226                         /* we check to see if theres new clients who want to join the party. */
 227                         _err = accept(slv->socket, (struct sockaddr*)&connect_addr, &addrlen);
 228
 229
 230                         /* if theres a new connection, we will add it to our buffer */
 231                         if (_err != -1)
 232                         {
 233                                 Slave *buf;
 234                                 Client *tmp;
 235
 236                                 /* we have a new client that wishes to connect so we let it connect */
 237
 238                                 Neuro_AllocEBuf(server->connections, sizeof(Slave*), sizeof(Slave));
 239
 240                                 buf = Neuro_GiveCurEBuf(server->connections);
 241
 242                                 tmp = Client_Create(slv->master);
 243
 244                                 tmp->connection_start_time = Neuro_GetTickCount();
 245                                 tmp->idle_time = tmp->connection_start_time;
 246                                 tmp->timeout = 0;
 247
 248                                 Slave_Init(buf, slv->master, _err, 1, tmp, NULL);
 249
 250                                 memcpy(&buf->c_address, &connect_addr, sizeof(struct sockaddr_in));
 251                                 buf->addrlen = addrlen;
 252
 253                                 Status_Add(slv->master, State_NewClient, NULL, 0, buf);
 254
 255                                 TRACE(Neuro_s("New Client Connection %x on socket %d (master %x slave %x)", buf, slv->socket, (int)buf->master, (int)buf));
 256                         }
 257                 }
 258                 break;
 259
 260                 case SOCK_DGRAM:
 261                 {
 262                         char *rbuffer = NULL;
 263 #ifndef WIN32
 264                         ssize_t rbuflen = 0;
 265 #else /* WIN32 */
 266                         int rbuflen = 0;
 267 #endif /* WIN32 */
 268                         int sock;
 269                         Slave *clientSlv;
 270
 271                         rbuffer = calloc(1, MAX_PACKET_SIZE * INPUT_PACKET_BUFFERING);
 272
 273                         rbuflen = recvfrom(slv->socket, rbuffer, MAX_PACKET_SIZE * INPUT_PACKET_BUFFERING, 0, (struct sockaddr*)&connect_addr, &addrlen);
 274
 275                         TRACE(Neuro_s("Packet from IP %s", inet_ntoa(connect_addr.sin_addr)));
 276
 277                         clientSlv = getSlaveByConnectAddr(server->connections, &connect_addr);
 278
 279                         if (!clientSlv)
 280                         {
 281                                 /* this is a new client connection, we create a new slave for this. */
 282
 283                                 Slave *buf;
 284                                 Client *tmp;
 285
 286                                 /* we have a new client that wishes to connect so we let it connect */
 287
 288                                 Neuro_AllocEBuf(server->connections, sizeof(Slave*), sizeof(Slave));
 289
 290                                 buf = Neuro_GiveCurEBuf(server->connections);
 291
 292                                 tmp = Client_Create(slv->master);
 293
 294                                 tmp->connection_start_time = Neuro_GetTickCount();
 295                                 tmp->idle_time = tmp->connection_start_time;
 296                                 tmp->timeout = 0;
 297
 298                                 Slave_Init(buf, slv->master, slv->socket, 1, tmp, NULL);
 299
 300                                 memcpy(&buf->c_address, &connect_addr, sizeof(struct sockaddr_in));
 301                                 buf->addrlen = addrlen;
 302
 303                                 Status_Add(slv->master, State_NewClient, NULL, 0, buf);
 304
 305                                 TRACE(Neuro_s("UDP-> New Client Connection %x on socket %d", buf, slv->socket));
 306
 307                                 clientSlv = buf;
 308                         }
 309                         else
 310                         {
 311                                 /* we are already connected to this slave, so we just handle its packet */
 312                         }
 313
 314                         TRACE(Neuro_s("UDP-> Got a new packet of size %d", rbuflen));
 315
 316                         Util_Buffer_Recv_Data(clientSlv, rbuffer, rbuflen);
 317
 318                         Client_PopData(clientSlv);
 319                 }
 320                 break;
 321         }
 322
 323         return 0;
 324 }
 325
 326 /*-------------------- Constructor Destructor ----------------------*/
 327
 328 Slave *
 329 Server_Create(Master *msr, const char *listen_ip, int port)
 330 {
 331         Slave *output;
 332         struct sockaddr_in saddress; /* server address */
 333         int _err = 0;
 334         unsigned int addrlen = 0;
 335         Server *svr;
 336         int sock = 0;
 337
 338         svr = calloc(1, sizeof(Server));
 339
 340         addrlen = sizeof(struct sockaddr_in);
 341
 342         sock = socket(AF_INET, msr->protocolType, 0);
 343
 344         if (sock <= 0)
 345         {
 346                 ERROR("socket creation failed\n");
 347                 return NULL;
 348         }
 349
 350 #ifndef WIN32
 351         {
 352                 int set = 1;
 353
 354                 /* this should fix an annoying issue happening between the execution
 355                  * of the server. Bind fails for a while until the address is available
 356                  * again.
 357                  */
 358                 setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&set, sizeof(int));
 359         }
 360 #endif /* not WIN32 */
 361
 362         saddress.sin_family = AF_INET;
 363         saddress.sin_addr.s_addr = inet_addr(listen_ip);
 364         saddress.sin_port = htons(port);
 365
 366         _err = bind(sock, (struct sockaddr*)&saddress, sizeof(saddress));
 367
 368 #ifndef WIN32
 369         fcntl(sock, F_SETFL, O_NONBLOCK);
 370 #else /* WIN32 */
 371         {
 372                 unsigned long nb = 1;
 373                 if (ioctlsocket(sock, FIONBIO, &nb) == SOCKET_ERROR)
 374                         return NULL;
 375         }
 376 #endif /* WIN32 */
 377
 378         if (_err == -1)
 379         {
 380                 ERROR("binding failed");
 381
 382                 free(svr);
 383
 384 #ifndef WIN32
 385                 close(sock);
 386 #else /* WIN32 */
 387                 closesocket(sock);
 388 #endif /* WIN32 */
 389                 return NULL;
 390         }
 391
 392         _err = 0;
 393
 394         if (msr->protocolType == SOCK_STREAM)
 395         {
 396                 _err = listen(sock, 2);
 397                 if (_err == -1)
 398                 {
 399                         ERROR("flagging the master socket as listening failed");
 400 #ifndef WIN32
 401                         close(sock);
 402 #else /* WIN32 */
 403                         closesocket(sock);
 404 #endif /* WIN32 */
 405
 406                         return NULL;
 407                 }
 408         }
 409
 410         Neuro_CreateEBuf(&svr->connections);
 411         Neuro_SetcallbEBuf(svr->connections, clean_connection);
 412
 413         output = Slave_Create(msr, sock, 0, NULL, svr);
 414
 415         msr->slave = output;
 416         msr->slave->c_address = saddress;
 417         msr->slave->addrlen = sizeof(saddress);
 418
 419         TRACE(Neuro_s("Server is accepting connections on port %d", port));
 420
 421         return output;
 422 }
 423
 424 void
 425 Server_Destroy(Server *srv)
 426 {
 427         if (!srv)
 428                 return;
 429
 430         Neuro_CleanEBuf(&srv->connections);
 431
 432         free(srv);
 433 }