home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume26 / pcomm-2.0.2 / part03 / p_lib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-13  |  7.2 KB  |  290 lines
  1. /*
  2.  * Routines to manipulate the pcomm.param file.
  3.  */
  4.  
  5. #include <stdio.h>
  6. #include "param.h"
  7.  
  8. /*
  9.  * Read the parameter structure from the pcomm.param file.  Returns a
  10.  * pointer to a static area containing the PARAM structure.  All errors
  11.  * are fatal.
  12.  */
  13.  
  14. struct PARAM *
  15. read_param()
  16. {
  17.     FILE *fp, *uid_fopen();
  18.     int i, line, oops;
  19.     char buf[200], *temp_token, *str, *str_dup(), *findfile();
  20.     char message[80], *str_tok();
  21.     static char *token[NUM_PARAM] = {"D_BAUD", "D_PARITY",
  22.     "D_DATA_BITS", "D_STOP_BITS", "HOT_KEY", "ASCII_HOT", "D_DUPLEX",
  23.     "FLOW_CTRL", "CR_IN", "CR_OUT", "LOGFILE", "DUMPFILE", "STRIP",
  24.     "PAUSE_CHAR", "CR_CHAR", "CTRL_CHAR", "ESC_CHAR", "BRK_CHAR",
  25.     "ABORT", "C_DELAY", "R_DELAY", "LOCAL_ECHO", "EXPAND", "CR_DELAY",
  26.     "PACE", "CR_UP", "LF_UP", "TIMER", "CR_DN", "LF_DN", "LD_PLUS",
  27.     "LD_MINUS", "LD_AT", "LD_POUND", "MAC_1", "MAC_2", "MAC_3",
  28.     "MAC_4", "MAC_5", "MAC_6", "MAC_7", "MAC_8", "MAC_9", "MAC_0"};
  29.     static struct PARAM p;
  30.     void error_win();
  31.  
  32.     if ((p.p_path = findfile("pcomm.param")) == NULL)
  33.         error_win(1, "Support file \"pcomm.param\" is missing", "or no read permission");
  34.  
  35.     if (!(fp = uid_fopen(p.p_path, "r"))) {
  36.         sprintf(buf, "\"%s\" for read", p.p_path);
  37.         error_win(1, "Can't open parameter file", buf);
  38.     }
  39.  
  40.     oops = 0;
  41.     line = 0;
  42.     for (i=0; i<NUM_PARAM; i++) {
  43.         line++;
  44.         if (fgets(buf, 200, fp) == NULL) {
  45.             sprintf(message, "is truncated at line %d", line);
  46.             oops++;
  47.             break;
  48.         }
  49.                     /* parse the input line */
  50.         if (!(temp_token = str_tok(buf, '='))) {
  51.             sprintf(message, "is missing a token at line %d", line);
  52.             oops++;
  53.             break;
  54.         }
  55.         if (!(str = str_tok((char *) NULL, '\n'))) {
  56.             sprintf(message, "is missing a parameter at line %d", line);
  57.             oops++;
  58.             break;
  59.         }
  60.                     /* sanity checking */
  61.         if (strcmp(temp_token, token[i])) {
  62.             sprintf(message, "is corrupted at line %d", line);
  63.             oops++;
  64.             break;
  65.         }
  66.  
  67.         switch (i) {
  68.                     /* used in ls_menu() */
  69.             case LINE_SET:
  70.                 p.d_baud = (unsigned int) atoi(str);
  71.                 break;
  72.             case LINE_SET+1:
  73.                 p.d_parity = *str;
  74.                 break;
  75.             case LINE_SET+2:
  76.                 p.d_data_bits = atoi(str);
  77.                 break;
  78.             case LINE_SET+3:
  79.                 p.d_stop_bits = atoi(str);
  80.                 break;
  81.  
  82.                     /* used in term_setup() */
  83.             case TERM_SETUP:
  84.                 p.hot_key = atoi(str);
  85.                 break;
  86.             case TERM_SETUP+1:
  87.                 p.ascii_hot = str_dup(str);
  88.                 break;
  89.             case TERM_SETUP+2:
  90.                 p.d_duplex = str_dup(str);
  91.                 break;
  92.             case TERM_SETUP+3:
  93.                 p.flow_ctrl = str_dup(str);
  94.                 break;
  95.             case TERM_SETUP+4:
  96.                 p.cr_in = str_dup(str);
  97.                 break;
  98.             case TERM_SETUP+5:
  99.                 p.cr_out = str_dup(str);
  100.                 break;
  101.  
  102.                     /* used in gen_setup() */
  103.             case GEN_SETUP:
  104.                 p.logfile = str_dup(str);
  105.                 break;
  106.             case GEN_SETUP+1:
  107.                 p.dumpfile = str_dup(str);
  108.                 break;
  109.             case GEN_SETUP+2:
  110.                 p.strip = str_dup(str);
  111.                 break;
  112.             case GEN_SETUP+3:
  113.                 p.pause_char = *str;
  114.                 break;
  115.             case GEN_SETUP+4:
  116.                 p.cr_char = *str;
  117.                 break;
  118.             case GEN_SETUP+5:
  119.                 p.ctrl_char = *str;
  120.                 break;
  121.             case GEN_SETUP+6:
  122.                 p.esc_char = *str;
  123.                 break;
  124.             case GEN_SETUP+7:
  125.                 p.brk_char = *str;
  126.                 break;
  127.             case GEN_SETUP+8:
  128.                 p.abort = str_dup(str);
  129.                 break;
  130.  
  131.                     /* used in gen_setup() delay_times() */
  132.             case DELAY_TIMES:
  133.                 p.c_delay = atoi(str);
  134.                 break;
  135.             case DELAY_TIMES+1:
  136.                 p.r_delay = atoi(str);
  137.                 break;
  138.  
  139.                     /* used in axfer_setup() */
  140.             case ASCII_SETUP:
  141.                 p.local_echo = str_dup(str);
  142.                 break;
  143.             case ASCII_SETUP+1:
  144.                 p.expand = str_dup(str);
  145.                 break;
  146.             case ASCII_SETUP+2:
  147.                 p.cr_delay = atoi(str);
  148.                 break;
  149.             case ASCII_SETUP+3:
  150.                 p.pace = str_dup(str);
  151.                 break;
  152.             case ASCII_SETUP+4:
  153.                 p.cr_up = str_dup(str);
  154.                 break;
  155.             case ASCII_SETUP+5:
  156.                 p.lf_up = str_dup(str);
  157.                 break;
  158.             case ASCII_SETUP+6:
  159.                 p.timer = atoi(str);
  160.                 break;
  161.             case ASCII_SETUP+7:
  162.                 p.cr_dn = str_dup(str);
  163.                 break;
  164.             case ASCII_SETUP+8:
  165.                 p.lf_dn = str_dup(str);
  166.                 break;
  167.  
  168.                     /* used in d_revise() */
  169.             case LD_CODES:
  170.                 p.ld_plus = str_dup(str);
  171.                 break;
  172.             case LD_CODES+1:
  173.                 p.ld_minus = str_dup(str);
  174.                 break;
  175.             case LD_CODES+2:
  176.                 p.ld_at = str_dup(str);
  177.                 break;
  178.             case LD_CODES+3:
  179.                 p.ld_pound = str_dup(str);
  180.                 break;
  181.  
  182.                     /* used in macro() */
  183.             case MACROS:
  184.                 p.mac_1 = str_dup(str);
  185.                 break;
  186.             case MACROS+1:
  187.                 p.mac_2 = str_dup(str);
  188.                 break;
  189.             case MACROS+2:
  190.                 p.mac_3 = str_dup(str);
  191.                 break;
  192.             case MACROS+3:
  193.                 p.mac_4 = str_dup(str);
  194.                 break;
  195.             case MACROS+4:
  196.                 p.mac_5 = str_dup(str);
  197.                 break;
  198.             case MACROS+5:
  199.                 p.mac_6 = str_dup(str);
  200.                 break;
  201.             case MACROS+6:
  202.                 p.mac_7 = str_dup(str);
  203.                 break;
  204.             case MACROS+7:
  205.                 p.mac_8 = str_dup(str);
  206.                 break;
  207.             case MACROS+8:
  208.                 p.mac_9 = str_dup(str);
  209.                 break;
  210.             case MACROS+9:
  211.                 p.mac_0 = str_dup(str);
  212.                 break;
  213.         }
  214.     }
  215.     fclose(fp);
  216.     if (oops) {
  217.         sprintf(buf, "Parameter file \"%s\"", p.p_path);
  218.         error_win(1, buf, message);
  219.     }
  220.     return(&p);
  221. }
  222.  
  223. /*
  224.  * Write the updated param structure to disk.  The values in memory should
  225.  * have already been "purified".  A non-zero return code means non-fatal
  226.  * error.
  227.  */
  228.  
  229. int
  230. up_param()
  231. {
  232.     FILE *fp, *uid_fopen();
  233.     char buf[80];
  234.     void error_win();
  235.                     /* open for write */
  236.     if (!(fp = uid_fopen(param->p_path, "w"))) {
  237.         sprintf(buf, "\"%s\"", param->p_path);
  238.         error_win(0, "No write permission on parameter file", buf);
  239.         return(1);
  240.     }
  241.  
  242.     fprintf(fp, "D_BAUD=%d\n", param->d_baud);
  243.     fprintf(fp, "D_PARITY=%c\n", param->d_parity);
  244.     fprintf(fp, "D_DATA_BITS=%d\n", param->d_data_bits);
  245.     fprintf(fp, "D_STOP_BITS=%d\n", param->d_stop_bits);
  246.     fprintf(fp, "HOT_KEY=%d\n", param->hot_key);
  247.     fprintf(fp, "ASCII_HOT=%s\n", param->ascii_hot);
  248.     fprintf(fp, "D_DUPLEX=%s\n", param->d_duplex);
  249.     fprintf(fp, "FLOW_CTRL=%s\n", param->flow_ctrl);
  250.     fprintf(fp, "CR_IN=%s\n", param->cr_in);
  251.     fprintf(fp, "CR_OUT=%s\n", param->cr_out);
  252.     fprintf(fp, "LOGFILE=%s\n", param->logfile);
  253.     fprintf(fp, "DUMPFILE=%s\n", param->dumpfile);
  254.     fprintf(fp, "STRIP=%s\n", param->strip);
  255.     fprintf(fp, "PAUSE_CHAR=%c\n", param->pause_char);
  256.     fprintf(fp, "CR_CHAR=%c\n", param->cr_char);
  257.     fprintf(fp, "CTRL_CHAR=%c\n", param->ctrl_char);
  258.     fprintf(fp, "ESC_CHAR=%c\n", param->esc_char);
  259.     fprintf(fp, "BRK_CHAR=%c\n", param->brk_char);
  260.     fprintf(fp, "ABORT=%s\n", param->abort);
  261.     fprintf(fp, "C_DELAY=%d\n", param->c_delay);
  262.     fprintf(fp, "R_DELAY=%d\n", param->r_delay);
  263.     fprintf(fp, "LOCAL_ECHO=%s\n", param->local_echo);
  264.     fprintf(fp, "EXPAND=%s\n", param->expand);
  265.     fprintf(fp, "CR_DELAY=%d\n", param->cr_delay);
  266.     fprintf(fp, "PACE=%s\n", param->pace);
  267.     fprintf(fp, "CR_UP=%s\n", param->cr_up);
  268.     fprintf(fp, "LF_UP=%s\n", param->lf_up);
  269.     fprintf(fp, "TIMER=%d\n", param->timer);
  270.     fprintf(fp, "CR_DN=%s\n", param->cr_dn);
  271.     fprintf(fp, "LF_DN=%s\n", param->lf_dn);
  272.     fprintf(fp, "LD_PLUS=%s\n", param->ld_plus);
  273.     fprintf(fp, "LD_MINUS=%s\n", param->ld_minus);
  274.     fprintf(fp, "LD_AT=%s\n", param->ld_at);
  275.     fprintf(fp, "LD_POUND=%s\n", param->ld_pound);
  276.     fprintf(fp, "MAC_1=%s\n", param->mac_1);
  277.     fprintf(fp, "MAC_2=%s\n", param->mac_2);
  278.     fprintf(fp, "MAC_3=%s\n", param->mac_3);
  279.     fprintf(fp, "MAC_4=%s\n", param->mac_4);
  280.     fprintf(fp, "MAC_5=%s\n", param->mac_5);
  281.     fprintf(fp, "MAC_6=%s\n", param->mac_6);
  282.     fprintf(fp, "MAC_7=%s\n", param->mac_7);
  283.     fprintf(fp, "MAC_8=%s\n", param->mac_8);
  284.     fprintf(fp, "MAC_9=%s\n", param->mac_9);
  285.     fprintf(fp, "MAC_0=%s\n", param->mac_0);
  286.  
  287.     fclose(fp);
  288.     return(0);
  289. }
  290.