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 char 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, byte a, cptr 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(cptr 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(int x, int y, int len, byte col, cptr 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
 673                                 /* Close the file */
 674                                 (void)fd_close(fd);
 675
 676                                 /* Build query */
 677                                 (void)sprintf(out_val, _("現存するファイルに上書きしますか? (%s)", "Replace existing file %s? "), buf);
 678
 679                                 /* Ask */
 680                                 if (!get_check(out_val)) return;
 681
 682                                 movie_fd = fd_open(buf, O_WRONLY | O_TRUNC);
 683                         }
 684                         else
 685                         {
 686                                 movie_fd = fd_make(buf, 0644);
 687                         }
 688
 689                         if (!movie_fd)
 690                         {
 691                                 msg_print(_("ファイルを開けません！", "Can not open file."));
 692                                 return;
 693                         }
 694
 695                         movie_mode = 1;
 696 #ifdef CHUUKEI
 697                         if (!chuukei_server) prepare_chuukei_hooks();
 698 #else
 699                         prepare_chuukei_hooks();
 700 #endif
 701                         do_cmd_redraw();
 702                 }
 703         }
 704 }
 705
 706 #ifdef CHUUKEI
 707 static int handle_timestamp_data(int timestamp)
 708 {
 709         long current_time = get_current_time();
 710
 711         /* 描画キューは空かどうか？ */
 712         if (fresh_queue.tail == fresh_queue.next)
 713         {
 714                 /* バッファリングし始めの時間を保存しておく */
 715                 epoch_time = current_time;
 716                 epoch_time += browse_delay;
 717                 epoch_time -= timestamp;
 718                 time_diff = current_time - timestamp;
 719         }
 720
 721         /* 描画キューに保存し、保存位置を進める */
 722         fresh_queue.time[fresh_queue.tail] = timestamp;
 723         fresh_queue.tail ++;
 724
 725         /* キューの最後尾に到達したら先頭に戻す */
 726         fresh_queue.tail %= FRESH_QUEUE_SIZE;
 727
 728         if (fresh_queue.tail == fresh_queue.next)
 729         {
 730                 /* 描画キュー溢れ */
 731                 prt("描画タイミングキューが溢れました。サーバとの接続を切断します。", 0, 0);
 732                 inkey();
 733                 close(sd);
 734
 735                 return -1;
 736         }
 737
 738         /* プレイ側とのディレイを調整 */
 739         if (time_diff != current_time - timestamp)
 740         {
 741                 long old_time_diff = time_diff;
 742                 time_diff = current_time - timestamp;
 743                 epoch_time -= (old_time_diff - time_diff);
 744         }
 745
 746         /* Success */
 747         return 0;
 748 }
 749 #endif /* CHUUKEI */
 750
 751 static int handle_movie_timestamp_data(int timestamp)
 752 {
 753         static int initialized = FALSE;
 754
 755         /* 描画キューは空かどうか？ */
 756         if (!initialized)
 757         {
 758                 /* バッファリングし始めの時間を保存しておく */
 759                 epoch_time = get_current_time();
 760                 epoch_time += browse_delay;
 761                 epoch_time -= timestamp;
 762                 //time_diff = current_time - timestamp;
 763                 initialized = TRUE;
 764         }
 765
 766         /* 描画キューに保存し、保存位置を進める */
 767         fresh_queue.time[fresh_queue.tail] = timestamp;
 768         fresh_queue.tail ++;
 769
 770         /* キューの最後尾に到達したら先頭に戻す */
 771         fresh_queue.tail %= FRESH_QUEUE_SIZE;
 772
 773         /* Success */
 774         return 0;
 775 }
 776
 777 #ifdef CHUUKEI
 778 static int read_sock(void)
 779 {
 780         static char recv_buf[RECVBUF_SIZE];
 781         static int remain_bytes = 0;
 782         int recv_bytes;
 783         int i;
 784
 785         /* 前回残ったデータの後につづけて配信サーバからデータ受信 */
 786         recv_bytes = recv(sd, recv_buf + remain_bytes, RECVBUF_SIZE - remain_bytes, 0);
 787
 788         if (recv_bytes <= 0)
 789                 return -1;
 790
 791         /* 前回残ったデータ量に今回読んだデータ量を追加 */
 792         remain_bytes += recv_bytes;
 793
 794         for (i = 0; i < remain_bytes; i ++)
 795         {
 796                 /* データのくぎり('\0')を探す */
 797                 if (recv_buf[i] == '\0')
 798                 {
 799                         /* 'd'で始まるデータ(タイムスタンプ)の場合は
 800                            描画キューに保存する処理を呼ぶ */
 801                         if ((recv_buf[0] == 'd') &&
 802                             (handle_timestamp_data(atoi(recv_buf + 1)) < 0))
 803                                 return -1;
 804
 805                         /* 受信データを保存 */
 806                         if (insert_ringbuf(recv_buf) < 0)
 807                                 return -1;
 808
 809                         /* 次のデータ移行をrecv_bufの先頭に移動 */
 810                         memmove(recv_buf, recv_buf + i + 1, remain_bytes - i - 1);
 811
 812                         remain_bytes -= (i+1);
 813                         i = 0;
 814                 }
 815         }
 816
 817         return 0;
 818 }
 819 #endif
 820
 821 static int read_movie_file(void)
 822 {
 823         static char recv_buf[RECVBUF_SIZE];
 824         static int remain_bytes = 0;
 825         int recv_bytes;
 826         int i;
 827
 828         recv_bytes = read(movie_fd, recv_buf + remain_bytes, RECVBUF_SIZE - remain_bytes);
 829
 830         if (recv_bytes <= 0)
 831                 return -1;
 832
 833         /* 前回残ったデータ量に今回読んだデータ量を追加 */
 834         remain_bytes += recv_bytes;
 835
 836         for (i = 0; i < remain_bytes; i ++)
 837         {
 838                 /* データのくぎり('\0')を探す */
 839                 if (recv_buf[i] == '\0')
 840                 {
 841                         /* 'd'で始まるデータ(タイムスタンプ)の場合は
 842                            描画キューに保存する処理を呼ぶ */
 843                         if ((recv_buf[0] == 'd') &&
 844                             (handle_movie_timestamp_data(atoi(recv_buf + 1)) < 0))
 845                                 return -1;
 846
 847                         /* 受信データを保存 */
 848                         if (insert_ringbuf(recv_buf) < 0)
 849                                 return -1;
 850
 851                         /* 次のデータ移行をrecv_bufの先頭に移動 */
 852                         memmove(recv_buf, recv_buf + i + 1, remain_bytes - i - 1);
 853
 854                         remain_bytes -= (i+1);
 855                         i = 0;
 856                 }
 857         }
 858
 859         return 0;
 860 }
 861
 862
 863 #ifndef WINDOWS
 864 /* Win版の床の中点と壁の豆腐をピリオドとシャープにする。*/
 865 static void win2unix(int col, char *buf)
 866 {
 867         char kabe;
 868         if ( col == 9 ) kabe = '%';
 869         else            kabe = '#';
 870
 871         while (*buf)
 872         {
 873 #ifdef JP
 874                 if (iskanji(*buf))
 875                 {
 876                         buf += 2;
 877                         continue;
 878                 }
 879 #endif
 880                 if (*buf == 127) *buf = kabe;
 881                 else if(*buf == 31) *buf = '.';
 882                 buf++;
 883         }
 884 }
 885 #endif
 886
 887 static bool get_nextbuf(char *buf)
 888 {
 889         char *ptr = buf;
 890
 891         while (1)
 892         {
 893                 *ptr = ring.buf[ring.rptr ++];
 894                 ring.inlen --;
 895                 if (ring.rptr == RINGBUF_SIZE) ring.rptr = 0;
 896                 if (*ptr++ == '\0') break;
 897         }
 898
 899         if (buf[0] == 'd') return (FALSE);
 900
 901         return (TRUE);
 902 }
 903
 904 /* プレイホストのマップが大きいときクライアントのマップもリサイズする */
 905 static void update_term_size(int x, int y, int len)
 906 {
 907         int ox, oy;
 908         int nx, ny;
 909         Term_get_size(&ox, &oy);
 910         nx = ox;
 911         ny = oy;
 912
 913         /* 横方向のチェック */
 914         if (x + len > ox) nx = x + len;
 915         /* 縦方向のチェック */
 916         if (y + 1 > oy) ny = y + 1;
 917
 918         if (nx != ox || ny != oy) Term_resize(nx, ny);
 919 }
 920
 921 static bool flush_ringbuf_client(void)
 922 {
 923         char buf[1024];
 924
 925         /* 書くデータなし */
 926         if (fresh_queue.next == fresh_queue.tail) return (FALSE);
 927
 928         /* まだ書くべき時でない */
 929         if (fresh_queue.time[fresh_queue.next] > get_current_time() - epoch_time) return (FALSE);
 930
 931         /* 時間情報(区切り)が得られるまで書く */
 932         while (get_nextbuf(buf))
 933         {
 934                 char id;
 935                 int x, y, len, col;
 936                 int i;
 937                 unsigned char tmp1, tmp2, tmp3, tmp4;
 938                 char *mesg;
 939
 940                 sscanf(buf, "%c%c%c%c%c", &id, &tmp1, &tmp2, &tmp3, &tmp4);
 941                 x = tmp1-1; y = tmp2-1; len = tmp3; col = tmp4;
 942                 if (id == 's')
 943                 {
 944                         col = tmp3;
 945                         mesg = &buf[4];
 946                 }
 947                 else mesg = &buf[5];
 948 #ifndef WINDOWS
 949                 win2unix(col, mesg);
 950 #endif
 951
 952                 switch (id)
 953                 {
 954                 case 't': /* 通常 */
 955 #if defined(SJIS) && defined(JP)
 956                         euc2sjis(mesg);
 957 #endif
 958                         update_term_size(x, y, len);
 959                         (void)((*angband_term[0]->text_hook)(x, y, len, (byte)col, mesg));
 960                         strncpy(&Term->scr->c[y][x], mesg, len);
 961                         for (i = x; i < x+len; i++)
 962                         {
 963                                 Term->scr->a[y][i] = col;
 964                         }
 965                         break;
 966
 967                 case 'n': /* 繰り返し */
 968                         for (i = 1; i < len; i++)
 969                         {
 970                                 mesg[i] = mesg[0];
 971                         }
 972                         mesg[i] = '\0';
 973                         update_term_size(x, y, len);
 974                         (void)((*angband_term[0]->text_hook)(x, y, len, (byte)col, mesg));
 975                         strncpy(&Term->scr->c[y][x], mesg, len);
 976                         for (i = x; i < x+len; i++)
 977                         {
 978                                 Term->scr->a[y][i] = col;
 979                         }
 980                         break;
 981
 982                 case 's': /* 一文字 */
 983                         update_term_size(x, y, 1);
 984                         (void)((*angband_term[0]->text_hook)(x, y, 1, (byte)col, mesg));
 985                         strncpy(&Term->scr->c[y][x], mesg, 1);
 986                         Term->scr->a[y][x] = col;
 987                         break;
 988
 989                 case 'w':
 990                         update_term_size(x, y, len);
 991                         (void)((*angband_term[0]->wipe_hook)(x, y, len));
 992                         break;
 993
 994                 case 'x':
 995                         if (x == TERM_XTRA_CLEAR) Term_clear();
 996                         (void)((*angband_term[0]->xtra_hook)(x, 0));
 997                         break;
 998
 999                 case 'c':
1000                         update_term_size(x, y, 1);
1001                         (void)((*angband_term[0]->curs_hook)(x, y));
1002                         break;
1003                 case 'C':
1004                         update_term_size(x, y, 1);
1005                         (void)((*angband_term[0]->bigcurs_hook)(x, y));
1006                         break;
1007                 }
1008         }
1009
1010         fresh_queue.next++;
1011         if (fresh_queue.next == FRESH_QUEUE_SIZE) fresh_queue.next = 0;
1012         return (TRUE);
1013 }
1014
1015 #ifdef CHUUKEI
1016 void browse_chuukei()
1017 {
1018 #ifndef MACINTOSH
1019         fd_set fdset;
1020         struct timeval tv;
1021
1022         tv.tv_sec = 0;
1023         tv.tv_usec = WAIT;
1024
1025         FD_ZERO(&fdset);
1026         FD_SET(sd, &fdset);
1027
1028         Term_clear();
1029         Term_fresh();
1030         Term_xtra(TERM_XTRA_REACT, 0);
1031
1032         while (1)
1033         {
1034                 fd_set tmp_fdset;
1035                 struct timeval tmp_tv;
1036
1037                 if (flush_ringbuf_client()) continue;
1038
1039                 tmp_fdset = fdset;
1040                 tmp_tv = tv;
1041
1042                 /* ソケットにデータが来ているかどうか調べる */
1043                 select(sd+1, &tmp_fdset, (fd_set *)NULL, (fd_set *)NULL, &tmp_tv);
1044                 if (FD_ISSET(sd, &tmp_fdset) == 0)
1045                 {
1046                         Term_xtra(TERM_XTRA_FLUSH, 0);
1047                         continue;
1048                 }
1049
1050                 if (read_sock() < 0)
1051                 {
1052                         chuukei_client = FALSE;
1053                 }
1054
1055                 /* 接続が切れた状態で書くべきデータがなくなっていたら終了 */
1056                 if (!chuukei_client && fresh_queue.next == fresh_queue.tail ) break;
1057         }
1058 #else
1059         Term_clear();
1060         Term_fresh();
1061         Term_xtra(TERM_XTRA_REACT, 0);
1062
1063         while (1)
1064         {
1065                 UInt32  unreadData = 0;
1066                 int n;
1067
1068                 if (flush_ringbuf_client()) continue;
1069
1070                 /* ソケットにデータが来ているかどうか調べる */
1071
1072                 OTCountDataBytes(ep, &unreadData);
1073                 if(unreadData <= 0 ){
1074                         Term_xtra(TERM_XTRA_FLUSH, 0);
1075                         continue;
1076                 }
1077                 if (read_sock() < 0)
1078                 {
1079                         chuukei_client = FALSE;
1080                 }
1081
1082                 /* 接続が切れた状態で書くべきデータがなくなっていたら終了 */
1083                 if (!chuukei_client && fresh_queue.next == fresh_queue.tail ) break;
1084         }
1085 #endif /*MACINTOSH*/
1086 }
1087 #endif /* CHUUKEI */
1088
1089 void prepare_browse_movie_aux(cptr filename)
1090 {
1091         movie_fd = fd_open(filename, O_RDONLY);
1092
1093         browsing_movie = TRUE;
1094
1095         init_buffer();
1096 }
1097
1098 void prepare_browse_movie(cptr filename)
1099 {
1100         char buf[1024];
1101         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, filename);
1102
1103         prepare_browse_movie_aux(buf);
1104 }
1105
1106 void browse_movie(void)
1107 {
1108         Term_clear();
1109         Term_fresh();
1110         Term_xtra(TERM_XTRA_REACT, 0);
1111
1112         while (read_movie_file() == 0)
1113         {
1114                 while (fresh_queue.next != fresh_queue.tail)
1115                 {
1116                         if (!flush_ringbuf_client())
1117                         {
1118                                 Term_xtra(TERM_XTRA_FLUSH, 0);
1119
1120                                 /* ソケットにデータが来ているかどうか調べる */
1121 #ifdef WINDOWS
1122                                 Sleep(WAIT);
1123 #else
1124                                 usleep(WAIT);
1125 #endif
1126                         }
1127                 }
1128         }
1129 }