home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume26 / pcomm-2.0.2 / part05 / pcomm_cmd.c next >
Encoding:
C/C++ Source or Header  |  1993-04-13  |  13.2 KB  |  539 lines
  1. /*
  2.  * An external command facility for Pcomm.  All of the "sanity checking"
  3.  * is done at this end, so virtually no checking is done at Pcomm's end.
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <ctype.h>
  8. #include "config.h"
  9. #include "cmd.h"
  10.  
  11. #ifdef BSD
  12. #include <sys/file.h>
  13. #else /* BSD */
  14. #include <fcntl.h>
  15. #endif /* BSD */
  16.  
  17. int cmd_ipc;
  18.  
  19. main(argc, argv)
  20. int argc;
  21. char *argv[];
  22. {
  23.     static char *cmds[] = {"SET", "QUERY", "IF", "DIAL", "REDIAL", "EXIT",
  24.     "CLEAR_SCREEN", "CHG_DIR", "HANG_UP", "PRINTER", "MODEM_BREAK", "SEND",
  25.     "RECEIVE", "SCREEN_DUMP", "DATA_LOG", 0};
  26.     static char *set_args[] = {"BAUD", "PARITY", "DATA_BITS", "STOP_BITS",
  27.     "DUPLEX", "AUX", "HOT_KEY", "ASCII_HOT", "FLOW_CTRL", "CR_IN",
  28.     "CR_OUT", "LOGFILE", "DUMPFILE", "STRIP", "LOCAL_ECHO", "EXPAND",
  29.     "CR_DELAY", "PACE", "CR_UP", "LF_UP", "TIMER", "CR_DN", "LF_DN", 0};
  30.     static char *qry_args[] = {"TTY_NAME", "MODEM_NAME", 0};
  31.     static char *if_args[] = {"CONNECTED", "LOG_STATUS", "PRINTER_STATUS",
  32.     0};
  33.     static char *xfer_args[] = {"XMODEM", "XMODEM_1K", "MODEM7", "YMODEM",
  34.     "YMODEM_G", "ASCII", "EXT_1", "EXT_2", "EXT_3", 0};
  35.     char *command, buf[256], *mkupper(), *arg1, *arg2, *s, *strchr();
  36.     char *pcomm_cmd, *getenv();
  37.     int cmd_num, i, arg_num, got_it;
  38.     unsigned int ui;
  39.     void send_cmd(), get_value(), exit(), cmd_exit();
  40.  
  41.                     /* get the environmental variable */
  42.     pcomm_cmd = getenv("PCOMM_CMD");
  43.     if (argc == 1 || pcomm_cmd == NULL || *pcomm_cmd == '\0') {
  44.         fprintf(stderr, "%s: This is a Pcomm support program.  It is intended for use inside\n", argv[0]);
  45.         fprintf(stderr, "an auto-login shell script\n");
  46.         exit(1);
  47.     }
  48.                     /* parse the command line */
  49.     command = mkupper(argv[1]);
  50.     if (argc > 2)
  51.         arg1 = mkupper(argv[2]);
  52.     else
  53.         arg1 = "";
  54.     if (argc > 3)
  55.         arg2 = mkupper(argv[3]);
  56.     else
  57.         arg2 = "";
  58.                     /* convert command to a number */
  59.     cmd_num = 0;
  60.     while (cmds[cmd_num] != NULL) {
  61.         if (!strcmp(command, cmds[cmd_num]))
  62.             break;
  63.         cmd_num++;
  64.     }
  65.                     /* attach to the IPC channel */
  66.     if ((cmd_ipc = ipc_attach(pcomm_cmd, O_RDWR)) < 0) {
  67.         fprintf(stderr, "%s: Can't attach to IPC channel\n", argv[0]);
  68.         exit(1);
  69.     }
  70.                     /* do it! */
  71.     switch(cmd_num) {
  72.         case SET:
  73.             if (argc < 4) {
  74.                 fprintf(stderr, "%s: SET command requires 2 arguments\n", argv[0]);
  75.                 cmd_exit(1);
  76.             }
  77.                 
  78.             arg_num = 0;
  79.             while (set_args[arg_num] != NULL) {
  80.                 if (!strcmp(arg1, set_args[arg_num]))
  81.                     break;
  82.                 arg_num++;
  83.             }
  84.             switch(arg_num) {
  85.                 case BAUD:
  86.                     ui = (unsigned int) atoi(arg2);
  87.                     switch(ui) {
  88.                         case 300:
  89.                         case 1200:
  90.                         case 2400:
  91.                         case 4800:
  92.                         case 9600:
  93.                         case 19200:
  94.                         case 38400:
  95.                             break;
  96.                         default:
  97.                             fprintf(stderr, "%s: bad value '%s' for SET BAUD command\n", argv[0], argv[3]);
  98.                             cmd_exit(1);
  99.                     }
  100.                     sprintf(buf, "%d", ui);
  101.                     send_cmd(SET, BAUD, buf);
  102.                     break;
  103.                 case PARITY:
  104.                     if (strcmp(arg2, "EVEN") && strcmp(arg2, "ODD") && strcmp(arg2, "NONE")) {
  105.                         fprintf(stderr, "%s: bad value '%s' for SET PARITY command\n", argv[0], argv[3]);
  106.                         cmd_exit(1);
  107.                     }
  108.                     send_cmd(SET, PARITY, arg2);
  109.                     break;
  110.                 case DATA_BITS:
  111.                     i = atoi(arg2);
  112.                     if (i != 7 && i != 8) {
  113.                         fprintf(stderr, "%s: bad value '%s' for SET DATA_BITS command\n", argv[0], argv[3]);
  114.                         cmd_exit(1);
  115.                     }
  116.                     sprintf(buf, "%d", i);
  117.                     send_cmd(SET, DATA_BITS, buf);
  118.                     break;
  119.                 case STOP_BITS:
  120.                     i = atoi(arg2);
  121.                     if (i != 1 && i != 2) {
  122.                         fprintf(stderr, "%s: bad value '%s' for SET STOP_BITS command\n", argv[0], argv[3]);
  123.                         cmd_exit(1);
  124.                     }
  125.                     sprintf(buf, "%d", i);
  126.                     send_cmd(SET, STOP_BITS, buf);
  127.                     break;
  128.                 case DUPLEX:
  129.                     if (strcmp(arg2, "FULL") && strcmp(arg2, "HALF")) {
  130.                         fprintf(stderr, "%s: bad value '%s' for SET DUPLEX command\n", argv[0], argv[3]);
  131.                         cmd_exit(1);
  132.                     }
  133.                     send_cmd(SET, DUPLEX, arg2);
  134.                     break;    
  135.                 case AUX:
  136.                     send_cmd(SET, AUX, argv[3]);
  137.                     break;
  138.                 case HOT_KEY:
  139.                     i = atoi(arg2);
  140.                     if (i <= 0 || i > 256) {
  141.                         fprintf(stderr, "%s: bad value '%s' for SET HOT_KEY command\n", argv[0], argv[3]);
  142.                         cmd_exit(1);
  143.                     }
  144.                     send_cmd(SET, HOT_KEY, arg2);
  145.                     break;
  146.                 case ASCII_HOT:
  147.                     send_cmd(SET, ASCII_HOT, argv[3]);
  148.                     break;
  149.                 case FLOW_CTRL:
  150.                     if (strcmp(arg2, "XON/XOFF") && strcmp(arg2, "NONE")) {
  151.                         fprintf(stderr, "%s: bad value '%s' for SET FLOW_CTRL command\n", argv[0], argv[3]);
  152.                         cmd_exit(1);
  153.                     }
  154.                     send_cmd(SET, FLOW_CTRL, arg2);
  155.                     break;
  156.                 case CR_IN:    
  157.                     if (strcmp(arg2, "CR") && strcmp(arg2, "CR/LF")) {
  158.                         fprintf(stderr, "%s: bad value '%s' for SET CR_IN command\n", argv[0], argv[3]);
  159.                         cmd_exit(1);
  160.                     }
  161.                     send_cmd(SET, CR_IN, arg2);
  162.                     break;
  163.                 case CR_OUT:
  164.                     if (strcmp(arg2, "CR") && strcmp(arg2, "CR/LF")) {
  165.                         fprintf(stderr, "%s: bad value '%s' for SET CR_OUT command\n", argv[0], argv[3]);
  166.                         cmd_exit(1);
  167.                     }
  168.                     send_cmd(SET, CR_OUT, arg2);
  169.                     break;
  170.                 case LOGFILE:
  171.                     send_cmd(SET, LOGFILE, argv[3]);
  172.                     break;
  173.                 case DUMPFILE:
  174.                     send_cmd(SET, DUMPFILE, argv[3]);
  175.                     break;
  176.                 case STRIP:    
  177.                     if (strcmp(arg2, "YES") && strcmp(arg2, "NO")) {
  178.                         fprintf(stderr, "%s: bad value '%s' for SET STRIP command\n", argv[0], argv[3]);
  179.                         cmd_exit(1);
  180.                     }
  181.                     send_cmd(SET, STRIP, arg2);
  182.                     break;
  183.                 case LOCAL_ECHO:    
  184.                     if (strcmp(arg2, "YES") && strcmp(arg2, "NO")) {
  185.                         fprintf(stderr, "%s: bad value '%s' for SET LOCAL_ECHO command\n", argv[0], argv[3]);
  186.                         cmd_exit(1);
  187.                     }
  188.                     send_cmd(SET, LOCAL_ECHO, arg2);
  189.                     break;
  190.                 case EXPAND:
  191.                     if (strcmp(arg2, "YES") && strcmp(arg2, "NO")) {
  192.                         fprintf(stderr, "%s: bad value '%s' for SET EXPAND command\n", argv[0], argv[3]);
  193.                         cmd_exit(1);
  194.                     }
  195.                     send_cmd(SET, EXPAND, arg2);
  196.                     break;
  197.                 case CR_DELAY:
  198.                     i = atoi(arg2);
  199.                     if (i != 0 && i != 100 && i != 150) {
  200.                         fprintf(stderr, "%s: bad value '%s' for SET CR_DELAY command\n", argv[0], argv[3]);
  201.                         cmd_exit(1);
  202.                     }
  203.                     sprintf(buf, "%d", i);
  204.                     send_cmd(SET, CR_DELAY, buf);
  205.                     break;
  206.                 case PACE:
  207.                     if (strcmp(arg2, "YES") && strcmp(arg2, "NO")) {
  208.                         fprintf(stderr, "%s: bad value '%s' for SET PACE command\n", argv[0], argv[3]);
  209.                         cmd_exit(1);
  210.                     }
  211.                     send_cmd(SET, PACE, arg2);
  212.                     break;
  213.                 case CR_UP:
  214.                     if (strcmp(arg2, "NONE") && strcmp(arg2, "ADD_LF") && strcmp(arg2, "STRIP")) {
  215.                         fprintf(stderr, "%s: bad value '%s' for SET CR_UP command\n", argv[0], argv[3]);
  216.                         cmd_exit(1);
  217.                     }
  218.                     send_cmd(SET, CR_UP, arg2);
  219.                     break;
  220.                 case LF_UP:
  221.                     if (strcmp(arg2, "NONE") && strcmp(arg2, "ADD_CR") && strcmp(arg2, "STRIP")) {
  222.                         fprintf(stderr, "%s: bad value '%s' for SET LF_UP command\n", argv[0], argv[3]);
  223.                         cmd_exit(1);
  224.                     }
  225.                     send_cmd(SET, LF_UP, arg2);
  226.                     break;
  227.                 case TIMER:
  228.                     i = atoi(arg2);
  229.                     if (i < 5 || i > 150) {
  230.                         fprintf(stderr, "%s: bad value '%s' for SET TIMER command\n", argv[0], argv[3]);
  231.                         cmd_exit(1);
  232.                     }
  233.                     sprintf(buf, "%d", i);
  234.                     send_cmd(SET, CR_DN, buf);
  235.                     break;
  236.                 case CR_DN:
  237.                     if (strcmp(arg2, "NONE") && strcmp(arg2, "ADD_LF") && strcmp(arg2, "STRIP")) {
  238.                         fprintf(stderr, "%s: bad value '%s' for SET CR_DN command\n", argv[0], argv[3]);
  239.                         cmd_exit(1);
  240.                     }
  241.                     send_cmd(SET, CR_DN, arg2);
  242.                     break;
  243.                 case LF_DN:    
  244.                     if (strcmp(arg2, "NONE") && strcmp(arg2, "ADD_CR") && strcmp(arg2, "STRIP")) {
  245.                         fprintf(stderr, "%s: bad value '%s' for SET LF_DN command\n", argv[0], argv[3]);
  246.                         cmd_exit(1);
  247.                     }
  248.                     send_cmd(SET, LF_DN, arg2);
  249.                     break;
  250.                 default:
  251.                     fprintf(stderr, "%s: Illegal argument '%s' for SET command\n", argv[0], argv[2]);
  252.                     cmd_exit(1);
  253.                     break;
  254.             }
  255.             break;
  256.         case QUERY:        /* the QUERY commands */
  257.             if (argc < 3) {
  258.                 fprintf(stderr, "%s: QUERY command requires an argument\n", argv[0]);
  259.                 cmd_exit(1);
  260.             }
  261.                 
  262.             arg_num = 0;
  263.             while (qry_args[arg_num] != NULL) {
  264.                 if (!strcmp(arg1, qry_args[arg_num]))
  265.                     break;
  266.                 arg_num++;
  267.             }
  268.  
  269.             switch(arg_num) {
  270.                 case TTY_NAME:
  271.                     send_cmd(QUERY, TTY_NAME, "dummy");
  272.                     get_value();
  273.                     break;
  274.                 case MODEM_NAME:
  275.                     send_cmd(QUERY, MODEM_NAME, "dummy");
  276.                     get_value();
  277.                     break;
  278.                 default:
  279.                     fprintf(stderr, "%s: Illegal argument '%s' for QUERY command\n", argv[0], argv[2]);
  280.                     cmd_exit(1);
  281.                     break;
  282.             }
  283.             break;
  284.         case IF:        /* the IF commands */
  285.             if (argc < 3) {
  286.                 fprintf(stderr, "%s: IF command requires an argument\n", argv[0]);
  287.                 cmd_exit(1);
  288.             }
  289.                 
  290.             arg_num = 0;
  291.             while (if_args[arg_num] != NULL) {
  292.                 if (!strcmp(arg1, if_args[arg_num]))
  293.                     break;
  294.                 arg_num++;
  295.             }
  296.  
  297.             switch(arg_num) {
  298.                 case CONNECTED:
  299.                     send_cmd(IF, CONNECTED, "dummy");
  300.                     break;
  301.                 case LOG_STATUS:
  302.                     send_cmd(IF, LOG_STATUS, "dummy");
  303.                     break;
  304.                 case PRINTER_STATUS:
  305.                     send_cmd(IF, PRINTER_STATUS, "dummy");
  306.                     break;
  307.                 default:
  308.                     fprintf(stderr, "%s: Illegal argument '%s' for IF command\n", argv[0], argv[2]);
  309.                     cmd_exit(1);
  310.                     break;
  311.             }
  312.             break;
  313.         case DIAL:
  314.             if (argc < 3) {
  315.                 fprintf(stderr, "%s: DIAL command requires an argument\n", argv[0]);
  316.                 cmd_exit(1);
  317.             }
  318.             if (!strcmp(arg1, "MANUAL")) {
  319.                 if (argc < 4) {
  320.                     fprintf(stderr, "%s: DIAL MANUAL command requires an argument\n", argv[0]);
  321.                     cmd_exit(1);
  322.                 }
  323.                 send_cmd(DIAL, 1, argv[3]);
  324.             }
  325.             else {
  326.                 if (s = strchr("+-@#", *argv[2]))
  327.                     i = atoi(++s);
  328.                 else
  329.                     i = atoi(argv[2]);
  330.                 if (i < 1 || i > 100) {
  331.                     fprintf(stderr, "%s: bad value '%s' for DIAL command\n", argv[0], argv[2]);
  332.                     cmd_exit(1);
  333.                 }
  334.                 send_cmd(DIAL, 0, argv[2]);
  335.             }
  336.             break;
  337.         case REDIAL:
  338.             if (argc < 3) {
  339.                 fprintf(stderr, "%s: REDIAL command requires at least 1 argument\n", argv[0]);
  340.                 cmd_exit(1);
  341.             }
  342.             send_cmd(REDIAL, 0, argv[2]);
  343.             break;
  344.         case EXIT:
  345.             send_cmd(EXIT, 0, "dummy");
  346.             /*
  347.              * Don't wait for a return code... Pcomm won't be
  348.              * around to send it!  So, assume it got there OK.
  349.              */
  350.             cmd_exit(0);
  351.             break;
  352.         case CLEAR_SCREEN:
  353.             send_cmd(CLEAR_SCREEN, 0, "dummy");
  354.             break;
  355.         case CHG_DIR:
  356.             if (argc < 3) {
  357.                 fprintf(stderr, "%s: CHG_DIR command requires an argument\n", argv[0]);
  358.                 cmd_exit(1);
  359.             }
  360.             send_cmd(CHG_DIR, 0, argv[2]);
  361.             break;
  362.         case HANG_UP:
  363.             send_cmd(HANG_UP, 0, "dummy");
  364.             break;
  365.         case PRINTER:
  366.             if (argc < 3) {
  367.                 fprintf(stderr, "%s: PRINTER command requires an argument\n", argv[0]);
  368.                 cmd_exit(1);
  369.             }
  370.             if (strcmp(arg1, "ON") && strcmp(arg1, "OFF")) {
  371.                 fprintf(stderr, "%s: bad value '%s' for PRINTER command\n", argv[0], argv[2]);
  372.                 cmd_exit(1);
  373.             }
  374.             if (!strcmp(arg1, "ON"))
  375.                 send_cmd(PRINTER, 1, "dummy");
  376.             else
  377.                 send_cmd(PRINTER, 0, "dummy");
  378.             break;
  379.         case MODEM_BREAK:
  380.             send_cmd(MODEM_BREAK, 0, "dummy");
  381.             break;
  382.         case SEND:
  383.             if (argc < 4) {
  384.                 fprintf(stderr, "%s: SEND command requires 2 arguments\n", argv[0]);
  385.                 cmd_exit(1);
  386.             }
  387.             arg_num = 0;
  388.             got_it = 0;
  389.             while (xfer_args[arg_num] != NULL) {
  390.                 if (!strcmp(xfer_args[arg_num], arg1)) {
  391.                     got_it++;
  392.                     break;
  393.                 }
  394.                 arg_num++;
  395.             }
  396.             if (!got_it) {
  397.                 fprintf(stderr, "%s: Illegal argument '%s' for SEND command\n", argv[0], argv[2]);
  398.                 cmd_exit(1);
  399.             }
  400.             send_cmd(SEND, ++arg_num, argv[3]);
  401.             break;
  402.         case RECEIVE:
  403.             if (argc < 3) {
  404.                 fprintf(stderr, "%s: RECEIVE command requires at least 1 argument\n", argv[0]);
  405.                 cmd_exit(1);
  406.             }
  407.             arg_num = 0;
  408.             got_it = 0;
  409.             while (xfer_args[arg_num] != NULL) {
  410.                 if (!strcmp(xfer_args[arg_num], arg1)) {
  411.                     got_it++;
  412.                     break;
  413.                 }
  414.                 arg_num++;
  415.             }
  416.             if (!got_it) {
  417.                 fprintf(stderr, "%s: Illegal argument '%s' for RECEIVE command\n", argv[0], argv[2]);
  418.                 cmd_exit(1);
  419.             }
  420.             if (argc < 4)
  421.                 send_cmd(RECEIVE, ++arg_num, "dummy");
  422.             else
  423.                 send_cmd(RECEIVE, ++arg_num, argv[3]);
  424.             break;
  425.         case SCREEN_DUMP:
  426.             send_cmd(SCREEN_DUMP, 0, "dummy");
  427.             break;
  428.         case DATA_LOG:
  429.             if (!strcmp(arg1, "ON"))
  430.                 send_cmd(DATA_LOG, 1, "dummy");
  431.             else
  432.                 send_cmd(DATA_LOG, 0, "dummy");
  433.             break;
  434.         default:
  435.             fprintf(stderr, "%s: Illegal command '%s'\n", argv[0], argv[1]);
  436.             cmd_exit(1);
  437.             break;
  438.     }
  439.                     /* get the return status */
  440.     if (ipc_read(cmd_ipc, buf, 256)) {
  441. #ifndef sparc
  442.         fprintf(stderr, "Can't read from IPC\n");
  443. #endif /* sparc */
  444.         cmd_exit(1);
  445.     }
  446.     cmd_exit(atoi(buf));
  447. }
  448.  
  449. /*
  450.  * Copy and convert a string to all upper case 
  451.  */
  452.  
  453. char *
  454. mkupper(string)
  455. char *string;
  456. {
  457.     int i;
  458.     char buf[80], *ans, *strcpy(), *malloc();
  459.     void exit();
  460.  
  461.     i = 0;
  462.     while (*string != '\0') {
  463.         if (islower(*string))
  464.             buf[i++] = toupper(*string);
  465.         else
  466.             buf[i++] = *string;
  467.         string++;
  468.         if (i == 79)
  469.             break;
  470.     }
  471.     buf[i] = '\0';
  472.     if ((ans = malloc((unsigned int) strlen(buf)+1)) == NULL) {
  473.         fprintf(stderr, "out of memory!\n");
  474.         exit(1);
  475.     }
  476.     strcpy(ans, buf);
  477.     
  478.     return(ans);
  479. }
  480.  
  481. /*
  482.  * Get a return value from a command, (and therefore exit prematurely).
  483.  */
  484.  
  485. void 
  486. get_value()
  487. {
  488.     char *s, *strchr(), buf[256];
  489.     void cmd_exit();
  490.  
  491.     if (ipc_read(cmd_ipc, buf, 256)) {
  492.         fprintf(stderr, "Can't read from IPC\n");
  493.         cmd_exit(1);
  494.     }
  495.  
  496.     if (s = strchr(buf, '\n'))
  497.         *++s = '\0';
  498.  
  499.     printf("%s", buf);
  500.     cmd_exit(0);
  501. }
  502.  
  503. /*
  504.  * Send a command to the Pcomm process
  505.  */
  506.  
  507. void
  508. send_cmd(cmd, arg1, arg2)
  509. int cmd, arg1;
  510. char *arg2;
  511. {
  512.     char buf[256];
  513.     void cmd_exit();
  514.  
  515.     sprintf(buf, "%d %d %249.249s\n", cmd, arg1, arg2);
  516.     if (ipc_write(cmd_ipc, buf, 256)) {
  517.         fprintf(stderr, "Can't write to IPC\n");
  518.         cmd_exit(1);
  519.     }
  520.     return;
  521. }
  522.  
  523. /*
  524.  * Clean up and go home...
  525.  */
  526.  
  527. void
  528. cmd_exit(n)
  529. int n;
  530. {
  531.     void exit();
  532.  
  533.     ipc_detach(cmd_ipc);
  534.     exit(n);
  535. }
  536.  
  537. #define MAIN
  538. #include IPC
  539.