home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume11 / bt / part02 / interface.c next >
C/C++ Source or Header  |  1990-12-11  |  9KB  |  419 lines
  1.  
  2. /* interface.c: Socket communications support& medium- level message
  3.  * passing functions. Copyright (C) 1990 Tom Boutell on original portions.
  4.  * All low- level socket code drawn with appreciation from:
  5.  * SOCK.C
  6.  * Copyright (C)1989 Dr Evil Laboratories
  7.  * This code written by Ray Moody, Roy Riggs, Mitch Adler,
  8.  * Bill Burdick, and Steven Grady
  9.  * No one makes any guarantees about anything.  This file maybe 
  10.  * freely distributed and modified as long as this header remains intact.  
  11.  */
  12.  
  13. #include <stdio.h>
  14. #include <sys/types.h>
  15. #include <sys/time.h>
  16. #include <sys/socket.h>
  17. #include <netinet/in.h>
  18. #include <string.h>
  19. #include <ctype.h>
  20. #include <signal.h>
  21. #include <netdb.h>
  22. #include <varargs.h>
  23.  
  24. #include "types.h"
  25. #include "pack.h"
  26. #include "bt.h"
  27. #include "interface.h"
  28.  
  29. #define DEBUG
  30. #undef DEBUG
  31. #ifdef DEBUG
  32. #define debug printf
  33. #else
  34. #define debug 0+
  35. #define perror 0+
  36. #endif
  37.  
  38. #define SECONDSLIMIT 0L
  39. #define MICROSECONDSLIMIT 1L
  40.  
  41. #define LINE_LEN 1024
  42. #define LOST_CARRIER_MSG "F"
  43.  
  44. #define NONE (fd_set *) NULL
  45. #define NEVER (struct timeval *) NULL
  46. #define IGNORE (struct sockaddr *) NULL
  47.  
  48. fd_set active;
  49. struct sockaddr_in sc_in;
  50. int s;
  51. char cur_input[LINE_LEN];
  52. char *curhostname = "";
  53. int playerids[20];
  54. char outputline[256];
  55. void setupinterface() {
  56.   int current;
  57.   init_socket(2727);
  58.   playertext=(outputline+1);
  59.   for (current=1; (current<=totalplayers); current++) {
  60.     playerids[current]=new_player(0);
  61.     players[current].live=1;
  62.     printf("Player %d has joined.\n",current);
  63.     outputline[0]=_YOUARE;
  64.     outputline[1]=64+current;
  65.     outputline[2]=0;
  66.     w_p(playerids[current],outputline,strlen(&outputline[0])+1);
  67.     }
  68. } 
  69.  
  70. void tellplayer(player)
  71.   int player;
  72. {
  73.   outputline[0]=_TEXT;
  74.   w_p(playerids[player],outputline,strlen(&outputline[0])+1);
  75. } 
  76.  
  77. void broadcast(messagetype,details)
  78.   char messagetype;
  79.   void* details;
  80. {
  81.   location where;
  82.   int thisplayer;
  83.   int current;
  84.   outputline[0]=messagetype;
  85.   switch (messagetype) {
  86.    
  87.     case _HEXSTATUS:
  88.       where=*(location*)details;
  89.       outputline[1]=64+where.x;
  90.       outputline[2]=64+where.y;
  91.       outputline[3]=64+map[where.x][where.y].terrain;
  92.       packint(4,map[where.x][where.y].population);
  93.       packint(7,map[where.x][where.y].lastuse);
  94.       packint(10,map[where.x][where.y].troops);
  95.       outputline[13]=map[where.x][where.y].owner+64;
  96.       outputline[14]=NULL;
  97.       break;
  98.     case _PLAYERSTATUS:
  99.       thisplayer=*(int*)details;
  100.       outputline[1]=thisplayer+64;
  101.       packint(2,players[thisplayer].action);
  102.       packint(5,players[thisplayer].hexes);
  103.       packint(8,players[thisplayer].troops);
  104.       packint(11,players[thisplayer].population);
  105.       packint(14,players[thisplayer].citadels);
  106.       outputline[17]=players[thisplayer].start.x+64;
  107.       outputline[18]=players[thisplayer].start.y+64;
  108.       outputline[19]=NULL;
  109.       break;
  110.     case _PLAYERDEAD:
  111.       thisplayer=*(int*)details;
  112.       outputline[1]=thisplayer+64;
  113.       outputline[2]=NULL;
  114.       break;
  115.     case _ACTION:
  116.       outputline[1]=NULL;    
  117.       break;
  118.     case _STARTUP:
  119.       outputline[1]=totalplayers+64;
  120.       outputline[2]=NULL;
  121.       break;
  122.     case _TEXT:
  123.       strcpy(&outputline[1],(char*) details);
  124.       break;
  125.     case _END:
  126.       outputline[1]=NULL;
  127.   }
  128.   for (current=0; (current<=totalplayers); current++) {
  129.     if (outputline[0]==_END) {
  130.     }
  131.     if (players[current].live) {
  132.       w_p(playerids[current],outputline,strlen(outputline)+1); 
  133.     }   
  134.   }
  135. }    
  136.  
  137. int getrequest(thisplayer,requesttype,specific)
  138.   int* thisplayer;
  139.   char* requesttype;
  140.   char* specific;
  141. {
  142.   char* received;
  143.   static int sweep;
  144.   int oldsweep;
  145.   sweep++;
  146.   if ((sweep>totalplayers) || (sweep<=0))
  147.     sweep=1;
  148.   oldsweep=sweep;
  149.   while (players[sweep].live==0) {
  150.     sweep++;
  151.     if (sweep>totalplayers)
  152.       sweep=1;
  153.     if (sweep==oldsweep)
  154.       return 0;
  155.   }
  156.   received=read_player(playerids[sweep]);
  157.   *thisplayer=sweep;
  158.   if (*received==NULL)
  159.     return 0;
  160.   *requesttype=received[0];
  161.   strcpy(specific,(received+=1));
  162.   return 1;
  163.   }           
  164.  
  165.  
  166. void shutdowninterface() {
  167.   disconnect_all();
  168. }
  169.   
  170.  
  171. /* - PD Socket code begins here.
  172.  * init_socket() - intialize our socket, port is the port number to use
  173.  *                 call this once at the beginning of your code
  174.  */
  175.  
  176. int init_socket(port)
  177.     int port;
  178. {
  179.     setbuf(stdout, (char *)0);
  180.     if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
  181.         perror("socket");
  182.         return 0;
  183.     }
  184.     sc_in.sin_family = AF_INET;
  185.     sc_in.sin_addr.s_addr = INADDR_ANY;
  186.     sc_in.sin_port = htons((u_short) port);
  187.     if (bind(s, (struct sockaddr *) &sc_in, sizeof(sc_in)) < 0) {
  188.         perror("bind");
  189.         return 0;
  190.     }
  191.     if (listen(s, 5) < 0) {
  192.         perror("listen");
  193.         return 0;
  194.     }
  195.  
  196.     FD_ZERO(&active);
  197.  
  198.     return 1;
  199. }
  200.  
  201.  
  202. /*
  203.  * disconnect_all() - throws everyone off
  204.  */
  205.  
  206. int disconnect_all()
  207. {
  208.     register int i;
  209.     
  210.     for (i = 0; i < FD_SETSIZE; i++) {
  211.         if (FD_ISSET(i, &active))
  212.             (void) disconnect(i);
  213.     }
  214.     return 1;
  215. }
  216.  
  217.  
  218. /*
  219.  * shut-down -- kills all connections and exits the pgm
  220.  */
  221.  
  222. int shut_down()
  223. {
  224.     (void) disconnect_all();
  225.     exit(0);
  226. }
  227.  
  228.  
  229. /* hostfrom() - returns a string containing an ascii name for the host
  230.  *              that the passed socket s is connected to.  Note that the
  231.  *              string is in static space.  If you want to munge with it,
  232.  *              make a copy.
  233.  */
  234.  
  235. char *hostfrom(i)
  236.     int i;
  237. {
  238.     struct sockaddr_in from;
  239.     int fromlen = sizeof(from);
  240.     struct hostent *host;
  241.     struct in_addr addr;
  242.  
  243.     if (getpeername(i, &from, &fromlen) < 0) {
  244.         perror("getpeername");
  245.         return NULL;
  246.     }
  247.     
  248.     addr = from.sin_addr;
  249.     if ((host = gethostbyaddr(&addr, sizeof(addr), AF_INET)) == NULL) {
  250.         debug("gethostbyaddr failed");
  251.         return NULL;
  252.     }
  253.         
  254.     return curhostname = host->h_name;
  255. }
  256.  
  257.  
  258. /*
  259.  * hostname() - returns curhostname
  260.  */
  261.  
  262. char *hostname()
  263. {
  264.     return curhostname;
  265. }
  266.  
  267.  
  268. /*
  269.  * new_player() - call this routine in your main loop to allow new
  270.  *                players to join.  returns a playerId or -1 if no one
  271.  *                wants to join.
  272.  *                if wait == 0, then put your process to sleep until
  273.  *                someone new tries to connect.
  274.  */
  275.  
  276. int new_player(wait)
  277.     int wait;   /* 0 - wait for activity, else don't wait */
  278. {
  279.     fd_set readfds;
  280.     int j;
  281.     struct timeval *pWaitTime, waitTime;
  282.  
  283.     pWaitTime = &waitTime;
  284.     
  285.     if (0 == wait) {
  286.         pWaitTime = NEVER;
  287.     } else {
  288.         pWaitTime->tv_sec = SECONDSLIMIT;
  289.         pWaitTime->tv_usec = MICROSECONDSLIMIT;
  290.     }
  291.  
  292.     bcopy((char *) &active, (char *) &readfds, sizeof(active));
  293.  
  294.     FD_SET(s, &readfds);
  295.  
  296.     if (select(FD_SETSIZE, &readfds, NONE, NONE, pWaitTime) < 0) {
  297.         perror("select");
  298.         return -1;
  299.     }
  300.     if (FD_ISSET(s, &readfds)) {
  301.         if ((j = accept(s, IGNORE, (int *) 0)) < 0) {
  302.             return -1;
  303.         }
  304.         FD_SET(j, &active);
  305.         curhostname = hostfrom(j);
  306.         debug("Test Host=%s\n", curhostname);
  307.         return j;
  308.     } else {
  309.         return -1;
  310.     }
  311. }
  312.  
  313.  
  314. /*
  315.  * disconnect() - drop the player with the given id
  316.  */
  317.  
  318. int disconnect(id)
  319.     int id;
  320. {
  321.     if (FD_ISSET(id, &active)) {
  322.         debug("** Just dropped %d\n", id);
  323.         FD_CLR(id, &active);
  324.         if (close(id) < 0) {
  325.             perror("close");
  326.             return 0;
  327.         }
  328.     } else {
  329.         debug("** Just tried to drop someone not connected\n");
  330.         return 0;
  331.     }
  332.     return 1;
  333. }
  334.  
  335.  
  336. /*
  337.  * read_player() - This routine returns the next string from the player
  338.  *                 connected to descriptor playerFd. If there is no
  339.  *                 input it returns the empty string. If the connection
  340.  *                 is lost the string LOST_CARRIER_MSG is returned.
  341.  *                 NOTE: control characters are replaced by spaces
  342.  *                       and it is null terminated at the first nl/cr
  343.  */
  344.  
  345. char *read_player(playerFd)
  346.     int playerFd;
  347. {
  348.     fd_set readfds;
  349.     struct timeval waitTime;
  350.     
  351.     waitTime.tv_sec = SECONDSLIMIT;
  352.     waitTime.tv_usec = MICROSECONDSLIMIT;
  353.  
  354.     bcopy((char *) &active, (char *) &readfds, sizeof(active));
  355.  
  356.     if (select(FD_SETSIZE, &readfds, NONE, NONE, &waitTime) < 0) {
  357.         perror("select");
  358.         return("");
  359.     }
  360.  
  361.     if (FD_ISSET(playerFd, &readfds)) {
  362.         int nbytes, i;
  363.         
  364.         nbytes = read(playerFd, cur_input, LINE_LEN);
  365.         if (nbytes < 0) {
  366.             perror("read");
  367.             disconnect(playerFd);
  368.             return(LOST_CARRIER_MSG);
  369.         } else if (nbytes == 0) {
  370.             disconnect(playerFd);
  371.             return(LOST_CARRIER_MSG);
  372.         } else {
  373. /* Don't need control editing    for(i=0; i<nbytes; ++i) {
  374.                 if (iscntrl(cur_input[i])) {
  375.                     if (cur_input[i]=='\n' ||
  376.                         cur_input[i]=='\r')
  377.                         cur_input[i] = '\n';
  378.                     else
  379.                         cur_input[i] = ' ';
  380.                 }
  381.             }
  382. */
  383.             if (nbytes != LINE_LEN) {
  384.                 cur_input[nbytes] = '\0';
  385.             } else {
  386.                 cur_input[LINE_LEN - 1] = '\0';
  387.             }
  388.  
  389.             return((char *) cur_input);
  390.         }
  391.     }
  392.     return("");
  393. }
  394.  
  395.  
  396. /*
  397.  * write_player() - write to id, a string with the given length
  398.  */
  399.  
  400. int w_p(id, str, len)
  401.     int id, len;
  402.     char *str;
  403. {
  404.     if (id > -1) {
  405.         if (!FD_ISSET(id, &active)) {
  406.             debug("** Tried to write to closed id #%d.\n", id);
  407.             return 0;
  408.         } else if (write(id, str, len) < 0) {
  409.             perror("Write");
  410.             return 0;
  411.         }
  412.     }
  413.     return 1;
  414. }
  415.  
  416.  
  417.  
  418.  
  419.