src/client/client.c

   1 #include <assert.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4
   5 #include <fcntl.h>
   6 #include <sys/types.h>
   7 #include <sys/time.h>
   8
   9 #ifndef __WIN32__
  10 #include <sys/ioctl.h>
  11 #include <sys/socket.h>
  12 #include <sys/select.h>
  13 #else /* __WIN32__ */
  14 #include <io.h>
  15 #include <winsock2.h>
  16 #endif /* __WIN32__ */
  17
  18 #include "main.h"
  19 #include "list.h"
  20 #include "tux.h"
  21 #include "proto.h"
  22
  23 #include "client.h"
  24
  25 #include "analyze.h"
  26 #include "world.h"
  27 #include "buffer.h"
  28
  29 #include "udp.h"
  30
  31 static sock_udp_t *sock_server_udp;
  32
  33 static list_t *listRecvMsg;
  34
  35 static buffer_t *clientRecvBuffer;
  36 static buffer_t *clientSendBuffer;
  37
  38 static my_time_t lastPing;
  39 static my_time_t lastPingServerAlive;
  40
  41 #ifdef SUPPORT_TRAFFIC
  42 static my_time_t lastTraffic;
  43 static int traffic_down;
  44 static int traffic_up;
  45 #endif /* SUPPORT_TRAFFIC */
  46
  47 typedef struct proto_cmd_client_struct {
  48         char *name;
  49         int len;
  50         void (*fce_proto) (char *msg);
  51 } proto_cmd_client_t;
  52
  53 static proto_cmd_client_t proto_cmd_list[] = {
  54         {.name = "error",.len = 5,.fce_proto = proto_recv_error_client},
  55         {.name = "init",.len = 4,.fce_proto = proto_recv_init_client},
  56         {.name = "event",.len = 5,.fce_proto = proto_recv_event_client},
  57         {.name = "newtux",.len = 6,.fce_proto = proto_recv_newtux_client},
  58         {.name = "del",.len = 3,.fce_proto = proto_recv_del_client},
  59         {.name = "additem",.len = 7,.fce_proto = proto_recv_additem_client},
  60         {.name = "shot",.len = 4,.fce_proto = proto_recv_shot_client},
  61         {.name = "kill",.len = 4,.fce_proto = proto_recv_kill_client},
  62         {.name = "module",.len = 6,.fce_proto = proto_recv_module_client},
  63         {.name = "chat",.len = 4,.fce_proto = proto_recv_chat_client},
  64         {.name = "ping",.len = 4,.fce_proto = proto_recv_ping_client},
  65         {.name = "end",.len = 3,.fce_proto = proto_recv_end_client},
  66         {.name = "",.len = 0,.fce_proto = NULL}
  67 };
  68
  69 static proto_cmd_client_t *findCmdProto(char *msg)
  70 {
  71         int len;
  72         int i;
  73
  74         len = strlen(msg);
  75
  76         for (i = 0; proto_cmd_list[i].len != 0; i++) {
  77                 proto_cmd_client_t *thisCmd;
  78
  79                 thisCmd = &proto_cmd_list[i];
  80
  81                 if (len >= thisCmd->len &&
  82                     strncmp(msg, thisCmd->name, thisCmd->len) == 0) {
  83                         return thisCmd;
  84                 }
  85         }
  86
  87         return NULL;
  88 }
  89
  90 static int initUdpClient(char *ip, int port)
  91 {
  92         sock_server_udp = sock_udp_connect(ip, port);
  93
  94         if (sock_server_udp == NULL) {
  95                 return -1;
  96         }
  97
  98         debug("Connected to game server [%s]:[%d]", ip, port);
  99
 100         return 0;
 101 }
 102
 103 int client_init(char *ip, int port)
 104 {
 105         char name[STR_NAME_SIZE];
 106         int ret;
 107
 108         listRecvMsg = list_new();
 109         lastPing = timer_get_current_time();
 110         lastPingServerAlive = timer_get_current_time();
 111
 112 #ifdef SUPPORT_TRAFFIC
 113         lastTraffic = timer_get_current_time();
 114         traffic_down = 0;
 115         traffic_up = 0;
 116 #endif /* SUPPORT_TRAFFIC */
 117
 118         clientRecvBuffer = buffer_new(CLIENT_BUFFER_LIMIT);
 119         clientSendBuffer = buffer_new(CLIENT_BUFFER_LIMIT);
 120
 121         ret = initUdpClient(ip, port);
 122
 123         if (ret < 0) {
 124                 return -1;
 125         }
 126
 127         public_server_get_setting_name_right(name);
 128         proto_send_hello_client(name);
 129
 130         return 0;
 131 }
 132
 133 static void errorWithServer()
 134 {
 135         error("Game server is not responding");
 136         analyze_set_msg(_("Unable to connect to the game server"));
 137         world_do_end();
 138 }
 139
 140 void client_send(char *msg)
 141 {
 142         int ret;
 143
 144         assert(msg != NULL);
 145
 146         ret = -1;
 147
 148         if (isParamFlag("--send")) {
 149                 debug("Sending data: %s", msg);
 150         }
 151
 152 #ifdef SUPPORT_TRAFFIC
 153         traffic_up += strlen(msg);
 154 #endif /* SUPPORT_TRAFFIC */
 155
 156         if (sock_server_udp != NULL) {
 157                 ret = sock_udp_write(sock_server_udp, sock_server_udp, msg, strlen(msg));
 158         }
 159
 160         if (ret < 0) {
 161                 errorWithServer();
 162                 return;
 163         }
 164 }
 165
 166 static int server_eventSelect()
 167 {
 168         char buffer[STR_PROTO_SIZE];
 169         int ret;
 170
 171         memset(buffer, 0, STR_PROTO_SIZE);
 172         ret = -1;
 173
 174         if (sock_server_udp != NULL) {
 175                 ret = sock_udp_read(sock_server_udp, sock_server_udp, buffer, STR_PROTO_SIZE - 1);
 176         }
 177
 178         if (ret < 0) {
 179                 errorWithServer();
 180                 return ret;
 181         }
 182
 183 #ifdef SUPPORT_TRAFFIC
 184         traffic_down += ret;
 185 #endif /* SUPPORT_TRAFFIC */
 186
 187         list_add(listRecvMsg, strdup(buffer));
 188
 189         return ret;
 190 }
 191
 192 static void client_eventWorkRecvList()
 193 {
 194         proto_cmd_client_t *protoCmd;
 195         char *line;
 196         int i;
 197
 198         /* processing of an event received from a game server */
 199
 200         assert(listRecvMsg != NULL);
 201
 202         for (i = 0; i < listRecvMsg->count; i++) {
 203                 line = (char *) listRecvMsg->list[i];
 204                 protoCmd = findCmdProto(line);
 205
 206                 if (isParamFlag("--recv")) {
 207                         debug("Recieved data: %s", line);
 208                 }
 209
 210                 if (protoCmd != NULL) {
 211                         protoCmd->fce_proto(line);
 212                         lastPingServerAlive = timer_get_current_time();
 213                 }
 214         }
 215
 216         list_destroy_item(listRecvMsg, free);
 217         listRecvMsg = list_new();
 218 }
 219
 220 static void eventPingServer()
 221 {
 222         my_time_t currentTime;
 223
 224         currentTime = timer_get_current_time();
 225
 226         if (currentTime - lastPing > CLIENT_TIMEOUT) {
 227                 proto_send_ping_client();
 228                 lastPing = timer_get_current_time();
 229         }
 230 }
 231
 232 static bool_t isServerAlive()
 233 {
 234         my_time_t currentTime;
 235
 236         currentTime = timer_get_current_time();
 237
 238         if (currentTime - lastPingServerAlive > SERVER_TIMEOUT_ALIVE) {
 239                 return FALSE;
 240         }
 241
 242         return TRUE;
 243 }
 244
 245 static void selectClientSocket()
 246 {
 247         fd_set readfds;
 248         struct timeval tv;
 249         int max_fd;
 250         int sock;
 251         bool_t isNext;
 252
 253         max_fd = 0;
 254         sock = 0;
 255
 256         if (sock_server_udp != NULL) {
 257                 if (isServerAlive() == FALSE) {
 258                         errorWithServer();
 259                         return;
 260                 }
 261         }
 262
 263         do {
 264                 isNext = FALSE;
 265
 266                 tv.tv_sec = 0;
 267                 tv.tv_usec = 0;
 268
 269                 FD_ZERO(&readfds);
 270
 271                 if (sock_server_udp != NULL) {
 272                         sock = sock_server_udp->sock;
 273                 }
 274
 275                 FD_SET(sock, &readfds);
 276                 max_fd = sock;
 277                 select(max_fd + 1, &readfds, (fd_set *) NULL, (fd_set *) NULL, &tv);
 278
 279                 if (FD_ISSET(sock, &readfds)) {
 280                         if (server_eventSelect() > 0) {
 281                                 isNext = TRUE;
 282                         }
 283                 }
 284
 285         } while (isNext == TRUE);
 286 }
 287
 288 #ifdef SUPPORT_TRAFFIC
 289 static void eventTraffic()
 290 {
 291         my_time_t currentTime;
 292
 293         currentTime = timer_get_current_time();
 294
 295         if (currentTime - lastTraffic > 5000) {
 296                 lastTraffic = currentTime;
 297
 298                 debug("Traffic: down [%d]/up [%d]", traffic_down, traffic_up);
 299
 300                 traffic_down = 0;
 301                 traffic_up = 0;
 302         }
 303 }
 304 #endif /* SUPPORT_TRAFFIC */
 305
 306 void client_event()
 307 {
 308 #ifdef SUPPORT_TRAFFIC
 309         eventTraffic();
 310 #endif /* SUPPORT_TRAFFIC */
 311
 312         eventPingServer();
 313         selectClientSocket();
 314         client_eventWorkRecvList();
 315 }
 316
 317 static void quitUdpClient()
 318 {
 319         assert(sock_server_udp != NULL);
 320         sock_udp_close(sock_server_udp);
 321
 322         debug("Closing connection to game server");
 323 }
 324
 325 void client_quit()
 326 {
 327         proto_send_end_client();
 328
 329         assert(listRecvMsg != NULL);
 330
 331         list_destroy_item(listRecvMsg, free);
 332         buffer_destroy(clientRecvBuffer);
 333         buffer_destroy(clientSendBuffer);
 334
 335         if (sock_server_udp != NULL) {
 336                 quitUdpClient();
 337         }
 338 }