/[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.31 by sysadm, Tue May 13 07:28:51 2025 UTC Revision 1.47 by sysadm, Sat Jun 21 02:15:18 2025 UTC
# Line 14  Line 14 
14   *                                                                         *   *                                                                         *
15   ***************************************************************************/   ***************************************************************************/
16    
17    #include "common.h"
18  #include "io.h"  #include "io.h"
19  #include "log.h"  #include "log.h"
 #include "common.h"  
20  #include <errno.h>  #include <errno.h>
21  #include <stdio.h>  #include <fcntl.h>
22  #include <stdarg.h>  #include <stdarg.h>
23    #include <stdio.h>
24  #include <string.h>  #include <string.h>
25  #include <time.h>  #include <time.h>
 #include <fcntl.h>  
26  #include <unistd.h>  #include <unistd.h>
 #include <sys/select.h>  
 #include <sys/ioctl.h>  
27  #include <sys/epoll.h>  #include <sys/epoll.h>
28    #include <sys/ioctl.h>
29    #include <sys/select.h>
30    #include <libssh/callbacks.h>
31    #include <libssh/libssh.h>
32    #include <libssh/server.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 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 146  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 159  int iflush() Line 176  int iflush()
176                                                  }                                                  }
177                                                  else                                                  else
178                                                  {                                                  {
179    #ifdef _DEBUG
180                                                          log_error("write(STDOUT) error (%d)\n", errno);                                                          log_error("write(STDOUT) error (%d)\n", errno);
181    #endif
182                                                          retry = 0;                                                          retry = 0;
183                                                          break;                                                          break;
184                                                  }                                                  }
# Line 248  int igetch(int timeout) Line 267  int igetch(int timeout)
267                  len = 0;                  len = 0;
268                  pos = 0;                  pos = 0;
269    
270                    if (SSH_v2 && ssh_channel_is_closed(SSH_channel))
271                    {
272                            log_error("SSH channel is closed\n");
273                            loop = 0;
274                            break;
275                    }
276    
277                  nfds = epoll_wait(epollfd, events, MAX_EVENTS, timeout);                  nfds = epoll_wait(epollfd, events, MAX_EVENTS, timeout);
278    
279                  if (nfds < 0)                  if (nfds < 0)
# Line 271  int igetch(int timeout) Line 297  int igetch(int timeout)
297                          {                          {
298                                  while (len < sizeof(buf) && !SYS_server_exit) // read until complete or error                                  while (len < sizeof(buf) && !SYS_server_exit) // read until complete or error
299                                  {                                  {
300                                          ret = (int)read(STDIN_FILENO, buf + len, sizeof(buf) - (size_t)len);                                          if (SSH_v2)
301                                            {
302                                                    ret = ssh_channel_read_nonblocking(SSH_channel, buf + len, sizeof(buf) - (uint32_t)len, 0);
303                                                    if (ret == SSH_ERROR)
304                                                    {
305                                                            log_error("ssh_channel_read_nonblocking() error: %s\n", ssh_get_error(SSH_session));
306                                                            loop = 0;
307                                                            break;
308                                                    }
309                                                    else if (ret == SSH_EOF)
310                                                    {
311                                                            loop = 0;
312                                                            break;
313                                                    }
314                                                    else if (ret == 0)
315                                                    {
316                                                            out = 0;
317                                                            break; // Check whether channel is still open
318                                                    }
319                                            }
320                                            else
321                                            {
322                                                    ret = (int)read(STDIN_FILENO, buf + len, sizeof(buf) - (size_t)len);
323                                            }
324                                          if (ret < 0)                                          if (ret < 0)
325                                          {                                          {
326                                                  if (errno == EAGAIN || errno == EWOULDBLOCK)                                                  if (errno == EAGAIN || errno == EWOULDBLOCK)
327                                                  {                                                  {
328                                                            out = 0;
329                                                          loop = 0;                                                          loop = 0;
330                                                          break;                                                          break;
331                                                  }                                                  }
# Line 285  int igetch(int timeout) Line 335  int igetch(int timeout)
335                                                  }                                                  }
336                                                  else                                                  else
337                                                  {                                                  {
338    #ifdef _DEBUG
339                                                          log_error("read(STDIN) error (%d)\n", errno);                                                          log_error("read(STDIN) error (%d)\n", errno);
340    #endif
341                                                          loop = 0;                                                          loop = 0;
342                                                          break;                                                          break;
343                                                  }                                                  }
# Line 305  int igetch(int timeout) Line 357  int igetch(int timeout)
357                  }                  }
358    
359                  // For debug                  // For debug
360                  // for (j = 0; j < len; j++)  #ifdef _DEBUG
361                  //   log_std ("<--[%u]\n", (buf[j] + 256) % 256);                  for (int j = pos; j < len; j++)
362                    {
363                            log_common("Debug: <--[%u]\n", (buf[j] + 256) % 256);
364                    }
365    #endif
366          }          }
367    
368          fcntl(STDIN_FILENO, F_SETFL, flags);          fcntl(STDIN_FILENO, F_SETFL, flags);
# Line 337  int igetch(int timeout) Line 393  int igetch(int timeout)
393                          continue;                          continue;
394                  }                  }
395    
396                  if (c == ESC_KEY)                  if (c == KEY_ESC)
397                  {                  {
398                          if (in_esc == 0)                          if (in_esc == 0)
399                          {                          {
# Line 348  int igetch(int timeout) Line 404  int igetch(int timeout)
404                          }                          }
405                          else                          else
406                          {                          {
407                                  out = ESC_KEY;                                  out = KEY_CSI;
408                                  in_esc = 0;                                  in_esc = 0;
409                                  break;                                  break;
410                          }                          }
# Line 359  int igetch(int timeout) Line 415  int igetch(int timeout)
415                  if (in_ascii)                  if (in_ascii)
416                  {                  {
417                          tmp[i++] = c;                          tmp[i++] = c;
418                          if (c == 'm')                          if (i == 2 && (tmp[0] == 79 || tmp[0] == 91))
419                          {                          {
420                                  in_ascii = 0;                                  in_ascii = 0;
421                                  continue;                                  switch (tmp[1])
                         }  
                         if (i == 2 && c >= 'A' && c <= 'D')  
                         {  
                                 in_ascii = 0;  
                                 switch (c)  
422                                  {                                  {
423                                  case 'A':                                  case 65:
424                                          out = KEY_UP;                                          out = KEY_UP;
425                                          break;                                          break;
426                                  case 'B':                                  case 66:
427                                          out = KEY_DOWN;                                          out = KEY_DOWN;
428                                          break;                                          break;
429                                  case 'C':                                  case 67:
430                                          out = KEY_RIGHT;                                          out = KEY_RIGHT;
431                                          break;                                          break;
432                                  case 'D':                                  case 68:
433                                          out = KEY_LEFT;                                          out = KEY_LEFT;
434                                          break;                                          break;
435                                    default:
436                                            in_ascii = 1;
437                                    }
438                                    if (!in_ascii)
439                                    {
440                                            break;
441                                    }
442                            }
443                            if (i == 2 && tmp[0] == 91) // Fterm
444                            {
445                                    in_ascii = 0;
446                                    switch (tmp[1])
447                                    {
448                                    case 86:
449                                            out = KEY_SHIFT_F1;
450                                            break;
451                                    case 90:
452                                            out = KEY_SHIFT_F2;
453                                            break;
454                                    case 97:
455                                            out = KEY_SHIFT_F3;
456                                            break;
457                                    case 98:
458                                            out = KEY_SHIFT_F4;
459                                            break;
460                                    case 99:
461                                            out = KEY_SHIFT_F5;
462                                            break;
463                                    case 100:
464                                            out = KEY_SHIFT_F6;
465                                            break;
466                                    case 101:
467                                            out = KEY_SHIFT_F7;
468                                            break;
469                                    case 102:
470                                            out = KEY_SHIFT_F8;
471                                            break;
472                                    case 103:
473                                            out = KEY_SHIFT_F9;
474                                            break;
475                                    case 104:
476                                            out = KEY_SHIFT_F10;
477                                            break;
478                                    case 107:
479                                            out = KEY_CTRL_F1;
480                                            break;
481                                    case 108:
482                                            out = KEY_CTRL_F2;
483                                            break;
484                                    case 109:
485                                            out = KEY_CTRL_F3;
486                                            break;
487                                    case 112:
488                                            out = KEY_CTRL_F6;
489                                            break;
490                                    case 113:
491                                            out = KEY_CTRL_F7;
492                                            break;
493                                    case 114:
494                                            out = KEY_CTRL_F8;
495                                            break;
496                                    case 115:
497                                            out = KEY_CTRL_F9;
498                                            break;
499                                    case 116:
500                                            out = KEY_CTRL_F10;
501                                            break;
502                                    default:
503                                            in_ascii = 1;
504                                    }
505                                    if (!in_ascii)
506                                    {
507                                            break;
508                                    }
509                            }
510                            if (i == 2 && tmp[0] == 79) // Xterm
511                            {
512                                    in_ascii = 0;
513                                    switch (tmp[1])
514                                    {
515                                    case 80:
516                                            out = KEY_F1;
517                                            break;
518                                    case 81:
519                                            out = KEY_F2;
520                                            break;
521                                    case 82:
522                                            out = KEY_F3;
523                                            break;
524                                    case 83:
525                                            out = KEY_F4;
526                                            break;
527                                    default:
528                                            in_ascii = 1;
529                                    }
530                                    if (!in_ascii)
531                                    {
532                                            break;
533                                  }                                  }
                                 break;  
534                          }                          }
535                          if (i == 3 && tmp[0] == 91 && tmp[2] == 126)                          if (i == 3 && tmp[0] == 91 && tmp[2] == 126)
536                          {                          {
# Line 392  int igetch(int timeout) Line 540  int igetch(int timeout)
540                                  case 49:                                  case 49:
541                                          out = KEY_HOME;                                          out = KEY_HOME;
542                                          break;                                          break;
543                                    case 50:
544                                            out = KEY_INS;
545                                            break;
546                                  case 51:                                  case 51:
547                                          out = KEY_DEL;                                          out = KEY_DEL;
548                                          break;                                          break;
# Line 404  int igetch(int timeout) Line 555  int igetch(int timeout)
555                                  case 54:                                  case 54:
556                                          out = KEY_PGDN;                                          out = KEY_PGDN;
557                                          break;                                          break;
558                                    default:
559                                            in_ascii = 1;
560                                    }
561                                    if (!in_ascii)
562                                    {
563                                            break;
564                                    }
565                            }
566                            if (i == 4 && tmp[0] == 91 && tmp[1] == 49 && tmp[3] == 126) // Fterm
567                            {
568                                    in_ascii = 0;
569                                    switch (tmp[2])
570                                    {
571                                    case 49:
572                                            out = KEY_F1;
573                                            break;
574                                    case 50:
575                                            out = KEY_F2;
576                                            break;
577                                    case 51:
578                                            out = KEY_F3;
579                                            break;
580                                    case 52:
581                                            out = KEY_F4;
582                                            break;
583                                    case 53:
584                                            out = KEY_F5;
585                                            break;
586                                    case 55:
587                                            out = KEY_F6;
588                                            break;
589                                    case 56:
590                                            out = KEY_F7;
591                                            break;
592                                    case 57:
593                                            out = KEY_F8;
594                                            break;
595                                    default:
596                                            in_ascii = 1;
597                                    }
598                                    if (!in_ascii)
599                                    {
600                                            break;
601                                  }                                  }
602                                  break;                          }
603                            if (i == 4 && tmp[0] == 91 && tmp[1] == 50 && tmp[3] == 126) // Fterm
604                            {
605                                    in_ascii = 0;
606                                    switch (tmp[2])
607                                    {
608                                    case 48:
609                                            out = KEY_F9;
610                                            break;
611                                    case 49:
612                                            out = KEY_F10;
613                                            break;
614                                    case 50:
615                                            out = KEY_F11; // Fterm
616                                            break;
617                                    case 51:
618                                            out = KEY_F11; // Xterm
619                                            break;
620                                    case 52:
621                                            out = KEY_F12; // Xterm
622                                            break;
623                                    default:
624                                            in_ascii = 1;
625                                    }
626                                    if (!in_ascii)
627                                    {
628                                            break;
629                                    }
630                            }
631                            if (i == 5 && tmp[0] == 91 && tmp[1] == 49 && tmp[2] == 59 && tmp[3] == 53) // Xterm
632                            {
633                                    in_ascii = 0;
634                                    switch (tmp[4])
635                                    {
636                                    case 65:
637                                            out = KEY_CTRL_UP;
638                                            break;
639                                    case 66:
640                                            out = KEY_CTRL_DOWN;
641                                            break;
642                                    case 67:
643                                            out = KEY_CTRL_RIGHT;
644                                            break;
645                                    case 68:
646                                            out = KEY_CTRL_LEFT;
647                                            break;
648                                    case 70:
649                                            out = KEY_CTRL_END;
650                                            break;
651                                    case 72:
652                                            out = KEY_CTRL_HOME;
653                                            break;
654                                    case 80:
655                                            out = KEY_CTRL_F1;
656                                            break;
657                                    case 81:
658                                            out = KEY_CTRL_F2;
659                                            break;
660                                    case 82:
661                                            out = KEY_CTRL_F3;
662                                            break;
663                                    default:
664                                            in_ascii = 1;
665                                    }
666                                    if (!in_ascii)
667                                    {
668                                            break;
669                                    }
670                            }
671                            if (i == 6 && tmp[0] == 91 && tmp[1] == 49 && tmp[3] == 59 && tmp[4] == 53 && tmp[5] == 126) // Xterm
672                            {
673                                    in_ascii = 0;
674                                    switch (tmp[2])
675                                    {
676                                    case 53:
677                                            out = KEY_CTRL_F5;
678                                            break;
679                                    case 55:
680                                            out = KEY_CTRL_F6;
681                                            break;
682                                    case 56:
683                                            out = KEY_CTRL_F7;
684                                            break;
685                                    case 57:
686                                            out = KEY_CTRL_F8;
687                                            break;
688                                    default:
689                                            in_ascii = 1;
690                                    }
691                                    if (!in_ascii)
692                                    {
693                                            break;
694                                    }
695                            }
696                            if (i == 6 && tmp[0] == 91 && tmp[1] == 50 && tmp[3] == 59 && tmp[4] == 53 && tmp[5] == 126) // Xterm
697                            {
698                                    in_ascii = 0;
699                                    switch (tmp[2])
700                                    {
701                                    case 48:
702                                            out = KEY_CTRL_F9;
703                                            break;
704                                    case 49:
705                                            out = KEY_CTRL_F10;
706                                            break;
707                                    case 51:
708                                            out = KEY_CTRL_F11;
709                                            break;
710                                    case 52:
711                                            out = KEY_CTRL_F12;
712                                            break;
713                                    default:
714                                            in_ascii = 1;
715                                    }
716                                    if (!in_ascii)
717                                    {
718                                            break;
719                                    }
720                            }
721                            if (i == 5 && tmp[0] == 91 && tmp[1] == 49 && tmp[2] == 59 && tmp[3] == 50) // Xterm
722                            {
723                                    in_ascii = 0;
724                                    switch (tmp[4])
725                                    {
726                                    case 80:
727                                            out = KEY_SHIFT_F1;
728                                            break;
729                                    case 81:
730                                            out = KEY_SHIFT_F2;
731                                            break;
732                                    case 82:
733                                            out = KEY_SHIFT_F3;
734                                            break;
735                                    case 83:
736                                            out = KEY_SHIFT_F4;
737                                            break;
738                                    default:
739                                            in_ascii = 1;
740                                    }
741                                    if (!in_ascii)
742                                    {
743                                            break;
744                                    }
745                            }
746                            if (i == 6 && tmp[0] == 91 && tmp[1] == 49 && tmp[3] == 59 && tmp[4] == 50 && tmp[5] == 126) // Xterm
747                            {
748                                    in_ascii = 0;
749                                    switch (tmp[2])
750                                    {
751                                    case 53:
752                                            out = KEY_SHIFT_F5;
753                                            break;
754                                    case 55:
755                                            out = KEY_SHIFT_F6;
756                                            break;
757                                    case 56:
758                                            out = KEY_SHIFT_F7;
759                                            break;
760                                    case 57:
761                                            out = KEY_SHIFT_F8;
762                                            break;
763                                    default:
764                                            in_ascii = 1;
765                                    }
766                                    if (!in_ascii)
767                                    {
768                                            break;
769                                    }
770                            }
771                            if (i == 6 && tmp[0] == 91 && tmp[1] == 50 && tmp[3] == 59 && tmp[4] == 50 && tmp[5] == 126) // Xterm
772                            {
773                                    in_ascii = 0;
774                                    switch (tmp[2])
775                                    {
776                                    case 48:
777                                            out = KEY_SHIFT_F9;
778                                            break;
779                                    case 49:
780                                            out = KEY_SHIFT_F10;
781                                            break;
782                                    case 51:
783                                            out = KEY_SHIFT_F11;
784                                            break;
785                                    case 52:
786                                            out = KEY_SHIFT_F12;
787                                            break;
788                                    default:
789                                            in_ascii = 1;
790                                    }
791                                    if (!in_ascii)
792                                    {
793                                            break;
794                                    }
795                            }
796    
797                            if (c == 'm')
798                            {
799                                    in_ascii = 0;
800                          }                          }
801                          continue;                          continue;
802                  }                  }
# Line 414  int igetch(int timeout) Line 805  int igetch(int timeout)
805                  break;                  break;
806          }          }
807    
         // for debug  
         // log_std ("-->[%u]\n", out);  
   
808          if (close(epollfd) < 0)          if (close(epollfd) < 0)
809          {          {
810                  log_error("close(epoll) error (%d)\n");                  log_error("close(epoll) error (%d)\n");
811          }          }
812    
813            // For ESC key
814            if (out == 0 && in_esc)
815            {
816                    out = KEY_ESC;
817            }
818    
819            // for debug
820    #ifdef _DEBUG
821            if (out != KEY_TIMEOUT && out != KEY_NULL)
822            {
823                    log_common("Debug: -->[0x %x]\n", out);
824            }
825    #endif
826    
827          return out;          return out;
828  }  }
829    
830  int igetch_t(int sec)  int igetch_t(int sec)
831  {  {
832          int ch;          int ch;
833          time_t t_begin = time(0);          time_t t_begin = time(NULL);
834    
835          do          do
836          {          {
837                  ch = igetch(100);                  ch = igetch(100);
838          } while (!SYS_server_exit && ch == KEY_TIMEOUT && (time(0) - t_begin < sec));          } while (!SYS_server_exit && ch == KEY_TIMEOUT && (time(NULL) - t_begin < sec));
839    
840          return ch;          return ch;
841  }  }

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