net.c

   1 /*
   2   Pacman Arena
   3   Copyright (C) 2003 Nuno Subtil
   4
   5   This program is free software; you can redistribute it and/or
   6   modify it under the terms of the GNU General Public License
   7   as published by the Free Software Foundation; either version 2
   8   of the License, or (at your option) any later version.
   9
  10   This program is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program; if not, write to the Free Software
  17   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18 */
  19
  20 static const char cvsid[] =
  21   "$Id: net.c,v 1.4 2003/11/27 22:39:11 nsubtil Exp $";
  22
  23 #include "config.h"
  24
  25 #include <SDL_net.h>
  26 #include <stdlib.h>
  27
  28 #include "audio.h"
  29 #include "net.h"
  30
  31 static UDPsocket sock = NULL;
  32 static IPaddress srv_addr;
  33 static UDPpacket *packet = NULL;
  34
  35 int server_running = 0;
  36 int client_running = 0;
  37
  38 /*
  39   starts a listener for the network server
  40 */
  41 void net_server_init(void)
  42 {
  43         if(sock == NULL)
  44                 SDLNet_Init();
  45
  46         sock = SDLNet_UDP_Open(NET_PACMAN_PORT);
  47         if(sock == NULL)
  48         {
  49                 printf("net_server_init: SDLNet_UDP_Open: %s\n", SDLNet_GetError());
  50                 SDL_Quit();
  51                 exit(1);
  52         }
  53
  54         if(packet == NULL)
  55         {
  56                 packet = SDLNet_AllocPacket(NET_MAX_PACKET_SIZE);
  57                 if(packet == NULL)
  58                 {
  59                         printf("net_send_packet: SDLNet_AllocPacket: %s\n", SDLNet_GetError());
  60                         SDL_Quit();
  61                         exit(1);
  62                 }
  63         }
  64
  65         printf("net_server_init: listening on port %d\n", NET_PACMAN_PORT);
  66         server_running = 1;
  67 }
  68
  69 /*
  70   connects to a server on a given host
  71 */
  72 void net_client_init(char *hostname)
  73 {
  74         struct packet_r_connok p;
  75
  76         if(packet == NULL)
  77         {
  78                 SDLNet_Init();
  79                 packet = SDLNet_AllocPacket(NET_MAX_PACKET_SIZE);
  80                 if(packet == NULL)
  81                 {
  82                         printf("net_send_packet: SDLNet_AllocPacket: %s\n", SDLNet_GetError());
  83                         SDL_Quit();
  84                         exit(1);
  85                 }
  86         }
  87
  88         sock = SDLNet_UDP_Open(0);
  89         if(sock == NULL)
  90         {
  91                 printf("net_client_init: SDLNet_UDP_Open: %s\n", SDLNet_GetError());
  92                 SDL_Quit();
  93                 exit(1);
  94         }
  95
  96         if(SDLNet_ResolveHost(&srv_addr, hostname, NET_PACMAN_PORT) == -1)
  97         {
  98                 printf("net_client_init: SDLNet_ResolveHost(%s): %s\n", hostname, SDLNet_GetError());
  99                 SDL_Quit();
 100                 exit(1);
 101         }
 102
 103         if(SDLNet_UDP_Bind(sock, 0, &srv_addr) == -1)
 104         {
 105                 printf("net_client_init: SDLNet_UDP_Bind: %s\n", SDLNet_GetError());
 106                 SDL_Quit();
 107                 exit(1);
 108         }
 109
 110         printf("net_client_init: connecting to %s port %d...\n", hostname, NET_PACMAN_PORT);
 111         /* send a connection packet */
 112         net_send_packet(sock, PTYPE_REQ_NEWCONN, NULL, srv_addr);
 113         /* wait for reply */
 114         net_wait_packet(sock, packet);
 115
 116         if(net_decode_ptype(packet) != PTYPE_REPLY_CONNOK)
 117         {
 118                 printf("net_client_init: connection refused\n");
 119                 SDL_Quit();
 120                 exit(1);
 121         }
 122
 123         net_decode_pdata(packet, &p);
 124         printf("net_client_init: connection established, id %d\n", p.player_id);
 125
 126         client_running = 1;
 127 }
 128
 129 /*
 130   waits for a packet
 131 */
 132 void net_wait_packet(UDPsocket usock, UDPpacket *pack)
 133 {
 134         while(SDLNet_UDP_Recv(usock, pack) != 1)
 135                 SDL_Delay(1);
 136 }
 137
 138 /*
 139   builds and sends a packet of a given type to a destination
 140 */
 141 void net_send_packet(UDPsocket usock, Uint8 ptype, void *pdata, IPaddress dest)
 142 {
 143         packet->len = 0;
 144         net_encode(packet, ptype, pdata);
 145         packet->address = dest;
 146         if(SDLNet_UDP_Send(usock, -1, packet) == 0)
 147         {
 148                 printf("net_send_packet: SDLNet_UDP_Send: %s\n", SDLNet_GetError());
 149                 SDL_Quit();
 150                 exit(1);
 151         }
 152 }
 153
 154 /*
 155   encodes a packet of a given type
 156 */
 157 void net_encode(UDPpacket *pack, Uint8 ptype, void *pdata)
 158 {
 159         /*
 160           packet structure:
 161           - packet type (1 byte)
 162           - packet flags (1 byte)
 163           - packet data (variable)
 164         */
 165
 166         /* packet type */
 167         net_pack_byte(pack, ptype);
 168         /* packet flags */
 169         net_pack_byte(pack, 0);
 170
 171         switch(ptype)
 172         {
 173         case PTYPE_REQ_NEWCONN:
 174                 /* nothing */
 175                 break;
 176
 177         case PTYPE_REPLY_CONNOK:
 178         {
 179                 struct packet_r_connok *p;
 180
 181                 p = (struct packet_r_connok *)pdata;
 182                 net_pack_int32(pack, p->player_id);
 183
 184                 break;
 185         }
 186
 187         default:
 188                 printf("net_send_packet: unknown ptype %d\n", ptype);
 189                 SDL_Quit();
 190                 exit(1);
 191         }
 192 }
 193
 194 /*
 195   decodes the packet type
 196   returns the type of packet, or -1 on error
 197 */
 198 int net_decode_ptype(UDPpacket *pack)
 199 {
 200         switch(pack->data[0])
 201         {
 202         case PTYPE_REQ_NEWCONN:
 203                 return PTYPE_REQ_NEWCONN;
 204
 205         case PTYPE_REPLY_CONNOK:
 206                 return PTYPE_REPLY_CONNOK;
 207
 208         default:
 209                 return -1;
 210         }
 211 }
 212
 213 /*
 214   decodes the data in pack
 215 */
 216 void net_decode_pdata(UDPpacket *pack, void *data)
 217 {
 218         switch(pack->data[0])
 219         {
 220         case PTYPE_REQ_NEWCONN:
 221                 return;
 222
 223         case PTYPE_REPLY_CONNOK:
 224         {
 225                 struct packet_r_connok *p;
 226
 227                 p = (struct packet_r_connok *)data;
 228
 229                 p->player_id = SDLNet_Read32(&pack->data[2]);
 230
 231                 return;
 232         }
 233         }
 234 }
 235
 236 /*
 237   packs a byte on the end of a packet
 238 */
 239 void net_pack_byte(UDPpacket *pack, Uint8 value)
 240 {
 241         if(pack->len + 1 > pack->maxlen)
 242         {
 243                 printf("net_pack_byte: packet too small (%d)\n", pack->maxlen);
 244                 SDL_Quit();
 245                 exit(1);
 246         }
 247
 248         pack->data[pack->len] = value;
 249         pack->len++;
 250 }
 251
 252 /*
 253   packs a 32-bit value on the end of a packet
 254 */
 255 void net_pack_int32(UDPpacket *pack, Uint32 value)
 256 {
 257         if(pack->len + 4 > pack->maxlen)
 258         {
 259                 printf("net_pack_int32: packet too small (%d)\n", pack->maxlen);
 260                 SDL_Quit();
 261                 exit(1);
 262         }
 263
 264         SDLNet_Write32(value, &pack->data[pack->len]);
 265         pack->len += 4;
 266 }
 267
 268 /*
 269   updates the server
 270 */
 271 void net_server_update(void)
 272 {
 273         while(SDLNet_UDP_Recv(sock, packet) == 1)
 274         {
 275                 switch(net_decode_ptype(packet))
 276                 {
 277                 case PTYPE_REQ_NEWCONN:
 278                 {
 279                         struct packet_r_connok p = {1};
 280
 281                         printf("net_server_update: new connection from %s\n", SDLNet_ResolveIP(&packet->address));
 282                         audio_play_sample("sfx/ghost-return.wav");
 283                         net_send_packet(sock, PTYPE_REPLY_CONNOK, &p, packet->address);
 284                 }
 285                 }
 286         }
 287 }
 288
 289 /*
 290   updates the client
 291 */
 292 void net_client_update(void)
 293 {
 294 }