/[LeafOK_CVS]/lbbs/src/io.c
ViewVC logotype

Diff of /lbbs/src/io.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.30 by sysadm, Tue May 13 02:19:15 2025 UTC Revision 1.44 by sysadm, Tue Jun 17 02:06:48 2025 UTC
# Line 27  Line 27 
27  #include <sys/select.h>  #include <sys/select.h>
28  #include <sys/ioctl.h>  #include <sys/ioctl.h>
29  #include <sys/epoll.h>  #include <sys/epoll.h>
30    #include <libssh/libssh.h>
31    #include <libssh/server.h>
32    #include <libssh/callbacks.h>
33    
34  static char stdout_buf[BUFSIZ];  static char stdout_buf[BUFSIZ];
35  static int stdout_buf_len = 0;  static int stdout_buf_len = 0;
# Line 48  int prints(const char *format, ...) Line 51  int prints(const char *format, ...)
51                  {                  {
52                          iflush();                          iflush();
53                  }                  }
54                    
55                  if (stdout_buf_len + ret <= BUFSIZ)                  if (stdout_buf_len + ret <= BUFSIZ)
56                  {                  {
57                          memcpy(stdout_buf + stdout_buf_len, buf, (size_t)ret);                          memcpy(stdout_buf + stdout_buf_len, buf, (size_t)ret);
# Line 58  int prints(const char *format, ...) Line 61  int prints(const char *format, ...)
61                  {                  {
62                          errno = EAGAIN;                          errno = EAGAIN;
63                          ret = (BUFSIZ - stdout_buf_len - ret);                          ret = (BUFSIZ - stdout_buf_len - ret);
64                            log_error("Output buffer is full, additional %d is required\n", ret);
65                  }                  }
66          }          }
67    
# Line 87  int outc(char c) Line 91  int outc(char c)
91          return ret;          return ret;
92  }  }
93    
94  int iflush()  int iflush(void)
95  {  {
96          int flags;          int flags;
97          struct epoll_event ev, events[MAX_EVENTS];          struct epoll_event ev, events[MAX_EVENTS];
# Line 107  int iflush() Line 111  int iflush()
111          if (epoll_ctl(epollfd, EPOLL_CTL_ADD, STDOUT_FILENO, &ev) == -1)          if (epoll_ctl(epollfd, EPOLL_CTL_ADD, STDOUT_FILENO, &ev) == -1)
112          {          {
113                  log_error("epoll_ctl(STDOUT_FILENO) error (%d)\n", errno);                  log_error("epoll_ctl(STDOUT_FILENO) error (%d)\n", errno);
114                    if (close(epollfd) < 0)
115                    {
116                            log_error("close(epoll) error (%d)\n");
117                    }
118                  return -1;                  return -1;
119          }          }
120    
# Line 142  int iflush() Line 150  int iflush()
150                          {                          {
151                                  while (stdout_buf_offset < stdout_buf_len && !SYS_server_exit) // write until complete or error                                  while (stdout_buf_offset < stdout_buf_len && !SYS_server_exit) // write until complete or error
152                                  {                                  {
153                                          ret = (int)write(STDOUT_FILENO, stdout_buf + stdout_buf_offset, (size_t)(stdout_buf_len - stdout_buf_offset));                                          if (SSH_v2)
154                                            {
155                                                    ret = ssh_channel_write(SSH_channel, stdout_buf + stdout_buf_offset, (uint32_t)(stdout_buf_len - stdout_buf_offset));
156                                                    if (ret == SSH_ERROR)
157                                                    {
158                                                            log_error("ssh_channel_write() error: %s\n", ssh_get_error(SSH_session));
159                                                            retry = 0;
160                                                            break;
161                                                    }
162                                            }
163                                            else
164                                            {
165                                                    ret = (int)write(STDOUT_FILENO, stdout_buf + stdout_buf_offset, (size_t)(stdout_buf_len - stdout_buf_offset));
166                                            }
167                                          if (ret < 0)                                          if (ret < 0)
168                                          {                                          {
169                                                  if (errno == EAGAIN || errno == EWOULDBLOCK)                                                  if (errno == EAGAIN || errno == EWOULDBLOCK)
# Line 186  int iflush() Line 207  int iflush()
207          // Restore STDOUT flags          // Restore STDOUT flags
208          fcntl(STDOUT_FILENO, F_SETFL, flags);          fcntl(STDOUT_FILENO, F_SETFL, flags);
209    
210            if (close(epollfd) < 0)
211            {
212                    log_error("close(epoll) error (%d)\n");
213            }
214    
215          return ret;          return ret;
216  }  }
217    
218  int igetch(int clear_buf)  int igetch(int timeout)
219  {  {
220          // static input buffer          // static input buffer
221          static unsigned char buf[LINE_BUFFER_LEN];          static unsigned char buf[LINE_BUFFER_LEN];
222          static ssize_t len = 0;          static int len = 0;
223          static int pos = 0;          static int pos = 0;
224    
225          struct epoll_event ev, events[MAX_EVENTS];          struct epoll_event ev, events[MAX_EVENTS];
226          int nfds, epollfd;          int nfds, epollfd;
227            int ret;
228            int loop;
229    
230          unsigned char tmp[LINE_BUFFER_LEN];          unsigned char tmp[LINE_BUFFER_LEN];
231          int out = '\0';          int out = KEY_NULL;
232          int in_esc = 0;          int in_esc = 0;
233          int in_ascii = 0;          int in_ascii = 0;
234          int in_control = 0;          int in_control = 0;
235          int i = 0;          int i = 0;
236          int flags;          int flags;
237    
         if (clear_buf)  
         {  
                 pos = 0;  
                 len = 0;  
   
                 return '\0';  
         }  
   
238          epollfd = epoll_create1(0);          epollfd = epoll_create1(0);
239          if (epollfd < 0)          if (epollfd < 0)
240          {          {
# Line 227  int igetch(int clear_buf) Line 247  int igetch(int clear_buf)
247          if (epoll_ctl(epollfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev) == -1)          if (epoll_ctl(epollfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev) == -1)
248          {          {
249                  log_error("epoll_ctl(STDIN_FILENO) error (%d)\n", errno);                  log_error("epoll_ctl(STDIN_FILENO) error (%d)\n", errno);
250    
251                    if (close(epollfd) < 0)
252                    {
253                            log_error("close(epoll) error (%d)\n");
254                    }
255                  return -1;                  return -1;
256          }          }
257    
258          flags = fcntl(STDIN_FILENO, F_GETFL, 0);          flags = fcntl(STDIN_FILENO, F_GETFL, 0);
259          fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);          fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);
260    
261          while (!SYS_server_exit && pos >= len)          loop = 1;
262    
263            while (loop && pos >= len && !SYS_server_exit)
264          {          {
265                  nfds = epoll_wait(epollfd, events, MAX_EVENTS, 100); // 0.1 second                  len = 0;
266                    pos = 0;
267    
268                    if (SSH_v2 && ssh_channel_is_closed(SSH_channel))
269                    {
270                            log_error("SSH channel is closed\n");
271                            loop = 0;
272                            break;
273                    }
274    
275                    nfds = epoll_wait(epollfd, events, MAX_EVENTS, timeout);
276    
277                  if (nfds < 0)                  if (nfds < 0)
278                  {                  {
279                          if (errno != EINTR)                          if (errno != EINTR)
280                          {                          {
281                                  log_error("epoll_wait() error (%d)\n", errno);                                  log_error("epoll_wait() error (%d)\n", errno);
282                                  fcntl(STDIN_FILENO, F_SETFL, flags);                                  break;
                                 return KEY_NULL;  
283                          }                          }
284                          continue;                          continue;
285                  }                  }
286                  else if (nfds == 0)                  else if (nfds == 0) // timeout
287                  {                  {
288                          fcntl(STDIN_FILENO, F_SETFL, flags);                          out = KEY_TIMEOUT;
289                          return KEY_TIMEOUT;                          break;
290                  }                  }
291    
292                  for (int i = 0; i < nfds; i++)                  for (int i = 0; i < nfds; i++)
293                  {                  {
294                          if (events[i].data.fd == STDIN_FILENO)                          if (events[i].data.fd == STDIN_FILENO)
295                          {                          {
296                                  while (!SYS_server_exit) // read until complete or error                                  while (len < sizeof(buf) && !SYS_server_exit) // read until complete or error
297                                  {                                  {
298                                          len = read(STDIN_FILENO, buf, sizeof(buf));                                          if (SSH_v2)
299                                          if (len < 0)                                          {
300                                                    ret = ssh_channel_read_nonblocking(SSH_channel, buf + len, sizeof(buf) - (uint32_t)len, 0);
301                                                    if (ret == SSH_ERROR)
302                                                    {
303                                                            log_error("ssh_channel_read_nonblocking() error: %s\n", ssh_get_error(SSH_session));
304                                                            loop = 0;
305                                                            break;
306                                                    }
307                                                    else if (ret == SSH_EOF)
308                                                    {
309                                                            loop = 0;
310                                                            break;
311                                                    }
312                                                    else if (ret == 0)
313                                                    {
314                                                            out = 0;
315                                                            break; // Check whether channel is still open
316                                                    }
317                                            }
318                                            else
319                                            {
320                                                    ret = (int)read(STDIN_FILENO, buf + len, sizeof(buf) - (size_t)len);
321                                            }
322                                            if (ret < 0)
323                                          {                                          {
324                                                  if (errno == EAGAIN || errno == EWOULDBLOCK)                                                  if (errno == EAGAIN || errno == EWOULDBLOCK)
325                                                  {                                                  {
326                                                          fcntl(STDIN_FILENO, F_SETFL, flags);                                                          out = 0;
327                                                          return KEY_TIMEOUT;                                                          loop = 0;
328                                                            break;
329                                                  }                                                  }
330                                                  else if (errno == EINTR)                                                  else if (errno == EINTR)
331                                                  {                                                  {
# Line 274  int igetch(int clear_buf) Line 334  int igetch(int clear_buf)
334                                                  else                                                  else
335                                                  {                                                  {
336                                                          log_error("read(STDIN) error (%d)\n", errno);                                                          log_error("read(STDIN) error (%d)\n", errno);
337                                                          fcntl(STDIN_FILENO, F_SETFL, flags);                                                          loop = 0;
338                                                          return KEY_NULL;                                                          break;
339                                                  }                                                  }
340                                          }                                          }
341                                          else if (len == 0) // broken pipe                                          else if (ret == 0) // broken pipe
342                                          {                                          {
343                                                  fcntl(STDIN_FILENO, F_SETFL, flags);                                                  loop = 0;
344                                                  return KEY_NULL;                                                  break;
345                                            }
346                                            else
347                                            {
348                                                    len += ret;
349                                                    continue;
350                                          }                                          }
   
                                         pos = 0;  
                                         break;  
351                                  }                                  }
352                          }                          }
353                  }                  }
354    
355                  // For debug                  // For debug
356                  // for (j = 0; j < len; j++)                  // for (int j = pos; j < len; j++)
357                  //   log_std ("<--[%u]\n", (buf[j] + 256) % 256);                  // {
358                    //      log_common("Debug: <--[%u]\n", (buf[j] + 256) % 256);
359                    // }
360          }          }
361    
362          fcntl(STDIN_FILENO, F_SETFL, flags);          fcntl(STDIN_FILENO, F_SETFL, flags);
# Line 323  int igetch(int clear_buf) Line 387  int igetch(int clear_buf)
387                          continue;                          continue;
388                  }                  }
389    
390                  if (c == ESC_KEY)                  if (c == KEY_ESC)
391                  {                  {
392                          if (in_esc == 0)                          if (in_esc == 0)
393                          {                          {
# Line 334  int igetch(int clear_buf) Line 398  int igetch(int clear_buf)
398                          }                          }
399                          else                          else
400                          {                          {
401                                  out = ESC_KEY;                                  out = KEY_CSI;
402                                  in_esc = 0;                                  in_esc = 0;
403                                  break;                                  break;
404                          }                          }
# Line 345  int igetch(int clear_buf) Line 409  int igetch(int clear_buf)
409                  if (in_ascii)                  if (in_ascii)
410                  {                  {
411                          tmp[i++] = c;                          tmp[i++] = c;
412                          if (c == 'm')                          if (i == 2 && (tmp[0] == 79 || tmp[0] == 91))
                         {  
                                 in_ascii = 0;  
                                 continue;  
                         }  
                         if (i == 2 && c >= 'A' && c <= 'D')  
413                          {                          {
414                                  in_ascii = 0;                                  in_ascii = 0;
415                                  switch (c)                                  switch (tmp[1])
416                                  {                                  {
417                                  case 'A':                                  case 65:
418                                          out = KEY_UP;                                          out = KEY_UP;
419                                          break;                                          break;
420                                  case 'B':                                  case 66:
421                                          out = KEY_DOWN;                                          out = KEY_DOWN;
422                                          break;                                          break;
423                                  case 'C':                                  case 67:
424                                          out = KEY_RIGHT;                                          out = KEY_RIGHT;
425                                          break;                                          break;
426                                  case 'D':                                  case 68:
427                                          out = KEY_LEFT;                                          out = KEY_LEFT;
428                                          break;                                          break;
429                                    default:
430                                            in_ascii = 1;
431                                    }
432                                    if (!in_ascii)
433                                    {
434                                            break;
435                                    }
436                            }
437                            if (i == 2 && tmp[0] == 91) // Fterm
438                            {
439                                    in_ascii = 0;
440                                    switch (tmp[1])
441                                    {
442                                    case 86:
443                                            out = KEY_SHIFT_F1;
444                                            break;
445                                    case 90:
446                                            out = KEY_SHIFT_F2;
447                                            break;
448                                    case 97:
449                                            out = KEY_SHIFT_F3;
450                                            break;
451                                    case 98:
452                                            out = KEY_SHIFT_F4;
453                                            break;
454                                    case 99:
455                                            out = KEY_SHIFT_F5;
456                                            break;
457                                    case 100:
458                                            out = KEY_SHIFT_F6;
459                                            break;
460                                    case 101:
461                                            out = KEY_SHIFT_F7;
462                                            break;
463                                    case 102:
464                                            out = KEY_SHIFT_F8;
465                                            break;
466                                    case 103:
467                                            out = KEY_SHIFT_F9;
468                                            break;
469                                    case 104:
470                                            out = KEY_SHIFT_F10;
471                                            break;
472                                    case 107:
473                                            out = KEY_CTRL_F1;
474                                            break;
475                                    case 108:
476                                            out = KEY_CTRL_F2;
477                                            break;
478                                    case 109:
479                                            out = KEY_CTRL_F3;
480                                            break;
481                                    case 112:
482                                            out = KEY_CTRL_F6;
483                                            break;
484                                    case 113:
485                                            out = KEY_CTRL_F7;
486                                            break;
487                                    case 114:
488                                            out = KEY_CTRL_F8;
489                                            break;
490                                    case 115:
491                                            out = KEY_CTRL_F9;
492                                            break;
493                                    case 116:
494                                            out = KEY_CTRL_F10;
495                                            break;
496                                    default:
497                                            in_ascii = 1;
498                                    }
499                                    if (!in_ascii)
500                                    {
501                                            break;
502                                    }
503                            }
504                            if (i == 2 && tmp[0] == 79) // Xterm
505                            {
506                                    in_ascii = 0;
507                                    switch (tmp[1])
508                                    {
509                                    case 80:
510                                            out = KEY_F1;
511                                            break;
512                                    case 81:
513                                            out = KEY_F2;
514                                            break;
515                                    case 82:
516                                            out = KEY_F3;
517                                            break;
518                                    case 83:
519                                            out = KEY_F4;
520                                            break;
521                                    default:
522                                            in_ascii = 1;
523                                    }
524                                    if (!in_ascii)
525                                    {
526                                            break;
527                                  }                                  }
                                 break;  
528                          }                          }
529                          if (i == 3 && tmp[0] == 91 && tmp[2] == 126)                          if (i == 3 && tmp[0] == 91 && tmp[2] == 126)
530                          {                          {
# Line 378  int igetch(int clear_buf) Line 534  int igetch(int clear_buf)
534                                  case 49:                                  case 49:
535                                          out = KEY_HOME;                                          out = KEY_HOME;
536                                          break;                                          break;
537                                    case 50:
538                                            out = KEY_INS;
539                                            break;
540                                  case 51:                                  case 51:
541                                          out = KEY_DEL;                                          out = KEY_DEL;
542                                          break;                                          break;
# Line 390  int igetch(int clear_buf) Line 549  int igetch(int clear_buf)
549                                  case 54:                                  case 54:
550                                          out = KEY_PGDN;                                          out = KEY_PGDN;
551                                          break;                                          break;
552                                    default:
553                                            in_ascii = 1;
554                                    }
555                                    if (!in_ascii)
556                                    {
557                                            break;
558                                    }
559                            }
560                            if (i == 4 && tmp[0] == 91 && tmp[1] == 49 && tmp[3] == 126) // Fterm
561                            {
562                                    in_ascii = 0;
563                                    switch (tmp[2])
564                                    {
565                                    case 49:
566                                            out = KEY_F1;
567                                            break;
568                                    case 50:
569                                            out = KEY_F2;
570                                            break;
571                                    case 51:
572                                            out = KEY_F3;
573                                            break;
574                                    case 52:
575                                            out = KEY_F4;
576                                            break;
577                                    case 53:
578                                            out = KEY_F5;
579                                            break;
580                                    case 55:
581                                            out = KEY_F6;
582                                            break;
583                                    case 56:
584                                            out = KEY_F7;
585                                            break;
586                                    case 57:
587                                            out = KEY_F8;
588                                            break;
589                                    default:
590                                            in_ascii = 1;
591                                    }
592                                    if (!in_ascii)
593                                    {
594                                            break;
595                                    }
596                            }
597                            if (i == 4 && tmp[0] == 91 && tmp[1] == 50 && tmp[3] == 126) // Fterm
598                            {
599                                    in_ascii = 0;
600                                    switch (tmp[2])
601                                    {
602                                    case 48:
603                                            out = KEY_F9;
604                                            break;
605                                    case 49:
606                                            out = KEY_F10;
607                                            break;
608                                    case 50:
609                                            out = KEY_F11; // Fterm
610                                            break;
611                                    case 51:
612                                            out = KEY_F11; // Xterm
613                                            break;
614                                    case 52:
615                                            out = KEY_F12; // Xterm
616                                            break;
617                                    default:
618                                            in_ascii = 1;
619                                    }
620                                    if (!in_ascii)
621                                    {
622                                            break;
623                                    }
624                            }
625                            if (i == 5 && tmp[0] == 91 && tmp[1] == 49 && tmp[2] == 59 && tmp[3] == 53) // Xterm
626                            {
627                                    in_ascii = 0;
628                                    switch (tmp[4])
629                                    {
630                                    case 65:
631                                            out = KEY_CTRL_UP;
632                                            break;
633                                    case 66:
634                                            out = KEY_CTRL_DOWN;
635                                            break;
636                                    case 67:
637                                            out = KEY_CTRL_RIGHT;
638                                            break;
639                                    case 68:
640                                            out = KEY_CTRL_LEFT;
641                                            break;
642                                    case 70:
643                                            out = KEY_CTRL_END;
644                                            break;
645                                    case 72:
646                                            out = KEY_CTRL_HOME;
647                                            break;
648                                    case 80:
649                                            out = KEY_CTRL_F1;
650                                            break;
651                                    case 81:
652                                            out = KEY_CTRL_F2;
653                                            break;
654                                    case 82:
655                                            out = KEY_CTRL_F3;
656                                            break;
657                                    default:
658                                            in_ascii = 1;
659                                    }
660                                    if (!in_ascii)
661                                    {
662                                            break;
663                                    }
664                            }
665                            if (i == 6 && tmp[0] == 91 && tmp[1] == 49 && tmp[3] == 59 && tmp[4] == 53 && tmp[5] == 126) // Xterm
666                            {
667                                    in_ascii = 0;
668                                    switch (tmp[2])
669                                    {
670                                    case 53:
671                                            out = KEY_CTRL_F5;
672                                            break;
673                                    case 55:
674                                            out = KEY_CTRL_F6;
675                                            break;
676                                    case 56:
677                                            out = KEY_CTRL_F7;
678                                            break;
679                                    case 57:
680                                            out = KEY_CTRL_F8;
681                                            break;
682                                    default:
683                                            in_ascii = 1;
684                                    }
685                                    if (!in_ascii)
686                                    {
687                                            break;
688                                  }                                  }
689                                  break;                          }
690                            if (i == 6 && tmp[0] == 91 && tmp[1] == 50 && tmp[3] == 59 && tmp[4] == 53 && tmp[5] == 126) // Xterm
691                            {
692                                    in_ascii = 0;
693                                    switch (tmp[2])
694                                    {
695                                    case 48:
696                                            out = KEY_CTRL_F9;
697                                            break;
698                                    case 49:
699                                            out = KEY_CTRL_F10;
700                                            break;
701                                    case 51:
702                                            out = KEY_CTRL_F11;
703                                            break;
704                                    case 52:
705                                            out = KEY_CTRL_F12;
706                                            break;
707                                    default:
708                                            in_ascii = 1;
709                                    }
710                                    if (!in_ascii)
711                                    {
712                                            break;
713                                    }
714                            }
715                            if (i == 5 && tmp[0] == 91 && tmp[1] == 49 && tmp[2] == 59 && tmp[3] == 50) // Xterm
716                            {
717                                    in_ascii = 0;
718                                    switch (tmp[4])
719                                    {
720                                    case 80:
721                                            out = KEY_SHIFT_F1;
722                                            break;
723                                    case 81:
724                                            out = KEY_SHIFT_F2;
725                                            break;
726                                    case 82:
727                                            out = KEY_SHIFT_F3;
728                                            break;
729                                    case 83:
730                                            out = KEY_SHIFT_F4;
731                                            break;
732                                    default:
733                                            in_ascii = 1;
734                                    }
735                                    if (!in_ascii)
736                                    {
737                                            break;
738                                    }
739                            }
740                            if (i == 6 && tmp[0] == 91 && tmp[1] == 49 && tmp[3] == 59 && tmp[4] == 50 && tmp[5] == 126) // Xterm
741                            {
742                                    in_ascii = 0;
743                                    switch (tmp[2])
744                                    {
745                                    case 53:
746                                            out = KEY_SHIFT_F5;
747                                            break;
748                                    case 55:
749                                            out = KEY_SHIFT_F6;
750                                            break;
751                                    case 56:
752                                            out = KEY_SHIFT_F7;
753                                            break;
754                                    case 57:
755                                            out = KEY_SHIFT_F8;
756                                            break;
757                                    default:
758                                            in_ascii = 1;
759                                    }
760                                    if (!in_ascii)
761                                    {
762                                            break;
763                                    }
764                            }
765                            if (i == 6 && tmp[0] == 91 && tmp[1] == 50 && tmp[3] == 59 && tmp[4] == 50 && tmp[5] == 126) // Xterm
766                            {
767                                    in_ascii = 0;
768                                    switch (tmp[2])
769                                    {
770                                    case 48:
771                                            out = KEY_SHIFT_F9;
772                                            break;
773                                    case 49:
774                                            out = KEY_SHIFT_F10;
775                                            break;
776                                    case 51:
777                                            out = KEY_SHIFT_F11;
778                                            break;
779                                    case 52:
780                                            out = KEY_SHIFT_F12;
781                                            break;
782                                    default:
783                                            in_ascii = 1;
784                                    }
785                                    if (!in_ascii)
786                                    {
787                                            break;
788                                    }
789                            }
790    
791                            if (c == 'm')
792                            {
793                                    in_ascii = 0;
794                          }                          }
795                          continue;                          continue;
796                  }                  }
# Line 400  int igetch(int clear_buf) Line 799  int igetch(int clear_buf)
799                  break;                  break;
800          }          }
801    
802            if (close(epollfd) < 0)
803            {
804                    log_error("close(epoll) error (%d)\n");
805            }
806    
807            // For ESC key
808            if (out == 0 && in_esc)
809            {
810                    out = KEY_ESC;
811            }
812    
813          // for debug          // for debug
814          // log_std ("-->[%u]\n", out);          // if (out != KEY_TIMEOUT && out != KEY_NULL)
815            // {
816            //      log_common("Debug: -->[0x %x]\n", out);
817            // }
818    
819          return out;          return out;
820  }  }
821    
822  int igetch_t(long int sec)  int igetch_t(int sec)
823  {  {
824          int ch;          int ch;
825          time_t t_begin = time(0);          time_t t_begin = time(NULL);
826    
827          do          do
828          {          {
829                  ch = igetch(0);                  ch = igetch(100);
830          } while (!SYS_server_exit && ch == KEY_TIMEOUT && (time(0) - t_begin < sec));          } while (!SYS_server_exit && ch == KEY_TIMEOUT && (time(NULL) - t_begin < sec));
831    
832          return ch;          return ch;
833  }  }
834    
835    void igetch_reset()
836    {
837            int ch;
838            do
839            {
840                    ch = igetch(0);
841            } while (ch != KEY_NULL && ch != KEY_TIMEOUT);
842    }

Legend:
Removed lines/characters  
Changed lines/characters
  Added lines/characters
webmaster@leafok.com
 ViewVC Help
Powered by ViewVC 1.3.0-beta1