home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 239.lha / amiga / src / client / cliterm.c next >
C/C++ Source or Header  |  1989-05-02  |  7KB  |  386 lines
  1.  
  2. /*
  3.  *  CLITERM.C
  4.  *
  5.  *  DNET (c)Copyright 1988-1989, Matthew Dillon, All Rights Reserved.
  6.  *
  7.  *  FTERM [-Nnet] [port]
  8.  */
  9.  
  10. #include <stdio.h>
  11. #include <local/typedefs.h>
  12. #include "/dnet/channel.h"
  13.  
  14. #include "/server/servers.h"
  15.  
  16. #ifndef DEVICES_CONUNIT_H
  17. typedef struct ConUnit        CONUNIT;
  18. typedef struct IOStdReq     IOCON;
  19. #endif
  20.  
  21. short IgnoreNS = 0;
  22.  
  23. TA Ta = { (ubyte *)"topaz", 8 };
  24.  
  25. ITEXT IText[] = {
  26.     { 0, 1, JAM2, 0, 0, &Ta, (ubyte *)"Flush"          }
  27. };
  28.  
  29. ITEM Item[] = {
  30.     { NULL    , 0, 0, 100, 10, ITEMTEXT|COMMSEQ|ITEMENABLED|HIGHCOMP, 0, (APTR)&IText[0], NULL, 'o' }
  31. };
  32.  
  33. MENU Menu[] = {
  34.     { NULL    , 0, 0, 100, 20, MENUENABLED, "Control", &Item[0] }
  35. };
  36.  
  37. char Title[80];
  38.  
  39. NW Nw = {
  40.     0, 12, 640, 60, -1, -1,
  41.     NEWSIZE|CLOSEWINDOW|MENUPICK,
  42.     WINDOWSIZING|WINDOWDRAG|WINDOWDEPTH|WINDOWCLOSE|NOCAREREFRESH|ACTIVATE,
  43.     NULL, NULL, Title, NULL, NULL,
  44.     32, 32, -1, -1, WBENCHSCREEN
  45. };
  46.  
  47. WIN *Win;
  48.  
  49. int Enable_Abort;
  50. char Buf[512];
  51. char Term[64] = { "FTERM (UNNAMED SHELL)" };
  52. char Cc;
  53.  
  54. /*
  55. extern void *OpenWindow();
  56. */
  57. extern void *GetMsg();
  58. /*
  59. extern void *CreatePort();
  60. */
  61.  
  62. long IntuitionBase;
  63. long GfxBase;
  64. IOCON *iocr, *iocw;
  65.  
  66. main(ac,av)
  67. char *av[];
  68. {
  69.     long chan;
  70.     long n;
  71.     long imask, conmask, dmask, cmdmask, mask;
  72.     char notdone = 1;
  73.     char portspec = 0;
  74.     char *host = NULL;
  75.     uword port = PORT_AMIGASHELL;
  76.     int i;
  77.     int bp = 0;
  78.     char inputbuf[256];
  79.  
  80.     sprintf(Title, "CLITerm V%s%s opening, wait..", VERSION, CLITERM_VERSION);
  81.     {
  82.     register short i;
  83.     for (i = 1; i < ac; ++i) {
  84.         if (strncmp(av[i], "-N", 2) == 0) {
  85.         host = av[i] + 2;
  86.         continue;
  87.         }
  88.         portspec = 1;
  89.         port = atoi(av[i]);
  90.     }
  91.     }
  92.     if (portspec)
  93.     printf("Using port %ld\n", port);
  94.     Enable_Abort = 0;
  95.     IntuitionBase = (long)OpenLibrary("intuition.library", 0);
  96.     GfxBase = (long)OpenLibrary("graphics.library", 0);
  97.     Win = OpenWindow(&Nw);
  98.     if (Win == NULL)
  99.     goto e1;
  100.     OpenConsole(Win, &iocr, &iocw);
  101.     if (iocr == NULL || iocw == NULL)
  102.     goto e3;
  103.  
  104.     /*
  105.      *    We delay here to allow DNET to go through its RESTART sequence
  106.      *    (when DNET automatically runs FTERM, it does so to quickly).
  107.      *    Such a hack!
  108.      */
  109.  
  110.     Delay(50 * 4);
  111.     chan = DOpen(host, port, 20, 15);
  112.  
  113.     if (!chan) {
  114.     puts("Unable to connect");
  115.     goto e3;
  116.     }
  117.     DQueue(chan, 32);
  118.     SetMenuStrip(Win, Menu);
  119.     SetWindowTitles(Win, Term, -1);
  120.     imask   = 1 << Win->UserPort->mp_SigBit;
  121.     dmask   = 1 << ((PORT *)chan)->mp_SigBit;
  122.     conmask = 1 << iocr->io_Message.mn_ReplyPort->mp_SigBit;
  123.  
  124.     /*
  125.     CreatePort(
  126.     */
  127.     iocr->io_Data = (APTR)&Cc;
  128.     iocr->io_Length = 1;
  129.     SendIO(iocr);
  130.  
  131.     setsize(iocw, chan, Win);
  132.     while (notdone) {
  133.     mask = Wait(imask|dmask|conmask);
  134.     if (mask & imask) {
  135.         IMESS *im;
  136.         while (im = GetMsg(Win->UserPort)) {
  137.         switch(im->Class) {
  138.         case NEWSIZE:
  139.             if (IgnoreNS) {
  140.             --IgnoreNS;
  141.             setsize(iocw, NULL, Win);
  142.             } else {
  143.             setsize(iocw, chan, Win);
  144.             }
  145.             break;
  146.         case CLOSEWINDOW:
  147.             notdone = 0;
  148.             break;
  149.         case MENUPICK:
  150.             switch((uword)((MENUNUM(im->Code)<<8)|ITEMNUM(im->Code))) {
  151.             case 0x0000:    /*    menu 0 item 0    */
  152.             DIoctl(chan, CIO_FLUSH, 0, 0);
  153.             break;
  154.             case 0x0001:    /*    menu 0 item 1    */
  155.             case 0x0002:    /*    menu 0 item 2    */
  156.             case 0x0100:    /*    menu 1 item 0    */
  157.             break;
  158.             }
  159.         }
  160.         ReplyMsg(im);
  161.         }
  162.     }
  163.     if (mask & dmask) {
  164.         char buf[256];
  165.         int n;
  166.         if ((n = DNRead(chan, buf, 256)) > 0) {
  167.         for (i = 0; i < n; i++)
  168.         {
  169.             if (buf[i] == '\n')
  170.             {
  171.                 movmem(&buf[i], &buf[i + 1], n - i);
  172.                 buf[i] = '\r';
  173.                 i++;
  174.                 n++;
  175.             }
  176.         }
  177.         iocw->io_Data = (APTR)buf;
  178.         iocw->io_Length = n;
  179.         DoIO(iocw);
  180.         }
  181.         if (n == -2) {
  182.         short val;
  183.         short cmd;
  184.         char aux;
  185.         cmd = DGetIoctl(chan, &val, &aux);
  186.         HandleIoctl(cmd, val, aux, Win, iocw);
  187.         /*
  188.         if (cmd == CIO_MODE) {
  189.             if (val)
  190.             SetWindowTitles(Win, "(Cooked)", -1);
  191.             else
  192.             SetWindowTitles(Win, "(Raw)", -1);
  193.         }
  194.         */
  195.         } else if (n < 0)
  196.         notdone = 0;
  197.     }
  198.     if (mask & conmask) {
  199.         if (CheckIO(iocr)) {
  200.         WaitIO(iocr);
  201.  
  202.         if (Cc == '\r')
  203.             Cc = '\n';
  204.         inputbuf[bp++] = Cc;
  205.  
  206.         if (Cc == 0x08)
  207.         {
  208.             if (bp <= 1)
  209.             {
  210.                 bp = 0;
  211.             }
  212.             else
  213.             {
  214.                 localecho(0x08);
  215.                 localecho(0x20);
  216.                 localecho(0x08);
  217.                 bp -= 2;
  218.             }
  219.         }
  220.         else if (Cc == 0x18)
  221.         {
  222.             while (--bp > 0)
  223.             {
  224.                 localecho(0x08);
  225.                 localecho(0x20);
  226.                 localecho(0x08);
  227.             }
  228.         }
  229.         else if (Cc == '\n')
  230.         {
  231.             localecho('\n');
  232.             localecho('\r');
  233.             DWrite(chan, inputbuf, bp);
  234.             bp = 0;
  235.         }
  236.         else
  237.             localecho(Cc);
  238.  
  239.         iocr->io_Data = (APTR)&Cc;
  240.         iocr->io_Length = 1;
  241.         SendIO(iocr);
  242. /*
  243.         if (Cc == '\r')
  244.         {
  245.             Cc = '\n';
  246.             DWrite(chan, &Cc, 1);
  247.             iocr->io_Data = (APTR)&Cc;
  248.             iocr->io_Length = 1;
  249.             SendIO(iocr);
  250.         }
  251. */
  252.         }
  253.     }
  254.     }
  255.     AbortIO(iocr);
  256.     WaitIO(iocr);
  257.     SetWindowTitles(Win, "Closing...", -1);
  258.     DClose(chan);
  259. e3: CloseConsole(iocr,iocw);
  260.     CloseWindow(Win);
  261. e1: CloseLibrary(IntuitionBase);
  262.     CloseLibrary(GfxBase);
  263. }
  264.  
  265. localecho (c)
  266. int c;
  267. {
  268. char cc;
  269.  
  270.     cc = c;
  271.     iocw->io_Data = (APTR)&cc;
  272.     iocw->io_Length = 1;
  273.     DoIO(iocw);
  274. }
  275.  
  276. OpenConsole(win, piocr, piocw)
  277. IOCON **piocr, **piocw;
  278. WIN *win;
  279. {
  280.     PORT *port;
  281.     static IOCON iocr, iocw;
  282.     int error;
  283.  
  284.     port = CreatePort(NULL, 0);
  285.     iocr.io_Command = CMD_READ;
  286.     iocr.io_Data = (APTR)win;
  287.     iocr.io_Message.mn_Node.ln_Type = NT_MESSAGE;
  288.     iocr.io_Message.mn_ReplyPort = port;
  289.     error = OpenDevice("console.device", 0, &iocr, 0);
  290.     if (!error) {
  291.     iocw = iocr;
  292.     iocw.io_Command = CMD_WRITE;
  293.     *piocr = &iocr;
  294.     *piocw = &iocw;
  295.     } else {
  296.     *piocr = *piocw = NULL;
  297.     }
  298. }
  299.  
  300. CloseConsole(iocr, iocw)
  301. IOCON *iocr;
  302. IOCON *iocw;
  303. {
  304.     IOCON *tmp = (iocr) ? iocr : iocw;
  305.     if (tmp) {
  306.     CloseDevice(tmp);
  307.     DeletePort(tmp->io_Message.mn_ReplyPort);
  308.     }
  309. }
  310.  
  311. setsize(iocw, chan, win)
  312. IOCON *iocw;
  313. WIN *win;
  314. {
  315.     struct ConUnit *cu = (struct ConUnit *)iocw->io_Unit;
  316.     static char IStr[] = { "\033c\23320l\233t\233u" };
  317.  
  318.     /*
  319.     if (Cooked & 4)
  320.     IStr[5] = 'h';
  321.     else
  322.     IStr[5] = 'l';
  323.     */
  324.     iocw->io_Data = (APTR)IStr;
  325.     iocw->io_Length = sizeof(IStr) - 1;
  326.     DoIO(iocw);
  327.     if (chan) {
  328.     DIoctl(chan, CIO_SETROWS, cu->cu_YMax+1, 0);
  329.     DIoctl(chan, CIO_SETCOLS, cu->cu_XMax+1, 0);
  330.     }
  331.     sprintf(Term, "FTERM   %ld x %ld", cu->cu_YMax+1, cu->cu_XMax+1);
  332.     SetWindowTitles(win, Term, -1);
  333. }
  334.  
  335. HandleIoctl(cmd, val, aux, win, iocw)
  336. short cmd, val;
  337. char aux;
  338. WIN *win;
  339. IOCON *iocw;
  340. {
  341.     static short saverows;
  342.     short height, width;
  343.     short dx, dy;
  344.  
  345.     switch(cmd) {
  346.     case CIO_MODE:
  347.     /*
  348.     Cooked = val;
  349.     */
  350.     break;
  351.     case CIO_SETROWS:
  352.     saverows = val;
  353.     break;
  354.     case CIO_SETCOLS:
  355.     width = val * win->RPort->TxWidth + win->BorderLeft + win->BorderRight;
  356.     height= saverows * win->RPort->TxHeight + win->BorderTop + win->BorderBottom;
  357.  
  358.     dx = win->WScreen->Width - (win->LeftEdge + width);
  359.     if (dx > 0)
  360.         dx = 0;
  361.     if (-dx > win->LeftEdge) {
  362.         dx = -win->LeftEdge;
  363.         width = win->WScreen->Width;
  364.     }
  365.  
  366.     dy = win->WScreen->Height - (win->TopEdge + height);
  367.     if (dy > 0)
  368.         dy = 0;
  369.     if (-dy > win->TopEdge) {
  370.         dy = -win->TopEdge;
  371.         height = win->WScreen->Height;
  372.     }
  373.  
  374.     if (dx || dy) {
  375.         MoveWindow(win, dx, dy);
  376.     }
  377.     if (win->Width != width || win->Height != height) {
  378.         SizeWindow(win, width - win->Width, height - win->Height);
  379.         ++IgnoreNS;
  380.     }
  381.     break;
  382.     }
  383. }
  384.  
  385.  
  386.