home *** CD-ROM | disk | FTP | other *** search
/ Network Supervisor's Toolkit / Network Supervisor's Toolkit.iso / tools / lu62 / debug / dummy.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-10  |  16.8 KB  |  638 lines
  1. /*
  2.  *  CopyRight 1995. Nicholas Poljakov all rights reserved.
  3.  */
  4. #include <bios.h>
  5. #include <dos.h>
  6. #include <memory.h>
  7. #include <direct.h>
  8. #include <string.h>
  9. #include <stdio.h>
  10. #include <conio.h>
  11. #include <stdlib.h>
  12. #include <io.h>
  13. #include <fcntl.h>
  14. #include <stdlib.h>
  15. #include <crtp.h>
  16. #include <state1.h>
  17.  
  18. #define BORDER 1
  19. #define REV_VID 0x70
  20. #define NORM_VID 0x1E
  21. #define MAX_FRAME 31
  22. #define BKSP 8
  23. #define F1 59
  24. #define F2 60
  25. #define F3 61
  26. #define F4 62
  27. #define F5 63
  28. #define F6 64
  29. #define F7 65
  30. #define F8 66
  31. #define F9 67
  32. #define F10 68
  33. #define HM  71   /* Home key     */
  34. #define UP  72   /* Up Arrow     */
  35. #define PU  73   /* Page Up      */
  36. #define LT  75   /* Left Arrow   */
  37. #define RT  77   /* Right Arrow  */
  38. #define END 79   /* End key      */
  39. #define DN  80   /* Down Arrow   */
  40. #define PD  81   /* Page Down    */
  41. #define ESC '\033'
  42.  
  43. #define lsl     1
  44. #define max_tps  1
  45. #define partsl   1
  46. #define maxru    2017
  47. #define pac      1
  48. #define MAX_FRAME 31
  49. #define L_PSTR    sizeof(struct part) * 4
  50. extern short cur_ln;
  51. extern struct menu_frame {
  52.     int startx, endx, starty, endy;
  53.     unsigned char *p;
  54.     char **menu;
  55.     char *keys;
  56.     int border;
  57.     int count;
  58.     unsigned char attrib;
  59.     int active;
  60.     int curx, cury;
  61.     char *header;
  62.     unsigned char shd;
  63.     } frame[MAX_FRAME];
  64.  
  65. extern struct LU_PARM{
  66.        unsigned long conv_id;
  67.        unsigned char lu_id[8];
  68.        unsigned char tp_id[8];
  69.        char tp_name[64];
  70. }*p_lparm;
  71. extern struct APL_PARM{
  72.        int status;  /* 0-start aplmain,1-start transaction,2-dos shell */
  73.        char p[80];  /* string for system(p) */
  74.        char args[64];/* string of arguments */
  75.        int rc;      /* aplmain return code */
  76.        char dir[60];/* directory name for aplmain */
  77.        int drlen;   /* directory name length */
  78.        void *tpe;   /* entry of exit program */
  79.        char pgm_state;
  80. }*p_aparm;
  81. extern char *sv;
  82. extern char *vid_mem;
  83. extern char tp_exist; /* Tp_exist eq. 0 if TP not active, and 1 vice versus.*/
  84. extern char lu_name[9];
  85. extern char lu_id[8];
  86. extern unsigned  long conv_id;
  87. extern char mode_name[9];
  88. extern char tp_id[8];
  89. extern unsigned char pgm_state;
  90. extern char InTp[40]; /* received TP name */
  91. extern struct crtp *p_crtp;
  92. extern unsigned char **tlx;
  93. extern void SendFil(char *, int);
  94.  
  95. extern char ps[4][14];
  96. int Fmh5Handler();
  97. void rem_exe(char *);
  98. void rem_com(char *);
  99. extern int p_lu_num;   /* number of LU - partners */
  100. extern struct    part    {         /* partner structure */
  101.                   char   plu[8] ;             /* str plu_name        */
  102.                   int psl;                    /* str plu_s_limit     */
  103.                   char   mode_name[8] ;       /* str mode_name       */
  104.                   int max_ru_size;            /* str ru_h_size       */
  105.                   int pacing;                 /* str =               */
  106.                   unsigned char lu_type;
  107.                }  pstr[4];
  108. void _interrupt _far tpe( unsigned _es, unsigned _ds, unsigned _di,
  109.                    unsigned _si, unsigned _bp, unsigned _sp,
  110.                    unsigned _bx, unsigned _dx, unsigned _cx,
  111.                    unsigned _ax, unsigned _ip, unsigned _cs,
  112.                 unsigned _flags );
  113.  
  114. SetLu()
  115. {
  116.     unsigned int ch;
  117.     union inkey {
  118.                    char ch[2];
  119.                    unsigned int i;
  120.                 } *c;
  121.     char buff[9];
  122.     int i;
  123.     int j;
  124.     int n;
  125.     unsigned long rc;
  126.     char retstr[6];
  127.     void *tp_exit;
  128.     unsigned char rtr;   /* retry switch for local menu operations */
  129.     unsigned char key;
  130.  
  131.     if (lu_id[0] != 0) {
  132.         window(14);
  133.     window_xy(14, 2, 1);
  134.         window_puts(14, "One LU can be attached only!");
  135.         window_xy(14, 3, 4);
  136.         window_puts(14, "Press ESC to continue");
  137.         while ((ch = getch()) != ESC) ;
  138.         deactivate( 14 );
  139.         return 0;
  140.     }
  141.     if (p_lu_num != 0) {
  142.         window(5);
  143.         window_xy(5, 1, 6);
  144.         window_puts(5, "Reset configuration ?");
  145.         window_xy(5, 2, 12);
  146.         window_puts(5, "[Y]");
  147.         window_xy(5, 2, 13);
  148.      ReIn:
  149.     ch = getch();
  150.         ch &= 0x00ff;
  151.         if ((ch == 'y')||(ch == 'Y')) {
  152.              p_lu_num = 0;
  153.              lu_name[0] = 0x00;
  154.              mode_name[0] = 0x00;
  155.              set0(&pstr, L_PSTR);
  156.              p_lu_num = 0;
  157.              deactivate( 5 );
  158.         }
  159.         else
  160.              if ((ch == 'n')||(ch == 'N')) {
  161.                 deactivate( 5 );
  162.                 n = p_lu_num;
  163.                 goto Att_lu;
  164.              }
  165.              else
  166.                 goto ReIn;
  167.     }
  168.  
  169.     rtr = 0;
  170.     c = &ch;
  171.     window(5);
  172.     window_xy(5, 1, 1);
  173.     window_puts(5, "LU name............");
  174.     window_xy(5, 2, 1);
  175.     window_puts(5, "Mode name..........");
  176.    SetLLu:
  177.     window_xy(5, 1, 20);
  178.     window_puts(5, "        ");
  179.     window_xy(5, 1, 20);
  180.     if (window_gets(5, buff) == 1) { /* read local LU name */
  181.         goto SetExit;
  182.     }
  183.     strcpy(lu_name, buff);
  184.     window_xy(5, 2, 20);
  185.     if (window_gets(5, buff) == 1) { /* read local mode name */
  186.         goto SetLLu;
  187.     }
  188.     if (buff[0] == 0x00) {
  189.       strcpy(buff, "MODE6");
  190.       window_puts(5, "MODE6");
  191.     }
  192.     strcpy(mode_name, buff);
  193.     /* Read LU partners names and others */
  194.     for (i = 0; i < 4; i++) {
  195.         window(16 + i);
  196.         window_xy(16 + i, 1, 1);
  197.         window_puts(16 + i, "LU name............");
  198.         window_xy(16 + i, 2, 1);
  199.         window_puts(16 + i, "Mode name..........");
  200.         window_xy(16 + i, 3, 1);
  201.         window_puts(16 + i, "LU type............");
  202.     SetPLu:
  203.         window_xy(16 + i, 1, 20);
  204.         window_puts(16 + i, "        ");
  205.         window_xy(16 + i, 1, 20);
  206.         if (window_gets(16 + i, buff) == 1) { /* read partner LU name */
  207.              rtr = 1;
  208.              goto ClsWin;
  209.         }
  210.         strcpy(pstr[i].plu, buff);
  211.      SetMode:
  212.         window_xy(16 + i, 2, 20);
  213.         window_puts(16 + i, "        ");
  214.         window_xy(16 + i, 2, 20);
  215.         if (window_gets(16 + i, buff) == 1) { /* read partner mode name */
  216.              rtr = 1;
  217.              goto SetPLu;
  218.         }
  219.         if (buff[0] == 0x00) {
  220.           strcpy(buff, "MODE6");
  221.           window_puts(16 + i, "MODE6");
  222.         }
  223.         strcpy(pstr[i].mode_name, buff);
  224.      SetType:
  225.         window_xy(16 + i, 3, 20);
  226.         ch = window_getche(16 + i);
  227.         if (ch == ESC) {
  228.             goto SetMode;
  229.         }
  230.         key = c -> ch[0] & 0x0f;
  231.         if ((key != 6)&&(key != 0)) {
  232.            window(14);
  233.            window_xy(14, 2, 5);
  234.            window_puts(14, "Type must be 6 or 0");
  235.            window_xy(14, 3, 4);
  236.            window_puts(14, "Press ESC to continue");
  237.            while ((ch = getch()) != ESC) ;
  238.            deactivate(14);
  239.            window_xy(16 + i, 3, 20);
  240.            window_puts(16 + i, "        ");
  241.            window_xy(16 + i, 3, 20);
  242.            goto SetType;
  243.         }
  244.         pstr[i].lu_type = key;
  245.         pstr[i].psl=partsl;
  246.         pstr[i].max_ru_size=maxru;
  247.         pstr[i].pacing=pac;
  248.         if ((ch = getch()) == ESC) {
  249.             goto ClsWin;
  250.         }
  251.     }
  252.     i = 3;
  253. ClsWin:
  254.     n = i + 1;
  255.     p_lu_num = n;
  256.     for (j = i; j >= 0; j--) {
  257.         deactivate(16 + j);
  258.     }
  259.     if (rtr) {
  260.         rtr = 0;
  261.         window_xy(5, 2, 20);
  262.         window_puts(5, "        ");
  263.         window_xy(5, 2, 20);
  264.         goto SetLLu;
  265.     }
  266. Att_lu:
  267.     tp_exit = p_aparm -> tpe;
  268.     attachlu   (
  269.              lu_name,
  270.              lsl,
  271.              max_tps,
  272.              tp_exit,
  273.              n,
  274.              &pstr,
  275.              &rc,
  276.              lu_id);
  277.     if (rc != 0) {
  278.         window(14);
  279.         window_xy(14, 1, 1);
  280.         window_puts(14, "Return code from ATTACH_LU");
  281.         sprintf(retstr,"%lx",rc);
  282.         i = (30 - strlen(retstr))/2;
  283.         window_xy(14, 2, i);
  284.         window_puts(14, retstr);
  285.         while ((ch = getch()) != ESC) ;
  286.         deactivate(14);
  287.     }
  288.     else
  289.             {
  290.                window(15);
  291.                window_xy(15, 2, 8);
  292.                window_puts(15, "LU is active!");
  293.                while ((ch = getch()) != ESC) ;
  294.            deactivate(15);
  295.            cur_ln = 0; /* initial value */
  296.         }
  297.  /*
  298.     if (!tp_exist) {
  299.         tp_started
  300.                  (lu_id,
  301.                   tp_id,
  302.                   &rc);
  303.         if (rc != 0) {
  304.             window_xy(20, 6, 1);
  305.             window_puts(20, "TP_started failure. Press ESC to exit.");
  306.         goto SetExit;
  307.     }
  308.     tp_exist = 1;
  309.     }
  310.  */
  311.  
  312. SetExit:
  313.     deactivate(5);
  314. };
  315. SelPtLu()
  316. {
  317.        register int i;
  318.        char *p_nm[4];
  319.        char p[8];
  320.  
  321.        for (i = 0; i < p_lu_num; i++) {
  322.        ps[i][0] = (i + 1) | 0x30;
  323.        ps[i][1] = 0x00;
  324.        strcat(ps[i], ". ");
  325.        strcat(ps[i], pstr[i].plu);
  326.        p_nm[i] = ps[i];
  327.        }
  328.        make_menu(24, p_nm, "1234", p_lu_num, 3, 12, BORDER, 0x72, 1);
  329.        sfs(sv, vid_mem);
  330.        cur_ln = pulldown(24);
  331.        restore_video( 24 );
  332. };
  333. SelectFile()
  334. {
  335. };
  336. Fmh5Handler()
  337. {
  338.         unsigned key;
  339.  
  340.      WaitFMH:
  341.         p_aparm -> pgm_state = 0;
  342.         window(21);
  343.         window_xy(21, 3, 2);
  344.     window_puts(21, "Waiting for request from remote LU");
  345.     window_xy(21, 5, 10);
  346.     window_puts(21, "Press ESC for EXIT...");
  347.         while (!(p_aparm -> pgm_state)) {
  348.              _asm
  349.                   {
  350.                      mov   ax, 0b00h
  351.                      int   21h
  352.                      and   ax, 00ffh
  353.                      mov   word ptr key[0], ax
  354.                   }
  355.              if (key != 0) {
  356.                     if ((key = getch()) == ESC) {
  357.                         goto HdExit;
  358.                     }
  359.              }
  360.     /*
  361.              if (_bios_keybrd( _KEYBRD_READY ) != 0) {
  362.                  key = _bios_keybrd( _KEYBRD_READ );
  363.                  key &= 0x00ff;
  364.                  if (key == 27) {
  365.                      goto HdExit;
  366.                  }
  367.          }
  368.      */
  369.     }
  370.     memcpy(tp_id, p_lparm->tp_id, 8);
  371.     memcpy(lu_id, p_lparm->lu_id, 8);
  372.     memcpy(InTp, p_lparm->tp_name, 40);
  373.     conv_id = p_lparm -> conv_id;
  374.  
  375.     if (memcmp(InTp, "TTY", 3) == 0) {
  376.          em_tty();
  377.          goto WaitFMH;
  378.         }
  379.         else
  380.               if (memcmp(InTp, "SEND", 4) == 0) {
  381.                   rcv(InTp);
  382.                   goto WaitFMH;
  383.               }
  384.               else
  385.                     if (memcmp(InTp, "DIR", 3) == 0) {
  386.                         dir(InTp);
  387.                         goto WaitFMH;
  388.                     }
  389.                     else
  390.                            if (memcmp(InTp, "RCV", 3) == 0) {
  391.                                 snd(InTp);
  392.                                 goto WaitFMH;
  393.                            }
  394.                            else
  395.                                 if (memcmp(InTp,"COPY",4) == 0){
  396.                                     rem_cp(InTp);
  397.                                     goto WaitFMH;
  398.                                 }
  399.                                 else
  400.                                      if (memcmp(InTp,"EXE",3) == 0){
  401.                                          rem_exe(InTp);
  402.                                      }
  403.                                      else
  404.                                          if (memcmp(InTp,"COM",3) == 0){
  405.                                                  rem_com(InTp);
  406.                                          }
  407.                      else
  408.                                              goto WaitFMH;
  409.    HdExit:
  410.         deactivate(21);
  411.         p_aparm -> pgm_state = 0;  /* Off state flag */
  412.         return 0;
  413. }
  414. void rem_exe(char *p){
  415.  
  416.  unsigned char rts;
  417.  unsigned char wr;
  418.  unsigned int max_length ;
  419.  char gds[8];
  420.  char *p_arg;
  421.  char l_arg;
  422.  int length;
  423.  struct rc {
  424.          unsigned int prim;
  425.          unsigned long sec;
  426.  } v_rc;
  427.  unsigned long rc;
  428.  
  429.     max_length = 2017;
  430.     recwait (tp_id,
  431.           conv_id,
  432.           ll,
  433.           &v_rc,
  434.           &length,
  435.           max_length,
  436.           &rts,
  437.           &gds,
  438.           &wr);
  439.     deallocate (tp_id,
  440.                 conv_id,
  441.                 Flush,
  442.                 &v_rc);
  443.     tp_ended (tp_id, &rc);
  444.     p_aparm -> status = 1;
  445.     p_aparm -> rc = 1;
  446.     strcpy( p_aparm -> p,&p[4]);
  447.     p_arg = strchr(p_aparm -> p,' ');
  448.     strcpy( p_aparm -> args, p_arg);
  449.     *p_arg = 0x00;
  450.     p_arg++;
  451.     l_arg = (char)strlen(p_arg);
  452.     l_arg++;
  453.     p_aparm -> args[0] = l_arg;
  454.     p_aparm -> args[l_arg] = 0x0d;
  455.     p_aparm -> args[l_arg+1] = 0x00;
  456.     p_lparm -> conv_id = conv_id;
  457.     memcpy( p_lparm -> lu_id, lu_id,8);
  458.     memcpy( p_lparm -> tp_id, tp_id,8);
  459.     save_ini();
  460.     cls(0);
  461.     goto_xy(0,0);
  462.     exit (1);
  463. }
  464. void rem_com(char *p){
  465.  
  466.  unsigned char rts;
  467.  unsigned char wr;
  468.  unsigned int max_length ;
  469.  char gds[8];
  470.  char *p_arg;
  471.  char l_arg;
  472.  int length;
  473.  struct rc {
  474.          unsigned int prim;
  475.          unsigned long sec;
  476.  } v_rc;
  477.  unsigned long rc;
  478.  
  479.     max_length = 2017;
  480.     recwait (tp_id,
  481.           conv_id,
  482.           ll,
  483.           &v_rc,
  484.           &length,
  485.           max_length,
  486.           &rts,
  487.           &gds,
  488.           &wr);
  489.     deallocate (tp_id,
  490.                 conv_id,
  491.                 Flush,
  492.                 &v_rc);
  493.     tp_ended (tp_id, &rc);
  494.     p_aparm -> rc = 3;
  495.     l_arg = (char)strlen(&p[4]);
  496.     p_aparm -> args[0] = l_arg;
  497.     strcpy( &(p_aparm -> args[1]),&p[4]);
  498.     p_lparm -> conv_id = conv_id;
  499.     memcpy( p_lparm -> lu_id, lu_id,8);
  500.     memcpy( p_lparm -> tp_id, tp_id,8);
  501.     save_ini();
  502.     cls(0);
  503.     goto_xy(0,0);
  504.     exit (3);
  505. }
  506. showp(ind)
  507. int ind;
  508. {
  509.         int i;
  510.     unsigned char type[2];
  511.         unsigned char att;
  512.  
  513.     type[1] = 0x00;
  514.         window(22);
  515.         for (i = 0; i < 3; i++) {
  516.              write_string(6 + i, 26, tlx[i], frame[22].attrib);
  517.         }
  518.     for (i = 0; i < p_lu_num; i++) {
  519.          if (cur_ln == i)
  520.         att = frame[22].attrib | 0x0e;
  521.          else
  522.         att = frame[22].attrib;
  523.          write_string(9 + i, 26, tlx[3], frame[22].attrib);
  524.          write_string(9 + i, 28, pstr[i].plu, att);
  525.          write_string(9 + i, 46, pstr[i].mode_name, frame[22].attrib);
  526.          type[0] = pstr[i].lu_type | 0x30;
  527.          write_string(9 + i, 59, type, frame[22].attrib);
  528.         }
  529.         write_string(9 + i, 26, tlx[4], frame[22].attrib);
  530.         att = frame[22].attrib;
  531.         att |= 0x09;
  532.     write_string(7, 14, "Local LU" ,att);
  533.         att |= 0x0f;
  534.     write_string(9, 14, lu_name, att);
  535.         if (ind) {
  536.            getch();
  537.        deactivate(22);
  538.     }
  539. }
  540. rcv(p)
  541. char *p;
  542. {
  543.         struct rcvd {
  544.                       int len;
  545.                       char  dt[2000];
  546.                     } *p_data;
  547.         unsigned long rc;
  548.         unsigned ch;
  549.         unsigned char rts;
  550.         unsigned char wr;
  551.         struct rc {
  552.                   unsigned int prim;
  553.                   unsigned long sec;
  554.                 } v_rc;
  555.         unsigned  int max_length ;
  556.     unsigned long cnt;
  557.     int  length;
  558.         char ccnt[10];
  559.     char fn[18];
  560.     char path[_MAX_PATH];
  561.         int fd;
  562.  
  563.         strcpy(fn, &p[5]);
  564.  
  565.         window(26);  /* Receive window */
  566.         window_xy(26, 2, 1);
  567.         window_puts(26, "Receive file : ");
  568.         window_puts(26, fn);
  569.         window_xy(26, 3, 1);
  570.     window_puts(26, "Current path is : ");
  571.     _getdcwd( 0, path, _MAX_PATH );
  572.     window_puts(26, path);
  573.         window_xy(26, 4, 1);
  574.         window_puts(26, "Current count is : 0");
  575.  
  576.     if ((fd = open(fn, O_WRONLY | O_CREAT | O_BINARY)) < 0) {
  577.               window(14);
  578.               window_xy(14, 2, 5);
  579.               window_puts(14, "Error File Open");
  580.               window_xy(14, 3, 4);
  581.               window_puts(14, "Press ESC to continue");
  582.               while ((ch = getch()) != ESC) ;
  583.               goto RcvExit;
  584.     }
  585.     if ((p_data = malloc(sizeof(struct rcvd))) == NULL) {
  586.         return 1;
  587.     }
  588.        cnt = 0;
  589.        max_length = 2000;
  590.  lcicl :
  591.        recwait (tp_id,
  592.                 conv_id,
  593.                 ll,
  594.                 &v_rc,
  595.                 &length,
  596.                 max_length,
  597.                 &rts,
  598.                 p_data,
  599.         &wr);
  600.        if( v_rc.prim == OK) {
  601.              write(fd,p_data->dt, p_data->len - 2);
  602.              window_xy(26, 4, 20);
  603.          cnt += p_data -> len-2;
  604.          sprintf(ccnt, "%lu", cnt);
  605.              window_puts(26, ccnt);
  606.        }
  607.        else
  608.             goto RcvExit;
  609.        recwait(tp_id,
  610.                 conv_id,
  611.                 ll,
  612.                 &v_rc,
  613.                 &length,
  614.                 max_length,
  615.                 &rts,
  616.                 p_data,
  617.         &wr);
  618.        if( v_rc.prim == OK) {
  619.           goto lcicl;
  620.        }
  621. RcvExit:
  622.         close( fd );
  623.         free(p_data);
  624.         window_xy(26, 5, 1);
  625.         window_puts(26, "End of File... ");
  626.         deactivate( 26 );
  627.         if (p_aparm -> pgm_state == 1) { /* remote control */
  628.             tp_ended (tp_id, &rc);
  629.         }
  630.         return 0;
  631. }
  632. snd(p)
  633. char *p;
  634.  
  635. {
  636.    SendFil(p + 4, 0);
  637. }
  638.