dek.c

   1 #include <string.h>
   2 #include <stdarg.h>
   3 #include "shogi.h"
   4
   5 #if defined(DEKUNOBOU)
   6
   7 int
   8 dek_start( const char *str_addr, int port_dek, int port_bnz )
   9 {
  10   SOCKADDR_IN service;
  11   WSADATA wsaData;
  12   u_short dek_ns_bnz;
  13
  14   /* initialize winsock */
  15   if ( WSAStartup( MAKEWORD(1,1), &wsaData ) )
  16     {
  17       str_error = "WSAStartup() failed.";
  18       return -2;
  19     }
  20
  21   dek_ul_addr = inet_addr( str_addr );
  22   if ( dek_ul_addr == INADDR_NONE )
  23     {
  24       struct hostent *phe = gethostbyname( str_addr );
  25       if ( ! phe )
  26         {
  27           str_error = str_WSAError( "gethostbyname() faild." );
  28           return -2;
  29         }
  30       dek_ul_addr = *( (u_long *)phe->h_addr_list[0] );
  31     }
  32
  33   dek_ns      = htons( (u_short)port_dek );
  34   dek_ns_bnz  = htons( (u_short)port_bnz );
  35
  36   dek_socket_in = socket( AF_INET, SOCK_STREAM, 0 );
  37   if ( dek_socket_in == INVALID_SOCKET )
  38     {
  39       str_error = str_WSAError( "socket() failed." );
  40       return -2;
  41     }
  42
  43   service.sin_family      = AF_INET;
  44   service.sin_addr.s_addr = dek_ul_addr;
  45   service.sin_port        = dek_ns_bnz;
  46   if ( bind( dek_socket_in, (SOCKADDR *)&service, sizeof(service) )
  47        == SOCKET_ERROR )
  48     {
  49       str_error = "bind() failed.";
  50       return -2;
  51     }
  52
  53   if ( listen( dek_socket_in, 1 ) == SOCKET_ERROR )
  54     {
  55       str_error = "listen() failed.";
  56       return -2;
  57     }
  58
  59   dek_s_accept = (SOCKET)SOCKET_ERROR;
  60
  61   return 1;
  62 }
  63
  64
  65 int
  66 dek_next_game( tree_t * restrict ptree )
  67 {
  68   if ( dek_ngame != 1 && dek_turn )
  69     {
  70       Out( "take a nap ..." );
  71       Sleep( 37000 );
  72       Out( " done\n" );
  73     }
  74
  75   if ( ini_game( ptree, &min_posi_no_handicap, flag_history, NULL, NULL ) < 0
  76        || get_elapsed( &time_turn_start ) < 0
  77        || ( dek_turn && com_turn_start( ptree, 0 ) < 0 ) ) { return -1; }
  78
  79   dek_turn  ^= 1;
  80   dek_ngame += 1;
  81
  82   return 1;
  83 }
  84
  85
  86 int
  87 dek_check( void )
  88 {
  89   struct timeval tv;
  90   fd_set readfds;
  91   int iret;
  92   char ch;
  93
  94   tv.tv_sec = tv.tv_usec = 0;
  95
  96   if ( dek_s_accept == SOCKET_ERROR )
  97     {
  98       FD_ZERO( &readfds );
  99 #if defined(_MSC_VER)
 100 #  pragma warning(disable:4127)
 101 #endif
 102       FD_SET( dek_socket_in, &readfds );
 103 #if defined(_MSC_VER)
 104 #  pragma warning(default:4127)
 105 #endif
 106       iret = select( 1, &readfds, NULL, NULL, &tv );
 107       if ( iret == SOCKET_ERROR )
 108         {
 109           snprintf( str_message, SIZE_MESSAGE,
 110                     "select() with a socket listening failed:%d",
 111                    WSAGetLastError() );
 112           str_error = str_message;
 113           return -1;
 114
 115         }
 116       if ( ! iret ) { return 0; } /* no connection is pending. */
 117
 118       dek_s_accept = accept( dek_socket_in, NULL, NULL );
 119       if ( dek_s_accept == SOCKET_ERROR )
 120         {
 121           snprintf( str_message, SIZE_MESSAGE,
 122                     "accept() following select() failed:%d",
 123                    WSAGetLastError() );
 124           str_error = str_message;
 125           return -1;
 126         }
 127     }
 128
 129   FD_ZERO( &readfds );
 130 #if defined(_MSC_VER)
 131 #  pragma warning(disable:4127)
 132 #endif
 133   FD_SET( dek_s_accept, &readfds );
 134 #if defined(_MSC_VER)
 135 #  pragma warning(default:4127)
 136 #endif
 137
 138   iret = select( 0, &readfds, NULL, NULL, &tv );
 139   if ( iret == SOCKET_ERROR )
 140     {
 141       snprintf( str_message, SIZE_MESSAGE,
 142                 "select() with a socket accepted failed:%d",
 143                 WSAGetLastError() );
 144       str_error = str_message;
 145       return -1;
 146     }
 147   if ( ! iret ) { return 0; } /* the connection isn't closed,
 148                                  nor has available data. */
 149
 150   iret = recv( dek_s_accept, &ch, 1, MSG_PEEK );
 151   if ( iret == SOCKET_ERROR )
 152     {
 153       closesocket( dek_s_accept );
 154       dek_s_accept = (SOCKET)SOCKET_ERROR;
 155       snprintf( str_message, SIZE_MESSAGE,
 156                 "recv() with flag MSG_PEEK failed:%d",
 157                 WSAGetLastError() );
 158       str_error = str_message;
 159       return -1;
 160     }
 161   if ( ! iret )
 162     {
 163       if ( closesocket( dek_s_accept ) )
 164         {
 165           dek_s_accept = (SOCKET)SOCKET_ERROR;
 166           snprintf( str_message, SIZE_MESSAGE,
 167                     "closesocket() failed:%d", WSAGetLastError() );
 168           str_error = str_message;
 169           return -1;
 170         }
 171       dek_s_accept = (SOCKET)SOCKET_ERROR;
 172       return 0; /* the connection has been closed. */
 173     }
 174
 175   return 1; /* data is available for reading. */
 176 }
 177
 178
 179 int
 180 dek_in( char *str, int n )
 181 {
 182 #if defined(_MSC_VER)
 183 #  pragma warning(disable:4127)
 184 #endif
 185   int count_byte;
 186
 187   for (;;) {
 188     if ( dek_s_accept == SOCKET_ERROR )
 189       {
 190         Out( "\nwait for new connection...\n" );
 191         dek_s_accept = accept( dek_socket_in, NULL, NULL );
 192         if ( dek_s_accept == SOCKET_ERROR )
 193           {
 194             str_error = str_WSAError( "accept() failed." );
 195             return -1;
 196           }
 197       }
 198
 199     count_byte = recv( dek_s_accept, str, n, 0 );
 200     if ( count_byte == SOCKET_ERROR )
 201       {
 202         closesocket( dek_s_accept );
 203         dek_s_accept = (SOCKET)SOCKET_ERROR;
 204         str_error = str_WSAError( "recv() failed." );
 205         return -1;
 206       }
 207     if ( count_byte ) { break; }
 208
 209     if ( closesocket( dek_s_accept ) )
 210       {
 211         dek_s_accept = (SOCKET)SOCKET_ERROR;
 212         str_error = str_WSAError( "closesocket() failed." );
 213         return -1;
 214       }
 215     dek_s_accept = (SOCKET)SOCKET_ERROR;
 216   }
 217
 218   *( str + count_byte ) = '\0';
 219   Out( "recieved %s", str );
 220
 221   return count_byte;
 222 #if defined(_MSC_VER)
 223 #  pragma warning(default:4127)
 224 #endif
 225 }
 226
 227
 228 int
 229 dek_out( const char *format, ... )
 230 {
 231   SOCKADDR_IN service;
 232   SOCKET socket_out;
 233   int nch, iret;
 234   char buf[256];
 235   va_list arg;
 236
 237   va_start( arg, format );
 238   nch = vsnprintf( buf, 256, format, arg );
 239   va_end( arg );
 240
 241   Out( "send %s", buf );
 242
 243   socket_out = socket( AF_INET, SOCK_STREAM, 0 );
 244   if ( socket_out == INVALID_SOCKET )
 245     {
 246       snprintf( str_message, SIZE_MESSAGE,
 247                 "socket() failed:%d", WSAGetLastError() );
 248       str_error = str_message;
 249       return -2;
 250     }
 251
 252   service.sin_family      = AF_INET;
 253   service.sin_addr.s_addr = dek_ul_addr;
 254   service.sin_port        = dek_ns;
 255   if ( connect( socket_out, (SOCKADDR *)&service, sizeof(service) )
 256        == SOCKET_ERROR )
 257     {
 258       snprintf( str_message, SIZE_MESSAGE,
 259                 "connect() failed:%d", WSAGetLastError() );
 260       str_error = str_message;
 261       return -2;
 262     }
 263
 264   iret = send( socket_out, buf, nch, 0 );
 265   if ( iret == SOCKET_ERROR )
 266     {
 267       closesocket( socket_out );
 268       snprintf( str_message, SIZE_MESSAGE,
 269                 "send() failed:%d", WSAGetLastError() );
 270       str_error = str_message;
 271       return -2;
 272     }
 273   if ( iret != nch )
 274     {
 275       closesocket( socket_out );
 276       str_error = "send() wrote partial number of bytes.";
 277       return -2;
 278     }
 279
 280   if ( closesocket( socket_out ) )
 281     {
 282       snprintf( str_message, SIZE_MESSAGE,
 283                 "closesocket() failed:%d", WSAGetLastError() );
 284       str_error = str_message;
 285       return -2;
 286     }
 287
 288   return 1;
 289 }
 290
 291 int
 292 dek_parse( char *str, int len )
 293 {
 294   if ( *str == '+' || *str == '-' )
 295     {
 296       memmove( str, str+1, 6 );
 297       str[6] = '\0';
 298     }
 299   else if ( ! strcmp( str, str_resign ) )
 300     {
 301       strncpy( str, "resign", len-1 );
 302       str[len-1] = '\0';
 303       dek_win += 1;
 304       Out( "Bonanza won against Dekunobou\n" );
 305     }
 306   else {
 307     str_error = "unknown command is recieved from Deknobou.";
 308     return -2;
 309   }
 310
 311   return 1;
 312 }
 313
 314 #  endif /* DEKUNOBOU */