/[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.32 by sysadm, Mon May 19 13:03:14 2025 UTC Revision 1.39 by sysadm, Thu Jun 5 05:24:56 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 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 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 248  int igetch(int timeout) Line 265  int igetch(int timeout)
265                  len = 0;                  len = 0;
266                  pos = 0;                  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);                  nfds = epoll_wait(epollfd, events, MAX_EVENTS, timeout);
276    
277                  if (nfds < 0)                  if (nfds < 0)
# Line 271  int igetch(int timeout) Line 295  int igetch(int timeout)
295                          {                          {
296                                  while (len < sizeof(buf) && !SYS_server_exit) // read until complete or error                                  while (len < sizeof(buf) && !SYS_server_exit) // read until complete or error
297                                  {                                  {
298                                          ret = (int)read(STDIN_FILENO, buf + len, sizeof(buf) - (size_t)len);                                          if (SSH_v2)
299                                            {
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                                                            break; // Check whether channel is still open
315                                                    }
316                                            }
317                                            else
318                                            {
319                                                    ret = (int)read(STDIN_FILENO, buf + len, sizeof(buf) - (size_t)len);
320                                            }
321                                          if (ret < 0)                                          if (ret < 0)
322                                          {                                          {
323                                                  if (errno == EAGAIN || errno == EWOULDBLOCK)                                                  if (errno == EAGAIN || errno == EWOULDBLOCK)
# Line 306  int igetch(int timeout) Line 352  int igetch(int timeout)
352                  }                  }
353    
354                  // For debug                  // For debug
355                  // for (j = 0; j < len; j++)                  // for (int j = pos; j < len; j++)
356                  //   log_std ("<--[%u]\n", (buf[j] + 256) % 256);                  // {
357                    //      log_common("Debug: <--[%u]\n", (buf[j] + 256) % 256);
358                    // }
359          }          }
360    
361          fcntl(STDIN_FILENO, F_SETFL, flags);          fcntl(STDIN_FILENO, F_SETFL, flags);
# Line 338  int igetch(int timeout) Line 386  int igetch(int timeout)
386                          continue;                          continue;
387                  }                  }
388    
389                  if (c == ESC_KEY)                  if (c == KEY_ESC)
390                  {                  {
391                          if (in_esc == 0)                          if (in_esc == 0)
392                          {                          {
# Line 349  int igetch(int timeout) Line 397  int igetch(int timeout)
397                          }                          }
398                          else                          else
399                          {                          {
400                                  out = ESC_KEY;                                  out = KEY_CSI;
401                                  in_esc = 0;                                  in_esc = 0;
402                                  break;                                  break;
403                          }                          }
# Line 360  int igetch(int timeout) Line 408  int igetch(int timeout)
408                  if (in_ascii)                  if (in_ascii)
409                  {                  {
410                          tmp[i++] = c;                          tmp[i++] = c;
411                          if (c == 'm')                          if (i == 2 && (tmp[0] == 79 || tmp[0] == 91))
412                          {                          {
413                                  in_ascii = 0;                                  in_ascii = 0;
414                                  continue;                                  switch (tmp[1])
                         }  
                         if (i == 2 && c >= 'A' && c <= 'D')  
                         {  
                                 in_ascii = 0;  
                                 switch (c)  
415                                  {                                  {
416                                  case 'A':                                  case 65:
417                                          out = KEY_UP;                                          out = KEY_UP;
418                                          break;                                          break;
419                                  case 'B':                                  case 66:
420                                          out = KEY_DOWN;                                          out = KEY_DOWN;
421                                          break;                                          break;
422                                  case 'C':                                  case 67:
423                                          out = KEY_RIGHT;                                          out = KEY_RIGHT;
424                                          break;                                          break;
425                                  case 'D':                                  case 68:
426                                          out = KEY_LEFT;                                          out = KEY_LEFT;
427                                          break;                                          break;
428                                    default:
429                                            in_ascii = 1;
430                                    }
431                                    if (!in_ascii)
432                                    {
433                                            break;
434                                    }
435                            }
436                            if (i == 2 && tmp[0] == 91) // Fterm
437                            {
438                                    in_ascii = 0;
439                                    switch (tmp[1])
440                                    {
441                                    case 86:
442                                            out = KEY_SHIFT_F1;
443                                            break;
444                                    case 90:
445                                            out = KEY_SHIFT_F2;
446                                            break;
447                                    case 97:
448                                            out = KEY_SHIFT_F3;
449                                            break;
450                                    case 98:
451                                            out = KEY_SHIFT_F4;
452                                            break;
453                                    case 99:
454                                            out = KEY_SHIFT_F5;
455                                            break;
456                                    case 100:
457                                            out = KEY_SHIFT_F6;
458                                            break;
459                                    case 101:
460                                            out = KEY_SHIFT_F7;
461                                            break;
462                                    case 102:
463                                            out = KEY_SHIFT_F8;
464                                            break;
465                                    case 103:
466                                            out = KEY_SHIFT_F9;
467                                            break;
468                                    case 104:
469                                            out = KEY_SHIFT_F10;
470                                            break;
471                                    case 107:
472                                            out = KEY_CTRL_F1;
473                                            break;
474                                    case 108:
475                                            out = KEY_CTRL_F2;
476                                            break;
477                                    case 109:
478                                            out = KEY_CTRL_F3;
479                                            break;
480                                    case 112:
481                                            out = KEY_CTRL_F6;
482                                            break;
483                                    case 113:
484                                            out = KEY_CTRL_F7;
485                                            break;
486                                    case 114:
487                                            out = KEY_CTRL_F8;
488                                            break;
489                                    case 115:
490                                            out = KEY_CTRL_F9;
491                                            break;
492                                    case 116:
493                                            out = KEY_CTRL_F10;
494                                            break;
495                                    default:
496                                            in_ascii = 1;
497                                    }
498                                    if (!in_ascii)
499                                    {
500                                            break;
501                                    }
502                            }
503                            if (i == 2 && tmp[0] == 79) // Xterm
504                            {
505                                    in_ascii = 0;
506                                    switch (tmp[1])
507                                    {
508                                    case 80:
509                                            out = KEY_F1;
510                                            break;
511                                    case 81:
512                                            out = KEY_F2;
513                                            break;
514                                    case 82:
515                                            out = KEY_F3;
516                                            break;
517                                    case 83:
518                                            out = KEY_F4;
519                                            break;
520                                    default:
521                                            in_ascii = 1;
522                                    }
523                                    if (!in_ascii)
524                                    {
525                                            break;
526                                  }                                  }
                                 break;  
527                          }                          }
528                          if (i == 3 && tmp[0] == 91 && tmp[2] == 126)                          if (i == 3 && tmp[0] == 91 && tmp[2] == 126)
529                          {                          {
# Line 405  int igetch(int timeout) Line 545  int igetch(int timeout)
545                                  case 54:                                  case 54:
546                                          out = KEY_PGDN;                                          out = KEY_PGDN;
547                                          break;                                          break;
548                                    default:
549                                            in_ascii = 1;
550                                    }
551                                    if (!in_ascii)
552                                    {
553                                            break;
554                                    }
555                            }
556                            if (i == 4 && tmp[0] == 91 && tmp[1] == 49 && tmp[3] == 126) // Fterm
557                            {
558                                    in_ascii = 0;
559                                    switch (tmp[2])
560                                    {
561                                    case 49:
562                                            out = KEY_F1;
563                                            break;
564                                    case 50:
565                                            out = KEY_F2;
566                                            break;
567                                    case 51:
568                                            out = KEY_F3;
569                                            break;
570                                    case 52:
571                                            out = KEY_F4;
572                                            break;
573                                    case 53:
574                                            out = KEY_F5;
575                                            break;
576                                    case 55:
577                                            out = KEY_F6;
578                                            break;
579                                    case 56:
580                                            out = KEY_F7;
581                                            break;
582                                    case 57:
583                                            out = KEY_F8;
584                                            break;
585                                    default:
586                                            in_ascii = 1;
587                                    }
588                                    if (!in_ascii)
589                                    {
590                                            break;
591                                  }                                  }
592                                  break;                          }
593                            if (i == 4 && tmp[0] == 91 && tmp[1] == 50 && tmp[3] == 126) // Fterm
594                            {
595                                    in_ascii = 0;
596                                    switch (tmp[2])
597                                    {
598                                    case 48:
599                                            out = KEY_F9;
600                                            break;
601                                    case 49:
602                                            out = KEY_F10;
603                                            break;
604                                    case 50:
605                                            out = KEY_F11; // Fterm
606                                            break;
607                                    case 51:
608                                            out = KEY_F11; // Xterm
609                                            break;
610                                    case 52:
611                                            out = KEY_F12; // Xterm
612                                            break;
613                                    default:
614                                            in_ascii = 1;
615                                    }
616                                    if (!in_ascii)
617                                    {
618                                            break;
619                                    }
620                            }
621                            if (i == 5 && tmp[0] == 91 && tmp[1] == 49 && tmp[2] == 59 && tmp[3] == 53) // Xterm
622                            {
623                                    in_ascii = 0;
624                                    switch (tmp[4])
625                                    {
626                                    case 80:
627                                            out = KEY_CTRL_F1;
628                                            break;
629                                    case 81:
630                                            out = KEY_CTRL_F2;
631                                            break;
632                                    case 82:
633                                            out = KEY_CTRL_F3;
634                                            break;
635                                    default:
636                                            in_ascii = 1;
637                                    }
638                                    if (!in_ascii)
639                                    {
640                                            break;
641                                    }
642                            }
643                            if (i == 6 && tmp[0] == 91 && tmp[1] == 49 && tmp[3] == 59 && tmp[4] == 53 && tmp[5] == 126) // Xterm
644                            {
645                                    in_ascii = 0;
646                                    switch (tmp[2])
647                                    {
648                                    case 53:
649                                            out = KEY_CTRL_F5;
650                                            break;
651                                    case 55:
652                                            out = KEY_CTRL_F6;
653                                            break;
654                                    case 56:
655                                            out = KEY_CTRL_F7;
656                                            break;
657                                    case 57:
658                                            out = KEY_CTRL_F8;
659                                            break;
660                                    default:
661                                            in_ascii = 1;
662                                    }
663                                    if (!in_ascii)
664                                    {
665                                            break;
666                                    }
667                            }
668                            if (i == 6 && tmp[0] == 91 && tmp[1] == 50 && tmp[3] == 59 && tmp[4] == 53 && tmp[5] == 126) // Xterm
669                            {
670                                    in_ascii = 0;
671                                    switch (tmp[2])
672                                    {
673                                    case 48:
674                                            out = KEY_CTRL_F9;
675                                            break;
676                                    case 49:
677                                            out = KEY_CTRL_F10;
678                                            break;
679                                    case 51:
680                                            out = KEY_CTRL_F11;
681                                            break;
682                                    case 52:
683                                            out = KEY_CTRL_F12;
684                                            break;
685                                    default:
686                                            in_ascii = 1;
687                                    }
688                                    if (!in_ascii)
689                                    {
690                                            break;
691                                    }
692                            }
693                            if (i == 5 && tmp[0] == 91 && tmp[1] == 49 && tmp[2] == 59 && tmp[3] == 50) // Xterm
694                            {
695                                    in_ascii = 0;
696                                    switch (tmp[4])
697                                    {
698                                    case 80:
699                                            out = KEY_SHIFT_F1;
700                                            break;
701                                    case 81:
702                                            out = KEY_SHIFT_F2;
703                                            break;
704                                    case 82:
705                                            out = KEY_SHIFT_F3;
706                                            break;
707                                    case 83:
708                                            out = KEY_SHIFT_F4;
709                                            break;
710                                    default:
711                                            in_ascii = 1;
712                                    }
713                                    if (!in_ascii)
714                                    {
715                                            break;
716                                    }
717                            }
718                            if (i == 6 && tmp[0] == 91 && tmp[1] == 49 && tmp[3] == 59 && tmp[4] == 50 && tmp[5] == 126) // Xterm
719                            {
720                                    in_ascii = 0;
721                                    switch (tmp[2])
722                                    {
723                                    case 53:
724                                            out = KEY_SHIFT_F5;
725                                            break;
726                                    case 55:
727                                            out = KEY_SHIFT_F6;
728                                            break;
729                                    case 56:
730                                            out = KEY_SHIFT_F7;
731                                            break;
732                                    case 57:
733                                            out = KEY_SHIFT_F8;
734                                            break;
735                                    default:
736                                            in_ascii = 1;
737                                    }
738                                    if (!in_ascii)
739                                    {
740                                            break;
741                                    }
742                            }
743                            if (i == 6 && tmp[0] == 91 && tmp[1] == 50 && tmp[3] == 59 && tmp[4] == 50 && tmp[5] == 126) // Xterm
744                            {
745                                    in_ascii = 0;
746                                    switch (tmp[2])
747                                    {
748                                    case 48:
749                                            out = KEY_SHIFT_F9;
750                                            break;
751                                    case 49:
752                                            out = KEY_SHIFT_F10;
753                                            break;
754                                    case 51:
755                                            out = KEY_SHIFT_F11;
756                                            break;
757                                    case 52:
758                                            out = KEY_SHIFT_F12;
759                                            break;
760                                    default:
761                                            in_ascii = 1;
762                                    }
763                                    if (!in_ascii)
764                                    {
765                                            break;
766                                    }
767                            }
768    
769                            if (c == 'm')
770                            {
771                                    in_ascii = 0;
772                          }                          }
773                          continue;                          continue;
774                  }                  }
# Line 415  int igetch(int timeout) Line 777  int igetch(int timeout)
777                  break;                  break;
778          }          }
779    
         // for debug  
         // log_std ("-->[%u]\n", out);  
   
780          if (close(epollfd) < 0)          if (close(epollfd) < 0)
781          {          {
782                  log_error("close(epoll) error (%d)\n");                  log_error("close(epoll) error (%d)\n");
783          }          }
784    
785            // For ESC key
786            if (out == 0 && in_esc)
787            {
788                    out = KEY_ESC;
789            }
790    
791            // for debug
792            // if (out != KEY_TIMEOUT && out != KEY_NULL)
793            // {
794            //      log_common ("Debug: -->[0x %x]\n", out);
795            // }
796    
797          return out;          return out;
798  }  }
799    

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