src/chuukei.c

   1 /*!
   2     @file chuukei.c
   3     @brief 中継機能の実装
   4     @date 2014/01/02
   5     @author
   6     2014 Deskull rearranged comment for Doxygen.
   7  */
   8
   9 #include "angband.h"
  10
  11 #include <stdio.h>
  12 #include <stdarg.h>
  13 #include <ctype.h>
  14 #ifdef WINDOWS
  15 #include <windows.h>
  16 #endif
  17
  18 #ifdef CHUUKEI
  19 #if defined(WINDOWS)
  20 #include <winsock.h>
  21 #elif defined(MACINTOSH)
  22 #include <OpenTransport.h>
  23 #include <OpenTptInternet.h>
  24 #else
  25 #include <sys/types.h>
  26 #include <sys/socket.h>
  27 #include <netinet/in.h>
  28 #include <netdb.h>
  29 #include <sys/time.h>
  30 #include <arpa/inet.h>
  31
  32 #include <setjmp.h>
  33 #include <signal.h>
  34 #endif
  35
  36 #define MAX_HOSTNAME 256
  37 #endif
  38
  39 #define RINGBUF_SIZE 1024*1024
  40 #define FRESH_QUEUE_SIZE 4096
  41 #ifdef WINDOWS
  42 #define WAIT 100
  43 #else
  44 #define WAIT 100*1000 /* ブラウズ側のウエイト(us単位) */
  45 #endif
  46 #define DEFAULT_DELAY 50
  47 #define RECVBUF_SIZE 1024
  48
  49 static long epoch_time;  /* バッファ開始時刻 */
  50 static int browse_delay; /* 表示するまでの時間(100ms単位)(この間にラグを吸収する) */
  51 #ifdef CHUUKEI
  52 static int sd; /* ソケットのファイルディスクリプタ */
  53 static long time_diff;   /* プレイ側との時間のずれ(これを見ながらディレイを調整していく) */
  54 static int server_port;
  55 static GAME_TEXT server_name[MAX_HOSTNAME];
  56 #endif
  57
  58 static int movie_fd;
  59 static int movie_mode;
  60
  61 #ifdef CHUUKEI
  62 #ifdef WINDOWS
  63 #define close closesocket
  64 #endif
  65
  66 #ifdef MACINTOSH
  67 static InetSvcRef inet_services = nil;
  68 static EndpointRef ep                   = kOTInvalidEndpointRef;
  69 #endif
  70 #endif
  71 /* 描画する時刻を覚えておくキュー構造体 */
  72 static struct
  73 {
  74         int time[FRESH_QUEUE_SIZE];
  75         int next;
  76         int tail;
  77 }fresh_queue;
  78
  79
  80 /* リングバッファ構造体 */
  81 static struct
  82 {
  83         char *buf;
  84         int wptr;
  85         int rptr;
  86         int inlen;
  87 }ring;
  88
  89 #ifdef MACINTOSH
  90 int recv(int s, char *buffer, size_t buflen, int flags)
  91 {
  92         OTFlags         junkFlags;
  93         int n = OTRcv(ep, (void *) buffer, buflen, &junkFlags);
  94         if( n <= 0 )
  95                 return n;
  96         return n;
  97 }
  98 #endif
  99
 100 /*
 101  * Original hooks
 102  */
 103 static errr (*old_xtra_hook)(int n, int v);
 104 static errr (*old_curs_hook)(int x, int y);
 105 static errr (*old_bigcurs_hook)(int x, int y);
 106 static errr (*old_wipe_hook)(int x, int y, int n);
 107 static errr (*old_text_hook)(int x, int y, int n, TERM_COLOR a, concptr s);
 108
 109 static void disable_chuukei_server(void)
 110 {
 111         term *t = angband_term[0];
 112 #ifdef CHUUKEI
 113         chuukei_server = FALSE;
 114 #endif /* CHUUKEI */
 115         t->xtra_hook = old_xtra_hook;
 116         t->curs_hook = old_curs_hook;
 117         t->bigcurs_hook = old_bigcurs_hook;
 118         t->wipe_hook = old_wipe_hook;
 119         t->text_hook = old_text_hook;
 120 }
 121
 122 /* ANSI Cによればstatic変数は0で初期化されるが一応初期化する */
 123 static errr init_buffer(void)
 124 {
 125         fresh_queue.next = fresh_queue.tail = 0;
 126         ring.wptr = ring.rptr = ring.inlen = 0;
 127         fresh_queue.time[0] = 0;
 128         ring.buf = malloc(RINGBUF_SIZE);
 129         if (ring.buf == NULL) return (-1);
 130
 131         return (0);
 132 }
 133
 134 /* 現在の時間を100ms単位で取得する */
 135 static long get_current_time(void)
 136 {
 137 #ifdef WINDOWS
 138         return timeGetTime() / 100;
 139 #elif defined(MACINTOSH)
 140         return TickCount();
 141 #else
 142         struct timeval tv;
 143         gettimeofday(&tv, NULL);
 144
 145         return (tv.tv_sec * 10 + tv.tv_usec / 100000);
 146 #endif
 147 }
 148
 149
 150 /* リングバッファ構造体に buf の内容を加える */
 151 static errr insert_ringbuf(char *buf)
 152 {
 153         int len;
 154         len = strlen(buf) + 1; /* +1は終端文字分 */
 155
 156         if (movie_mode)
 157         {
 158                 fd_write(movie_fd, buf, len);
 159 #ifdef CHUUKEI
 160                 if (!chuukei_server) return 0;
 161 #else
 162                 return 0;
 163 #endif
 164         }
 165
 166         /* バッファをオーバー */
 167         if (ring.inlen + len >= RINGBUF_SIZE)
 168         {
 169 #ifdef CHUUKEI
 170                 if (chuukei_server) disable_chuukei_server();
 171                 else chuukei_client = FALSE;
 172
 173                 prt("送受信バッファが溢れました。サーバとの接続を切断します。", 0, 0);
 174                 inkey();
 175
 176                 close(sd);
 177 #endif
 178                 return (-1);
 179         }
 180
 181         /* バッファの終端までに収まる */
 182         if (ring.wptr + len < RINGBUF_SIZE)
 183         {
 184                 memcpy(ring.buf + ring.wptr, buf, len);
 185                 ring.wptr += len;
 186         }
 187         /* バッファの終端までに収まらない(ピッタリ収まる場合も含む) */
 188         else
 189         {
 190                 int head = RINGBUF_SIZE - ring.wptr;  /* 前半 */
 191                 int tail = len - head;               /* 後半 */
 192
 193                 memcpy(ring.buf + ring.wptr, buf, head);
 194                 memcpy(ring.buf, buf + head, tail);
 195                 ring.wptr = tail;
 196         }
 197
 198         ring.inlen += len;
 199
 200         /* Success */
 201         return (0);
 202 }
 203
 204 #ifdef CHUUKEI
 205 void flush_ringbuf(void)
 206 {
 207 #ifndef MACINTOSH
 208         fd_set fdset;
 209         struct timeval tv;
 210
 211         if (!chuukei_server) return;
 212
 213         if (ring.inlen == 0) return;
 214
 215         tv.tv_sec = 0;
 216         tv.tv_usec = 0;
 217
 218         FD_ZERO(&fdset);
 219         FD_SET(sd, &fdset);
 220
 221         while (1)
 222         {
 223                 fd_set tmp_fdset;
 224                 int result;
 225
 226                 tmp_fdset = fdset;
 227
 228                 /* ソケットにデータを書き込めるかどうか調べる */
 229                 select(sd+1, (fd_set *)NULL, &tmp_fdset, (fd_set *)NULL, &tv);
 230
 231                 /* 書き込めなければ戻る */
 232                 if (FD_ISSET(sd, &tmp_fdset) == 0) break;
 233
 234                 result = send(sd, ring.buf + ring.rptr, ((ring.wptr > ring.rptr ) ? ring.wptr : RINGBUF_SIZE) - ring.rptr, 0);
 235
 236                 if (result <= 0)
 237                 {
 238                         /* サーバとの接続断？ */
 239                         if (chuukei_server) disable_chuukei_server();
 240
 241                         prt("サーバとの接続が切断されました。", 0, 0);
 242                         inkey();
 243                         close(sd);
 244
 245                         return;
 246                 }
 247
 248                 ring.rptr += result;
 249                 ring.inlen -= result;
 250
 251                 if (ring.rptr == RINGBUF_SIZE) ring.rptr = 0;
 252                 if (ring.inlen == 0) break;
 253         }
 254 #else
 255         if (!chuukei_server) return;
 256
 257         if (ring.inlen == 0) return;
 258
 259         while (1)
 260         {
 261                 int result;
 262
 263                 /* ソケットにデータを書き込めるかどうか調べる */
 264                 result = OTSnd(ep, ring.buf + ring.rptr, ((ring.wptr > ring.rptr ) ? ring.wptr : RINGBUF_SIZE) - ring.rptr, 0);
 265
 266                 if (result <= 0)
 267                 {
 268                         /* サーバとの接続断？ */
 269                         if (chuukei_server) disable_chuukei_server();
 270
 271                         prt("サーバとの接続が切断されました。", 0, 0);
 272                         inkey();
 273                         close(sd);
 274
 275                         return;
 276                 }
 277
 278                 ring.rptr += result;
 279                 ring.inlen -= result;
 280
 281                 if (ring.rptr == RINGBUF_SIZE) ring.rptr = 0;
 282                 if (ring.inlen == 0) break;
 283         }
 284 #endif
 285 }
 286
 287
 288 static int read_chuukei_prf(concptr prf_name)
 289 {
 290         char buf[1024];
 291         FILE *fp;
 292
 293         path_build(buf, sizeof(buf), ANGBAND_DIR_XTRA, prf_name);
 294         fp = my_fopen(buf, "r");
 295
 296         if (!fp) return (-1);
 297
 298         /* 初期化 */
 299         server_port = -1;
 300         server_name[0] = 0;
 301         browse_delay = DEFAULT_DELAY;
 302
 303         while (0 == my_fgets(fp, buf, sizeof(buf)))
 304         {
 305                 /* サーバ名 */
 306                 if (!strncmp(buf, "server:", 7))
 307                 {
 308                         strncpy(server_name, buf + 7, MAX_HOSTNAME - 1);
 309                         server_name[MAX_HOSTNAME - 1] = '\0';
 310                 }
 311
 312                 /* ポート番号 */
 313                 if (!strncmp(buf, "port:", 5))
 314                 {
 315                         server_port = atoi(buf + 5);
 316                 }
 317
 318                 /* ディレイ */
 319                 if (!strncmp(buf, "delay:", 6))
 320                 {
 321                         browse_delay = atoi(buf + 6);
 322                 }
 323         }
 324
 325         my_fclose(fp);
 326
 327         /* prfファイルが完全でない */
 328         if (server_port == -1 || server_name[0] == 0) return (-1);
 329
 330         return (0);
 331 }
 332
 333 int connect_chuukei_server(char *prf_name)
 334 {
 335 #ifndef MACINTOSH
 336
 337 #ifdef WINDOWS
 338         WSADATA wsaData;
 339         WORD wVersionRequested = (WORD) (( 1) |  ( 1 << 8));
 340 #endif
 341
 342         struct sockaddr_in ask;
 343         struct hostent *hp;
 344
 345         if (read_chuukei_prf(prf_name) < 0)
 346         {
 347                 printf("Wrong prf file\n");
 348                 return (-1);
 349         }
 350
 351         if (init_buffer() < 0)
 352         {
 353                 printf("Malloc error\n");
 354                 return (-1);
 355         }
 356
 357 #ifdef WINDOWS
 358         if (WSAStartup(wVersionRequested, &wsaData))
 359         {
 360                 msg_print("Report: WSAStartup failed.");
 361                 return (-1);
 362         }
 363 #endif
 364
 365         printf("server = %s\nport = %d\n", server_name, server_port);
 366
 367         if ((hp = gethostbyname(server_name)) != NULL)
 368         {
 369                 memset(&ask, 0, sizeof(ask));
 370                 memcpy(&ask.sin_addr, hp->h_addr_list[0], hp->h_length);
 371         }
 372         else
 373         {
 374                 if ((ask.sin_addr.s_addr=inet_addr(server_name)) == 0)
 375                 {
 376                         printf("Bad hostname\n");
 377                         return (-1);
 378                 }
 379         }
 380
 381         ask.sin_family = AF_INET;
 382         ask.sin_port = htons((unsigned short)server_port);
 383
 384 #ifndef WINDOWS
 385         if ((sd=socket(PF_INET,SOCK_STREAM, 0)) < 0)
 386 #else
 387         if ((sd=socket(PF_INET,SOCK_STREAM, 0)) == INVALID_SOCKET)
 388 #endif
 389         {
 390                 printf("Can't create socket\n");
 391                 return (-1);
 392         }
 393
 394         if (connect(sd, (struct sockaddr *)&ask, sizeof(ask)) < 0)
 395         {
 396                 close(sd);
 397                 printf("Can't connect %s port %d\n", server_name, server_port);
 398                 return (-1);
 399         }
 400
 401         return (0);
 402 #else   /* MACINTOSH */
 403         OSStatus err;
 404         InetHostInfo    response;
 405         InetHost                host_addr;
 406         InetAddress     inAddr;
 407         TCall                   sndCall;
 408         Boolean                 bind    = false;
 409         OSStatus        junk;
 410
 411         if (read_chuukei_prf(prf_name) < 0){
 412                 printf("Wrong prf file\n");
 413                 return (-1);
 414         }
 415
 416         init_buffer();
 417
 418         printf("server = %s\nport = %d\n", server_name, server_port);
 419
 420
 421 #if TARGET_API_MAC_CARBON
 422         err = InitOpenTransportInContext(kInitOTForApplicationMask, NULL);
 423 #else
 424         err = InitOpenTransport();
 425 #endif
 426
 427         memset(&response, 0, sizeof(response));
 428
 429
 430 #if TARGET_API_MAC_CARBON
 431         inet_services = OTOpenInternetServicesInContext(kDefaultInternetServicesPath, 0, &err, NULL);
 432 #else
 433         inet_services = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
 434 #endif
 435
 436         if (err == noErr) {
 437                 err = OTInetStringToAddress(inet_services, (char *)server_name, &response);
 438
 439                 if (err == noErr) {
 440                         host_addr = response.addrs[0];
 441                 } else {
 442                         printf("Bad hostname\n");
 443                 }
 444
 445 #if TARGET_API_MAC_CARBON
 446                 ep = (void *)OTOpenEndpointInContext(OTCreateConfiguration(kTCPName), 0, nil, &err, NULL);
 447 #else
 448                 ep = (void *)OTOpenEndpoint(OTCreateConfiguration(kTCPName), 0, nil, &err);
 449 #endif
 450
 451                 if (err == noErr) {
 452                         err = OTBind(ep, nil, nil);
 453                         bind = (err == noErr);
 454             }
 455             if (err == noErr){
 456                 OTInitInetAddress(&inAddr, server_port, host_addr);
 457
 458                         sndCall.addr.len        = sizeof(InetAddress);
 459                         sndCall.addr.buf        = (unsigned char*) &inAddr;
 460                         sndCall.opt.buf         = nil;          /* no connection options */
 461                         sndCall.opt.len         = 0;
 462                         sndCall.udata.buf       = nil;          /* no connection data */
 463                         sndCall.udata.len       = 0;
 464                         sndCall.sequence        = 0;            /* ignored by OTConnect */
 465
 466                         err = OTConnect(ep, &sndCall, NULL);
 467
 468                         if( err != noErr ){
 469                                 printf("Can't connect %s port %d\n", server_name, server_port);
 470                         }
 471                 }
 472
 473                 err = OTSetSynchronous(ep);
 474                 if (err == noErr)
 475                         err = OTSetBlocking(ep);
 476
 477         }
 478
 479         if( err != noErr ){
 480                 if( bind ){
 481                         OTUnbind(ep);
 482                 }
 483                 /* Clean up. */
 484                 if (ep != kOTInvalidEndpointRef) {
 485                         OTCloseProvider(ep);
 486                         ep = nil;
 487                 }
 488                 if (inet_services != nil) {
 489                         OTCloseProvider(inet_services);
 490                         inet_services = nil;
 491                 }
 492
 493                 return -1;
 494         }
 495
 496         return 0;
 497
 498 #endif
 499 }
 500 #endif /* CHUUKEI */
 501
 502 /* strが同じ文字の繰り返しかどうか調べる */
 503 static bool string_is_repeat(char *str, int len)
 504 {
 505         char c = str[0];
 506         int i;
 507
 508         if (len < 2) return (FALSE);
 509 #ifdef JP
 510         if (iskanji(c)) return (FALSE);
 511 #endif
 512
 513         for (i = 1; i < len; i++)
 514         {
 515 #ifdef JP
 516                 if(c != str[i] || iskanji(str[i])) return (FALSE);
 517 #else
 518                 if(c != str[i]) return (FALSE);
 519 #endif
 520         }
 521
 522         return (TRUE);
 523 }
 524
 525 static errr send_text_to_chuukei_server(TERM_LEN x, TERM_LEN y, int len, TERM_COLOR col, concptr str)
 526 {
 527         char buf[1024];
 528         char buf2[1024];
 529
 530         strncpy(buf2, str, len);
 531         buf2[len] = '\0';
 532
 533         if (len == 1)
 534         {
 535                 sprintf(buf, "s%c%c%c%c", x+1, y+1, col, buf2[0]);
 536         }
 537         else if(string_is_repeat(buf2, len))
 538         {
 539                 int i;
 540                 for (i = len; i > 0; i -= 127)
 541                 {
 542                         sprintf(buf, "n%c%c%c%c%c", x+1, y+1, MIN(i, 127), col, buf2[0]);
 543                 }
 544         }
 545         else
 546         {
 547 #if defined(SJIS) && defined(JP)
 548                 sjis2euc(buf2);
 549 #endif
 550                 sprintf(buf, "t%c%c%c%c%s", x+1, y+1, len, col, buf2);
 551         }
 552
 553         insert_ringbuf(buf);
 554
 555         return (*old_text_hook)(x, y, len, col, str);
 556 }
 557
 558 static errr send_wipe_to_chuukei_server(int x, int y, int len)
 559 {
 560         char buf[1024];
 561
 562         sprintf(buf, "w%c%c%c", x+1, y+1, len);
 563
 564         insert_ringbuf(buf);
 565
 566         return (*old_wipe_hook)(x, y, len);
 567 }
 568
 569 static errr send_xtra_to_chuukei_server(int n, int v)
 570 {
 571         char buf[1024];
 572
 573         if (n == TERM_XTRA_CLEAR || n == TERM_XTRA_FRESH || n == TERM_XTRA_SHAPE)
 574         {
 575                 sprintf(buf, "x%c", n+1);
 576
 577                 insert_ringbuf(buf);
 578
 579                 if (n == TERM_XTRA_FRESH)
 580                 {
 581                         sprintf(buf, "d%ld", get_current_time() - epoch_time);
 582                         insert_ringbuf(buf);
 583                 }
 584         }
 585
 586         /* Verify the hook */
 587         if (!old_xtra_hook) return -1;
 588
 589         return (*old_xtra_hook)(n, v);
 590 }
 591
 592 static errr send_curs_to_chuukei_server(int x, int y)
 593 {
 594         char buf[1024];
 595
 596         sprintf(buf, "c%c%c", x+1, y+1);
 597
 598         insert_ringbuf(buf);
 599
 600         return (*old_curs_hook)(x, y);
 601 }
 602
 603 static errr send_bigcurs_to_chuukei_server(int x, int y)
 604 {
 605         char buf[1024];
 606
 607         sprintf(buf, "C%c%c", x+1, y+1);
 608
 609         insert_ringbuf(buf);
 610
 611         return (*old_bigcurs_hook)(x, y);
 612 }
 613
 614
 615 /*
 616  * Prepare z-term hooks to call send_*_to_chuukei_server()'s
 617  */
 618 void prepare_chuukei_hooks(void)
 619 {
 620         term *t0 = angband_term[0];
 621
 622         /* Save original z-term hooks */
 623         old_xtra_hook = t0->xtra_hook;
 624         old_curs_hook = t0->curs_hook;
 625         old_bigcurs_hook = t0->bigcurs_hook;
 626         old_wipe_hook = t0->wipe_hook;
 627         old_text_hook = t0->text_hook;
 628
 629         /* Prepare z-term hooks */
 630         t0->xtra_hook = send_xtra_to_chuukei_server;
 631         t0->curs_hook = send_curs_to_chuukei_server;
 632         t0->bigcurs_hook = send_bigcurs_to_chuukei_server;
 633         t0->wipe_hook = send_wipe_to_chuukei_server;
 634         t0->text_hook = send_text_to_chuukei_server;
 635 }
 636
 637
 638 /*
 639  * Prepare z-term hooks to call send_*_to_chuukei_server()'s
 640  */
 641 void prepare_movie_hooks(void)
 642 {
 643         char buf[1024];
 644         char tmp[80];
 645
 646         if (movie_mode)
 647         {
 648                 movie_mode = 0;
 649 #ifdef CHUUKEI
 650                 if (!chuukei_server) disable_chuukei_server();
 651 #else
 652                 disable_chuukei_server();
 653 #endif
 654                 fd_close(movie_fd);
 655                 msg_print(_("録画を終了しました。", "Stopped recording."));
 656         }
 657         else
 658         {
 659                 sprintf(tmp, "%s.amv", player_base);
 660                 if (get_string(_("ムービー記録ファイル: ", "Movie file name: "), tmp, 80))
 661                 {
 662                         int fd;
 663
 664                         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, tmp);
 665
 666                         fd = fd_open(buf, O_RDONLY);
 667
 668                         /* Existing file */
 669                         if (fd >= 0)
 670                         {
 671                                 char out_val[160];
 672                                 (void)fd_close(fd);
 673
 674                                 /* Build query */
 675                                 (void)sprintf(out_val, _("現存するファイルに上書きしますか? (%s)", "Replace existing file %s? "), buf);
 676
 677                                 /* Ask */
 678                                 if (!get_check(out_val)) return;
 679
 680                                 movie_fd = fd_open(buf, O_WRONLY | O_TRUNC);
 681                         }
 682                         else
 683                         {
 684                                 movie_fd = fd_make(buf, 0644);
 685                         }
 686
 687                         if (!movie_fd)
 688                         {
 689                                 msg_print(_("ファイルを開けません！", "Can not open file."));
 690                                 return;
 691                         }
 692
 693                         movie_mode = 1;
 694 #ifdef CHUUKEI
 695                         if (!chuukei_server) prepare_chuukei_hooks();
 696 #else
 697                         prepare_chuukei_hooks();
 698 #endif
 699                         do_cmd_redraw();
 700                 }
 701         }
 702 }
 703
 704 #ifdef CHUUKEI
 705 static int handle_timestamp_data(int timestamp)
 706 {
 707         long current_time = get_current_time();
 708
 709         /* 描画キューは空かどうか？ */
 710         if (fresh_queue.tail == fresh_queue.next)
 711         {
 712                 /* バッファリングし始めの時間を保存しておく */
 713                 epoch_time = current_time;
 714                 epoch_time += browse_delay;
 715                 epoch_time -= timestamp;
 716                 time_diff = current_time - timestamp;
 717         }
 718
 719         /* 描画キューに保存し、保存位置を進める */
 720         fresh_queue.time[fresh_queue.tail] = timestamp;
 721         fresh_queue.tail ++;
 722
 723         /* キューの最後尾に到達したら先頭に戻す */
 724         fresh_queue.tail %= FRESH_QUEUE_SIZE;
 725
 726         if (fresh_queue.tail == fresh_queue.next)
 727         {
 728                 /* 描画キュー溢れ */
 729                 prt("描画タイミングキューが溢れました。サーバとの接続を切断します。", 0, 0);
 730                 inkey();
 731                 close(sd);
 732
 733                 return -1;
 734         }
 735
 736         /* プレイ側とのディレイを調整 */
 737         if (time_diff != current_time - timestamp)
 738         {
 739                 long old_time_diff = time_diff;
 740                 time_diff = current_time - timestamp;
 741                 epoch_time -= (old_time_diff - time_diff);
 742         }
 743
 744         /* Success */
 745         return 0;
 746 }
 747 #endif /* CHUUKEI */
 748
 749 static int handle_movie_timestamp_data(int timestamp)
 750 {
 751         static int initialized = FALSE;
 752
 753         /* 描画キューは空かどうか？ */
 754         if (!initialized)
 755         {
 756                 /* バッファリングし始めの時間を保存しておく */
 757                 epoch_time = get_current_time();
 758                 epoch_time += browse_delay;
 759                 epoch_time -= timestamp;
 760                 //time_diff = current_time - timestamp;
 761                 initialized = TRUE;
 762         }
 763
 764         /* 描画キューに保存し、保存位置を進める */
 765         fresh_queue.time[fresh_queue.tail] = timestamp;
 766         fresh_queue.tail ++;
 767
 768         /* キューの最後尾に到達したら先頭に戻す */
 769         fresh_queue.tail %= FRESH_QUEUE_SIZE;
 770
 771         /* Success */
 772         return 0;
 773 }
 774
 775 #ifdef CHUUKEI
 776 static int read_sock(void)
 777 {
 778         static char recv_buf[RECVBUF_SIZE];
 779         static int remain_bytes = 0;
 780         int recv_bytes;
 781         int i;
 782
 783         /* 前回残ったデータの後につづけて配信サーバからデータ受信 */
 784         recv_bytes = recv(sd, recv_buf + remain_bytes, RECVBUF_SIZE - remain_bytes, 0);
 785
 786         if (recv_bytes <= 0)
 787                 return -1;
 788
 789         /* 前回残ったデータ量に今回読んだデータ量を追加 */
 790         remain_bytes += recv_bytes;
 791
 792         for (i = 0; i < remain_bytes; i ++)
 793         {
 794                 /* データのくぎり('\0')を探す */
 795                 if (recv_buf[i] == '\0')
 796                 {
 797                         /* 'd'で始まるデータ(タイムスタンプ)の場合は
 798                            描画キューに保存する処理を呼ぶ */
 799                         if ((recv_buf[0] == 'd') &&
 800                             (handle_timestamp_data(atoi(recv_buf + 1)) < 0))
 801                                 return -1;
 802
 803                         /* 受信データを保存 */
 804                         if (insert_ringbuf(recv_buf) < 0)
 805                                 return -1;
 806
 807                         /* 次のデータ移行をrecv_bufの先頭に移動 */
 808                         memmove(recv_buf, recv_buf + i + 1, remain_bytes - i - 1);
 809
 810                         remain_bytes -= (i+1);
 811                         i = 0;
 812                 }
 813         }
 814
 815         return 0;
 816 }
 817 #endif
 818
 819 static int read_movie_file(void)
 820 {
 821         static char recv_buf[RECVBUF_SIZE];
 822         static int remain_bytes = 0;
 823         int recv_bytes;
 824         int i;
 825
 826         recv_bytes = read(movie_fd, recv_buf + remain_bytes, RECVBUF_SIZE - remain_bytes);
 827
 828         if (recv_bytes <= 0)
 829                 return -1;
 830
 831         /* 前回残ったデータ量に今回読んだデータ量を追加 */
 832         remain_bytes += recv_bytes;
 833
 834         for (i = 0; i < remain_bytes; i ++)
 835         {
 836                 /* データのくぎり('\0')を探す */
 837                 if (recv_buf[i] == '\0')
 838                 {
 839                         /* 'd'で始まるデータ(タイムスタンプ)の場合は
 840                            描画キューに保存する処理を呼ぶ */
 841                         if ((recv_buf[0] == 'd') &&
 842                             (handle_movie_timestamp_data(atoi(recv_buf + 1)) < 0))
 843                                 return -1;
 844
 845                         /* 受信データを保存 */
 846                         if (insert_ringbuf(recv_buf) < 0)
 847                                 return -1;
 848
 849                         /* 次のデータ移行をrecv_bufの先頭に移動 */
 850                         memmove(recv_buf, recv_buf + i + 1, remain_bytes - i - 1);
 851
 852                         remain_bytes -= (i+1);
 853                         i = 0;
 854                 }
 855         }
 856
 857         return 0;
 858 }
 859
 860
 861 #ifndef WINDOWS
 862 /* Win版の床の中点と壁の豆腐をピリオドとシャープにする。*/
 863 static void win2unix(int col, char *buf)
 864 {
 865         char kabe;
 866         if ( col == 9 ) kabe = '%';
 867         else            kabe = '#';
 868
 869         while (*buf)
 870         {
 871 #ifdef JP
 872                 if (iskanji(*buf))
 873                 {
 874                         buf += 2;
 875                         continue;
 876                 }
 877 #endif
 878                 if (*buf == 127) *buf = kabe;
 879                 else if(*buf == 31) *buf = '.';
 880                 buf++;
 881         }
 882 }
 883 #endif
 884
 885 static bool get_nextbuf(char *buf)
 886 {
 887         char *ptr = buf;
 888
 889         while (1)
 890         {
 891                 *ptr = ring.buf[ring.rptr ++];
 892                 ring.inlen --;
 893                 if (ring.rptr == RINGBUF_SIZE) ring.rptr = 0;
 894                 if (*ptr++ == '\0') break;
 895         }
 896
 897         if (buf[0] == 'd') return (FALSE);
 898
 899         return (TRUE);
 900 }
 901
 902 /* プレイホストのマップが大きいときクライアントのマップもリサイズする */
 903 static void update_term_size(int x, int y, int len)
 904 {
 905         int ox, oy;
 906         int nx, ny;
 907         Term_get_size(&ox, &oy);
 908         nx = ox;
 909         ny = oy;
 910
 911         /* 横方向のチェック */
 912         if (x + len > ox) nx = x + len;
 913         /* 縦方向のチェック */
 914         if (y + 1 > oy) ny = y + 1;
 915
 916         if (nx != ox || ny != oy) Term_resize(nx, ny);
 917 }
 918
 919 static bool flush_ringbuf_client(void)
 920 {
 921         char buf[1024];
 922
 923         /* 書くデータなし */
 924         if (fresh_queue.next == fresh_queue.tail) return (FALSE);
 925
 926         /* まだ書くべき時でない */
 927         if (fresh_queue.time[fresh_queue.next] > get_current_time() - epoch_time) return (FALSE);
 928
 929         /* 時間情報(区切り)が得られるまで書く */
 930         while (get_nextbuf(buf))
 931         {
 932                 char id;
 933                 int x, y, len;
 934                 TERM_COLOR col;
 935                 int i;
 936                 unsigned char tmp1, tmp2, tmp3, tmp4;
 937                 char *mesg;
 938
 939                 sscanf(buf, "%c%c%c%c%c", &id, &tmp1, &tmp2, &tmp3, &tmp4);
 940                 x = tmp1-1; y = tmp2-1; len = tmp3; col = tmp4;
 941                 if (id == 's')
 942                 {
 943                         col = tmp3;
 944                         mesg = &buf[4];
 945                 }
 946                 else mesg = &buf[5];
 947 #ifndef WINDOWS
 948                 win2unix(col, mesg);
 949 #endif
 950
 951                 switch (id)
 952                 {
 953                 case 't': /* 通常 */
 954 #if defined(SJIS) && defined(JP)
 955                         euc2sjis(mesg);
 956 #endif
 957                         update_term_size(x, y, len);
 958                         (void)((*angband_term[0]->text_hook)(x, y, len, (byte)col, mesg));
 959                         strncpy(&Term->scr->c[y][x], mesg, len);
 960                         for (i = x; i < x+len; i++)
 961                         {
 962                                 Term->scr->a[y][i] = col;
 963                         }
 964                         break;
 965
 966                 case 'n': /* 繰り返し */
 967                         for (i = 1; i < len; i++)
 968                         {
 969                                 mesg[i] = mesg[0];
 970                         }
 971                         mesg[i] = '\0';
 972                         update_term_size(x, y, len);
 973                         (void)((*angband_term[0]->text_hook)(x, y, len, (byte)col, mesg));
 974                         strncpy(&Term->scr->c[y][x], mesg, len);
 975                         for (i = x; i < x+len; i++)
 976                         {
 977                                 Term->scr->a[y][i] = col;
 978                         }
 979                         break;
 980
 981                 case 's': /* 一文字 */
 982                         update_term_size(x, y, 1);
 983                         (void)((*angband_term[0]->text_hook)(x, y, 1, (byte)col, mesg));
 984                         strncpy(&Term->scr->c[y][x], mesg, 1);
 985                         Term->scr->a[y][x] = col;
 986                         break;
 987
 988                 case 'w':
 989                         update_term_size(x, y, len);
 990                         (void)((*angband_term[0]->wipe_hook)(x, y, len));
 991                         break;
 992
 993                 case 'x':
 994                         if (x == TERM_XTRA_CLEAR) Term_clear();
 995                         (void)((*angband_term[0]->xtra_hook)(x, 0));
 996                         break;
 997
 998                 case 'c':
 999                         update_term_size(x, y, 1);
1000                         (void)((*angband_term[0]->curs_hook)(x, y));
1001                         break;
1002                 case 'C':
1003                         update_term_size(x, y, 1);
1004                         (void)((*angband_term[0]->bigcurs_hook)(x, y));
1005                         break;
1006                 }
1007         }
1008
1009         fresh_queue.next++;
1010         if (fresh_queue.next == FRESH_QUEUE_SIZE) fresh_queue.next = 0;
1011         return (TRUE);
1012 }
1013
1014 #ifdef CHUUKEI
1015 void browse_chuukei()
1016 {
1017 #ifndef MACINTOSH
1018         fd_set fdset;
1019         struct timeval tv;
1020
1021         tv.tv_sec = 0;
1022         tv.tv_usec = WAIT;
1023
1024         FD_ZERO(&fdset);
1025         FD_SET(sd, &fdset);
1026
1027         Term_clear();
1028         Term_fresh();
1029         Term_xtra(TERM_XTRA_REACT, 0);
1030
1031         while (1)
1032         {
1033                 fd_set tmp_fdset;
1034                 struct timeval tmp_tv;
1035
1036                 if (flush_ringbuf_client()) continue;
1037
1038                 tmp_fdset = fdset;
1039                 tmp_tv = tv;
1040
1041                 /* ソケットにデータが来ているかどうか調べる */
1042                 select(sd+1, &tmp_fdset, (fd_set *)NULL, (fd_set *)NULL, &tmp_tv);
1043                 if (FD_ISSET(sd, &tmp_fdset) == 0)
1044                 {
1045                         Term_xtra(TERM_XTRA_FLUSH, 0);
1046                         continue;
1047                 }
1048
1049                 if (read_sock() < 0)
1050                 {
1051                         chuukei_client = FALSE;
1052                 }
1053
1054                 /* 接続が切れた状態で書くべきデータがなくなっていたら終了 */
1055                 if (!chuukei_client && fresh_queue.next == fresh_queue.tail ) break;
1056         }
1057 #else
1058         Term_clear();
1059         Term_fresh();
1060         Term_xtra(TERM_XTRA_REACT, 0);
1061
1062         while (1)
1063         {
1064                 UInt32  unreadData = 0;
1065                 int n;
1066
1067                 if (flush_ringbuf_client()) continue;
1068
1069                 /* ソケットにデータが来ているかどうか調べる */
1070
1071                 OTCountDataBytes(ep, &unreadData);
1072                 if(unreadData <= 0 ){
1073                         Term_xtra(TERM_XTRA_FLUSH, 0);
1074                         continue;
1075                 }
1076                 if (read_sock() < 0)
1077                 {
1078                         chuukei_client = FALSE;
1079                 }
1080
1081                 /* 接続が切れた状態で書くべきデータがなくなっていたら終了 */
1082                 if (!chuukei_client && fresh_queue.next == fresh_queue.tail ) break;
1083         }
1084 #endif /*MACINTOSH*/
1085 }
1086 #endif /* CHUUKEI */
1087
1088 void prepare_browse_movie_aux(concptr filename)
1089 {
1090         movie_fd = fd_open(filename, O_RDONLY);
1091
1092         browsing_movie = TRUE;
1093
1094         init_buffer();
1095 }
1096
1097 void prepare_browse_movie(concptr filename)
1098 {
1099         char buf[1024];
1100         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, filename);
1101
1102         prepare_browse_movie_aux(buf);
1103 }
1104
1105 void browse_movie(void)
1106 {
1107         Term_clear();
1108         Term_fresh();
1109         Term_xtra(TERM_XTRA_REACT, 0);
1110
1111         while (read_movie_file() == 0)
1112         {
1113                 while (fresh_queue.next != fresh_queue.tail)
1114                 {
1115                         if (!flush_ringbuf_client())
1116                         {
1117                                 Term_xtra(TERM_XTRA_FLUSH, 0);
1118
1119                                 /* ソケットにデータが来ているかどうか調べる */
1120 #ifdef WINDOWS
1121                                 Sleep(WAIT);
1122 #else
1123                                 usleep(WAIT);
1124 #endif
1125                         }
1126                 }
1127         }
1128 }