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