SauerbratenRemote/src/engine/server.cpp

   1 // server.cpp: little more than enhanced multicaster
   2 // runs dedicated or as client coroutine
   3
   4 #include "pch.h"
   5
   6 #ifdef STANDALONE
   7 #include "cube.h"
   8 #include "iengine.h"
   9 #include "igame.h"
  10 void localservertoclient(int chan, uchar *buf, int len) {}
  11 void fatal(const char *s, ...)
  12 {
  13     void cleanupserver();
  14     cleanupserver();
  15     s_sprintfdlv(msg,s,s);
  16     printf("servererror: %s\n", msg);
  17     exit(EXIT_FAILURE);
  18 }
  19 #else
  20 #include "engine.h"
  21 #endif
  22
  23 igameclient     *cl = NULL;
  24 igameserver     *sv = NULL;
  25 iclientcom      *cc = NULL;
  26 icliententities *et = NULL;
  27
  28 hashtable<const char *, igame *> *gamereg = NULL;
  29
  30 vector<char *> gameargs;
  31
  32 void registergame(const char *name, igame *ig)
  33 {
  34     if(!gamereg) gamereg = new hashtable<const char *, igame *>;
  35     (*gamereg)[name] = ig;
  36 }
  37
  38 void initgame(const char *game)
  39 {
  40     igame **ig = gamereg->access(game);
  41     if(!ig) fatal("cannot start game module: %s", game);
  42     sv = (*ig)->newserver();
  43     cl = (*ig)->newclient();
  44     if(cl)
  45     {
  46         cc = cl->getcom();
  47         et = cl->getents();
  48         cl->initclient();
  49     }
  50     loopv(gameargs)
  51     {
  52         if(!cl || !cl->clientoption(gameargs[i]))
  53         {
  54             if(!sv->serveroption(gameargs[i]))
  55 #ifdef STANDALONE
  56                 printf("unknown command-line option: %s\n", gameargs[i]);
  57 #else
  58                 conoutf(CON_ERROR, "unknown command-line option: %s", gameargs[i]);
  59 #endif
  60         }
  61     }
  62 }
  63
  64 // all network traffic is in 32bit ints, which are then compressed using the following simple scheme (assumes that most values are small).
  65
  66 void putint(ucharbuf &p, int n)
  67 {
  68     if(n<128 && n>-127) p.put(n);
  69     else if(n<0x8000 && n>=-0x8000) { p.put(0x80); p.put(n); p.put(n>>8); }
  70     else { p.put(0x81); p.put(n); p.put(n>>8); p.put(n>>16); p.put(n>>24); }
  71 }
  72
  73 int getint(ucharbuf &p)
  74 {
  75     int c = (char)p.get();
  76     if(c==-128) { int n = p.get(); n |= char(p.get())<<8; return n; }
  77     else if(c==-127) { int n = p.get(); n |= p.get()<<8; n |= p.get()<<16; return n|(p.get()<<24); }
  78     else return c;
  79 }
  80
  81 // much smaller encoding for unsigned integers up to 28 bits, but can handle signed
  82 void putuint(ucharbuf &p, int n)
  83 {
  84     if(n < 0 || n >= (1<<21))
  85     {
  86         p.put(0x80 | (n & 0x7F));
  87         p.put(0x80 | ((n >> 7) & 0x7F));
  88         p.put(0x80 | ((n >> 14) & 0x7F));
  89         p.put(n >> 21);
  90     }
  91     else if(n < (1<<7)) p.put(n);
  92     else if(n < (1<<14))
  93     {
  94         p.put(0x80 | (n & 0x7F));
  95         p.put(n >> 7);
  96     }
  97     else
  98     {
  99         p.put(0x80 | (n & 0x7F));
 100         p.put(0x80 | ((n >> 7) & 0x7F));
 101         p.put(n >> 14);
 102     }
 103 }
 104
 105 int getuint(ucharbuf &p)
 106 {
 107     int n = p.get();
 108     if(n & 0x80)
 109     {
 110         n += (p.get() << 7) - 0x80;
 111         if(n & (1<<14)) n += (p.get() << 14) - (1<<14);
 112         if(n & (1<<21)) n += (p.get() << 21) - (1<<21);
 113         if(n & (1<<28)) n |= 0xF0000000;
 114     }
 115     return n;
 116 }
 117
 118 void sendstring(const char *t, ucharbuf &p)
 119 {
 120     while(*t) putint(p, *t++);
 121     putint(p, 0);
 122 }
 123
 124 void getstring(char *text, ucharbuf &p, int len)
 125 {
 126     char *t = text;
 127     do
 128     {
 129         if(t>=&text[len]) { text[len-1] = 0; return; }
 130         if(!p.remaining()) { *t = 0; return; }
 131         *t = getint(p);
 132     }
 133     while(*t++);
 134 }
 135
 136 void filtertext(char *dst, const char *src, bool whitespace, int len)
 137 {
 138     for(int c = *src; c; c = *++src)
 139     {
 140         switch(c)
 141         {
 142         case '\f': ++src; continue;
 143         }
 144         if(isspace(c) ? whitespace : isprint(c))
 145         {
 146             *dst++ = c;
 147             if(!--len) break;
 148         }
 149     }
 150     *dst = '\0';
 151 }
 152
 153 enum { ST_EMPTY, ST_LOCAL, ST_TCPIP };
 154
 155 struct client                   // server side version of "dynent" type
 156 {
 157     int type;
 158     int num;
 159     ENetPeer *peer;
 160     string hostname;
 161     void *info;
 162 };
 163
 164 vector<client *> clients;
 165
 166 ENetHost *serverhost = NULL;
 167 size_t bsend = 0, brec = 0;
 168 int laststatus = 0;
 169 ENetSocket pongsock = ENET_SOCKET_NULL;
 170
 171 void cleanupserver()
 172 {
 173     if(serverhost) enet_host_destroy(serverhost);
 174 }
 175
 176 void sendfile(int cn, int chan, FILE *file, const char *format, ...)
 177 {
 178 #ifndef STANDALONE
 179     extern ENetHost *clienthost;
 180 #endif
 181     if(cn < 0)
 182     {
 183 #ifndef STANDALONE
 184         if(!clienthost || clienthost->peers[0].state != ENET_PEER_STATE_CONNECTED)
 185 #endif
 186             return;
 187     }
 188     else if(cn >= clients.length() || clients[cn]->type != ST_TCPIP) return;
 189
 190     fseek(file, 0, SEEK_END);
 191     int len = ftell(file);
 192     bool reliable = false;
 193     if(*format=='r') { reliable = true; ++format; }
 194     ENetPacket *packet = enet_packet_create(NULL, MAXTRANS+len, ENET_PACKET_FLAG_RELIABLE);
 195     rewind(file);
 196
 197     ucharbuf p(packet->data, packet->dataLength);
 198     va_list args;
 199     va_start(args, format);
 200     while(*format) switch(*format++)
 201     {
 202         case 'i':
 203         {
 204             int n = isdigit(*format) ? *format++-'0' : 1;
 205             loopi(n) putint(p, va_arg(args, int));
 206             break;
 207         }
 208         case 's': sendstring(va_arg(args, const char *), p); break;
 209         case 'l': putint(p, len); break;
 210     }
 211     va_end(args);
 212     enet_packet_resize(packet, p.length()+len);
 213
 214     fread(&packet->data[p.length()], 1, len, file);
 215     enet_packet_resize(packet, p.length()+len);
 216
 217     if(cn >= 0) enet_peer_send(clients[cn]->peer, chan, packet);
 218 #ifndef STANDALONE
 219     else enet_peer_send(&clienthost->peers[0], chan, packet);
 220 #endif
 221
 222     if(!packet->referenceCount) enet_packet_destroy(packet);
 223 }
 224
 225 void process(ENetPacket *packet, int sender, int chan);
 226 //void disconnect_client(int n, int reason);
 227
 228 void *getinfo(int i)    { return !clients.inrange(i) || clients[i]->type==ST_EMPTY ? NULL : clients[i]->info; }
 229 int getnumclients()     { return clients.length(); }
 230 uint getclientip(int n) { return clients.inrange(n) && clients[n]->type==ST_TCPIP ? clients[n]->peer->address.host : 0; }
 231
 232 void sendpacket(int n, int chan, ENetPacket *packet, int exclude)
 233 {
 234     if(n<0)
 235     {
 236         sv->recordpacket(chan, packet->data, packet->dataLength);
 237         loopv(clients) if(i!=exclude) sendpacket(i, chan, packet);
 238         return;
 239     }
 240     switch(clients[n]->type)
 241     {
 242         case ST_TCPIP:
 243         {
 244             enet_peer_send(clients[n]->peer, chan, packet);
 245             bsend += packet->dataLength;
 246             break;
 247         }
 248
 249         case ST_LOCAL:
 250             localservertoclient(chan, packet->data, (int)packet->dataLength);
 251             break;
 252     }
 253 }
 254
 255 void sendf(int cn, int chan, const char *format, ...)
 256 {
 257     int exclude = -1;
 258     bool reliable = false;
 259     if(*format=='r') { reliable = true; ++format; }
 260     ENetPacket *packet = enet_packet_create(NULL, MAXTRANS, reliable ? ENET_PACKET_FLAG_RELIABLE : 0);
 261     ucharbuf p(packet->data, packet->dataLength);
 262     va_list args;
 263     va_start(args, format);
 264     while(*format) switch(*format++)
 265     {
 266         case 'x':
 267             exclude = va_arg(args, int);
 268             break;
 269
 270         case 'v':
 271         {
 272             int n = va_arg(args, int);
 273             int *v = va_arg(args, int *);
 274             loopi(n) putint(p, v[i]);
 275             break;
 276         }
 277
 278         case 'i':
 279         {
 280             int n = isdigit(*format) ? *format++-'0' : 1;
 281             loopi(n) putint(p, va_arg(args, int));
 282             break;
 283         }
 284         case 's': sendstring(va_arg(args, const char *), p); break;
 285         case 'm':
 286         {
 287             int n = va_arg(args, int);
 288             enet_packet_resize(packet, packet->dataLength+n);
 289             p.buf = packet->data;
 290             p.maxlen += n;
 291             p.put(va_arg(args, uchar *), n);
 292             break;
 293         }
 294     }
 295     va_end(args);
 296     enet_packet_resize(packet, p.length());
 297     sendpacket(cn, chan, packet, exclude);
 298     if(packet->referenceCount==0) enet_packet_destroy(packet);
 299 }
 300
 301 const char *disc_reasons[] = { "normal", "end of packet", "client num", "kicked/banned", "tag type", "ip is banned", "server is in private mode", "server FULL (maxclients)" };
 302
 303 void disconnect_client(int n, int reason)
 304 {
 305     if(clients[n]->type!=ST_TCPIP) return;
 306     s_sprintfd(s)("client (%s) disconnected because: %s\n", clients[n]->hostname, disc_reasons[reason]);
 307     puts(s);
 308     enet_peer_disconnect(clients[n]->peer, reason);
 309     sv->clientdisconnect(n);
 310     clients[n]->type = ST_EMPTY;
 311     clients[n]->peer->data = NULL;
 312     sv->deleteinfo(clients[n]->info);
 313     clients[n]->info = NULL;
 314     sv->sendservmsg(s);
 315 }
 316
 317 void process(ENetPacket *packet, int sender, int chan)   // sender may be -1
 318 {
 319     ucharbuf p(packet->data, (int)packet->dataLength);
 320     sv->parsepacket(sender, chan, (packet->flags&ENET_PACKET_FLAG_RELIABLE)!=0, p);
 321     if(p.overread()) { disconnect_client(sender, DISC_EOP); return; }
 322 }
 323
 324 void send_welcome(int n)
 325 {
 326     ENetPacket *packet = enet_packet_create (NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE);
 327     ucharbuf p(packet->data, packet->dataLength);
 328     int chan = sv->welcomepacket(p, n, packet);
 329     enet_packet_resize(packet, p.length());
 330     sendpacket(n, chan, packet);
 331     if(packet->referenceCount==0) enet_packet_destroy(packet);
 332 }
 333
 334 void localclienttoserver(int chan, ENetPacket *packet)
 335 {
 336     process(packet, 0, chan);
 337     if(packet->referenceCount==0) enet_packet_destroy(packet);
 338 }
 339
 340 client &addclient()
 341 {
 342     loopv(clients) if(clients[i]->type==ST_EMPTY)
 343     {
 344         clients[i]->info = sv->newinfo();
 345         return *clients[i];
 346     }
 347     client *c = new client;
 348     c->num = clients.length();
 349     c->info = sv->newinfo();
 350     clients.add(c);
 351     return *c;
 352 }
 353
 354 int localclients = 0, nonlocalclients = 0;
 355
 356 bool hasnonlocalclients() { return nonlocalclients!=0; }
 357 bool haslocalclients() { return localclients!=0; }
 358
 359 static ENetAddress pongaddr;
 360
 361 void sendserverinforeply(ucharbuf &p)
 362 {
 363     ENetBuffer buf;
 364     buf.data = p.buf;
 365     buf.dataLength = p.length();
 366     enet_socket_send(pongsock, &pongaddr, &buf, 1);
 367 }
 368
 369 void sendpongs()        // reply all server info requests
 370 {
 371     ENetBuffer buf;
 372     uchar pong[MAXTRANS];
 373     int len;
 374     enet_uint32 events = ENET_SOCKET_WAIT_RECEIVE;
 375     buf.data = pong;
 376     while(enet_socket_wait(pongsock, &events, 0) >= 0 && events)
 377     {
 378         buf.dataLength = sizeof(pong);
 379         len = enet_socket_receive(pongsock, &pongaddr, &buf, 1);
 380         if(len < 0) return;
 381         ucharbuf req(pong, len), p(pong, sizeof(pong));
 382         p.len += len;
 383         sv->serverinforeply(req, p);
 384     }
 385 }
 386
 387 #ifdef STANDALONE
 388 bool resolverwait(const char *name, ENetAddress *address)
 389 {
 390     return enet_address_set_host(address, name) >= 0;
 391 }
 392
 393 int connectwithtimeout(ENetSocket sock, const char *hostname, ENetAddress &remoteaddress)
 394 {
 395     int result = enet_socket_connect(sock, &remoteaddress);
 396     if(result<0) enet_socket_destroy(sock);
 397     return result;
 398 }
 399 #endif
 400
 401 ENetSocket httpgetsend(ENetAddress &remoteaddress, const char *hostname, const char *req, const char *ref, const char *agent, ENetAddress *localaddress = NULL)
 402 {
 403     if(remoteaddress.host==ENET_HOST_ANY)
 404     {
 405 #ifdef STANDALONE
 406         printf("looking up %s...\n", hostname);
 407 #endif
 408         if(!resolverwait(hostname, &remoteaddress)) return ENET_SOCKET_NULL;
 409     }
 410     ENetSocket sock = enet_socket_create(ENET_SOCKET_TYPE_STREAM, localaddress);
 411     if(sock==ENET_SOCKET_NULL || connectwithtimeout(sock, hostname, remoteaddress)<0)
 412     {
 413 #ifdef STANDALONE
 414         printf(sock==ENET_SOCKET_NULL ? "could not open socket\n" : "could not connect\n");
 415 #endif
 416         return ENET_SOCKET_NULL;
 417     }
 418     ENetBuffer buf;
 419     s_sprintfd(httpget)("GET %s HTTP/1.0\nHost: %s\nReferer: %s\nUser-Agent: %s\n\n", req, hostname, ref, agent);
 420     buf.data = httpget;
 421     buf.dataLength = strlen((char *)buf.data);
 422 #ifdef STANDALONE
 423     printf("sending request to %s...\n", hostname);
 424 #endif
 425     enet_socket_send(sock, NULL, &buf, 1);
 426     return sock;
 427 }
 428
 429 bool httpgetreceive(ENetSocket sock, ENetBuffer &buf, int timeout = 0)
 430 {
 431     if(sock==ENET_SOCKET_NULL) return false;
 432     enet_uint32 events = ENET_SOCKET_WAIT_RECEIVE;
 433     if(enet_socket_wait(sock, &events, timeout) >= 0 && events)
 434     {
 435         int len = enet_socket_receive(sock, NULL, &buf, 1);
 436         if(len<=0)
 437         {
 438             enet_socket_destroy(sock);
 439             return false;
 440         }
 441         buf.data = ((char *)buf.data)+len;
 442         ((char*)buf.data)[0] = 0;
 443         buf.dataLength -= len;
 444     }
 445     return true;
 446 }
 447
 448 uchar *stripheader(uchar *b)
 449 {
 450     char *s = strstr((char *)b, "\n\r\n");
 451     if(!s) s = strstr((char *)b, "\n\n");
 452     return s ? (uchar *)s : b;
 453 }
 454
 455 ENetSocket mssock = ENET_SOCKET_NULL;
 456 ENetAddress msaddress = { ENET_HOST_ANY, ENET_PORT_ANY };
 457 ENetAddress masterserver = { ENET_HOST_ANY, 80 };
 458 int lastupdatemaster = 0;
 459 string masterbase;
 460 string masterpath;
 461 uchar masterrep[MAXTRANS];
 462 ENetBuffer masterb;
 463
 464 void updatemasterserver()
 465 {
 466     s_sprintfd(path)("%sregister.do?action=add", masterpath);
 467     if(mssock!=ENET_SOCKET_NULL) enet_socket_destroy(mssock);
 468     mssock = httpgetsend(masterserver, masterbase, path, sv->servername(), sv->servername(), &msaddress);
 469     masterrep[0] = 0;
 470     masterb.data = masterrep;
 471     masterb.dataLength = MAXTRANS-1;
 472 }
 473
 474 void checkmasterreply()
 475 {
 476     if(mssock!=ENET_SOCKET_NULL && !httpgetreceive(mssock, masterb))
 477     {
 478         mssock = ENET_SOCKET_NULL;
 479         printf("masterserver reply: %s\n", stripheader(masterrep));
 480     }
 481 }
 482
 483 #ifndef STANDALONE
 484
 485 #define RETRIEVELIMIT 20000
 486
 487 uchar *retrieveservers(uchar *buf, int buflen)
 488 {
 489     buf[0] = '\0';
 490
 491     s_sprintfd(path)("%sretrieve.do?item=list", masterpath);
 492     ENetAddress address = masterserver;
 493     ENetSocket sock = httpgetsend(address, masterbase, path, sv->servername(), sv->servername());
 494     if(sock==ENET_SOCKET_NULL) return buf;
 495     /* only cache this if connection succeeds */
 496     masterserver = address;
 497
 498     s_sprintfd(text)("retrieving servers from %s... (esc to abort)", masterbase);
 499     show_out_of_renderloop_progress(0, text);
 500
 501     ENetBuffer eb;
 502     eb.data = buf;
 503     eb.dataLength = buflen-1;
 504
 505     int starttime = SDL_GetTicks(), timeout = 0;
 506     while(httpgetreceive(sock, eb, 250))
 507     {
 508         timeout = SDL_GetTicks() - starttime;
 509         show_out_of_renderloop_progress(min(float(timeout)/RETRIEVELIMIT, 1.0f), text);
 510         if(interceptkey(SDLK_ESCAPE)) timeout = RETRIEVELIMIT + 1;
 511         if(timeout > RETRIEVELIMIT)
 512         {
 513             buf[0] = '\0';
 514             enet_socket_destroy(sock);
 515             return buf;
 516         }
 517     }
 518
 519     return stripheader(buf);
 520 }
 521 #endif
 522
 523 #define DEFAULTCLIENTS 6
 524
 525 int uprate = 0, maxclients = DEFAULTCLIENTS;
 526 const char *ip = "", *master = NULL;
 527 const char *game = "fps";
 528
 529 #ifdef STANDALONE
 530 int lastmillis = 0, totalmillis = 0;
 531 #endif
 532
 533 void serverslice(uint timeout)   // main server update, called from main loop in sp, or from below in dedicated server
 534 {
 535     localclients = nonlocalclients = 0;
 536     loopv(clients) switch(clients[i]->type)
 537     {
 538         case ST_LOCAL: localclients++; break;
 539         case ST_TCPIP: nonlocalclients++; break;
 540     }
 541
 542     if(!serverhost)
 543     {
 544         sv->serverupdate(lastmillis, totalmillis);
 545         return;
 546     }
 547
 548     // below is network only
 549
 550     lastmillis = totalmillis = (int)enet_time_get();
 551     sv->serverupdate(lastmillis, totalmillis);
 552
 553     sendpongs();
 554
 555     if(*masterpath) checkmasterreply();
 556
 557     if(totalmillis-lastupdatemaster>60*60*1000 && *masterpath)       // send alive signal to masterserver every hour of uptime
 558     {
 559         updatemasterserver();
 560         lastupdatemaster = totalmillis;
 561     }
 562
 563     if(totalmillis-laststatus>60*1000)   // display bandwidth stats, useful for server ops
 564     {
 565         laststatus = totalmillis;
 566         if(nonlocalclients || bsend || brec) printf("status: %d remote clients, %.1f send, %.1f rec (K/sec)\n", nonlocalclients, bsend/60.0f/1024, brec/60.0f/1024);
 567         bsend = brec = 0;
 568     }
 569
 570     ENetEvent event;
 571     bool serviced = false;
 572     while(!serviced)
 573     {
 574         if(enet_host_check_events(serverhost, &event) <= 0)
 575         {
 576             if(enet_host_service(serverhost, &event, timeout) <= 0) break;
 577             serviced = true;
 578         }
 579         switch(event.type)
 580         {
 581             case ENET_EVENT_TYPE_CONNECT:
 582             {
 583                 client &c = addclient();
 584                 c.type = ST_TCPIP;
 585                 c.peer = event.peer;
 586                 c.peer->data = &c;
 587                 char hn[1024];
 588                 s_strcpy(c.hostname, (enet_address_get_host_ip(&c.peer->address, hn, sizeof(hn))==0) ? hn : "unknown");
 589                 printf("client connected (%s)\n", c.hostname);
 590                 int reason = DISC_MAXCLIENTS;
 591                 if(nonlocalclients<maxclients && !(reason = sv->clientconnect(c.num, c.peer->address.host)))
 592                 {
 593                     nonlocalclients++;
 594                     send_welcome(c.num);
 595                 }
 596                 else disconnect_client(c.num, reason);
 597                 break;
 598             }
 599             case ENET_EVENT_TYPE_RECEIVE:
 600             {
 601                 brec += event.packet->dataLength;
 602                 client *c = (client *)event.peer->data;
 603                 if(c) process(event.packet, c->num, event.channelID);
 604                 if(event.packet->referenceCount==0) enet_packet_destroy(event.packet);
 605                 break;
 606             }
 607             case ENET_EVENT_TYPE_DISCONNECT:
 608             {
 609                 client *c = (client *)event.peer->data;
 610                 if(!c) break;
 611                 printf("disconnected client (%s)\n", c->hostname);
 612                 sv->clientdisconnect(c->num);
 613                 nonlocalclients--;
 614                 c->type = ST_EMPTY;
 615                 event.peer->data = NULL;
 616                 sv->deleteinfo(c->info);
 617                 c->info = NULL;
 618                 break;
 619             }
 620             default:
 621                 break;
 622         }
 623     }
 624     if(sv->sendpackets()) enet_host_flush(serverhost);
 625 }
 626
 627 void localdisconnect()
 628 {
 629     loopv(clients) if(clients[i]->type==ST_LOCAL)
 630     {
 631         sv->localdisconnect(i);
 632         localclients--;
 633         clients[i]->type = ST_EMPTY;
 634         sv->deleteinfo(clients[i]->info);
 635         clients[i]->info = NULL;
 636     }
 637 }
 638
 639 void localconnect()
 640 {
 641     client &c = addclient();
 642     c.type = ST_LOCAL;
 643     s_strcpy(c.hostname, "local");
 644     localclients++;
 645     sv->localconnect(c.num);
 646     send_welcome(c.num);
 647 }
 648
 649 void initserver(bool dedicated)
 650 {
 651     initgame(game);
 652
 653     if(!master) master = sv->getdefaultmaster();
 654     const char *mid = strstr(master, "/");
 655     if(!mid) mid = master;
 656     s_strcpy(masterpath, mid);
 657     s_strncpy(masterbase, master, mid-master+1);
 658
 659     if(dedicated)
 660     {
 661         ENetAddress address = { ENET_HOST_ANY, sv->serverport() };
 662         if(*ip)
 663         {
 664             if(enet_address_set_host(&address, ip)<0) printf("WARNING: server ip not resolved");
 665             else msaddress.host = address.host;
 666         }
 667         serverhost = enet_host_create(&address, maxclients+1, 0, uprate);
 668         if(!serverhost) fatal("could not create server host");
 669         loopi(maxclients) serverhost->peers[i].data = NULL;
 670         address.port = sv->serverinfoport();
 671         pongsock = enet_socket_create(ENET_SOCKET_TYPE_DATAGRAM, &address);
 672         if(pongsock == ENET_SOCKET_NULL) fatal("could not create server info socket");
 673         else enet_socket_set_option(pongsock, ENET_SOCKOPT_NONBLOCK, 1);
 674     }
 675
 676     sv->serverinit();
 677
 678     if(dedicated)       // do not return, this becomes main loop
 679     {
 680         #ifdef WIN32
 681         SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
 682         #endif
 683         printf("dedicated server started, waiting for clients...\nCtrl-C to exit\n\n");
 684         atexit(enet_deinitialize);
 685         atexit(cleanupserver);
 686         enet_time_set(0);
 687         if(*masterpath) updatemasterserver();
 688         for(;;) serverslice(5);
 689     }
 690 }
 691
 692 bool serveroption(char *opt)
 693 {
 694     switch(opt[1])
 695     {
 696         case 'u': uprate = atoi(opt+2); return true;
 697         case 'c':
 698         {
 699             int clients = atoi(opt+2);
 700             if(clients > 0) maxclients = min(clients, MAXCLIENTS);
 701             else maxclients = DEFAULTCLIENTS;
 702             return true;
 703         }
 704         case 'i': ip = opt+2; return true;
 705         case 'm': master = opt+2; return true;
 706         case 'g': game = opt+2; return true;
 707         default: return false;
 708     }
 709 }
 710
 711 #ifdef STANDALONE
 712 int main(int argc, char* argv[])
 713 {
 714     for(int i = 1; i<argc; i++) if(argv[i][0]!='-' || !serveroption(argv[i])) gameargs.add(argv[i]);
 715     if(enet_initialize()<0) fatal("Unable to initialise network module");
 716     initserver(true);
 717     return 0;
 718 }
 719 #endif