lprsetup.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

                

/**************************
*  get fields for DoAdd
**************************/
AddField ()
{
    char    buf[LEN];		/* temp buffer		 */
    int     done;		/* flag			 */
    int     i,j;		/* temp index		 */
    struct stat st;
    char *valu;
    int yn;
    struct table *lp_entry=NULL;

    /********************************
    *  clear changeable tab values
    ********************************/
    for (i = 0; tab[i].name != 0; ++i)
    {
	tab[i].used = NO;
	tab[i].nvalue = 0;
    }

    if (MatchPrinter () == QUIT)
	return (QUIT);

    if (AddSyn () == QUIT)
	return (QUIT);

    if ((strcmp (ptype, "remote") !=0) && (strcmp(ptype, "printserver") != 0)) {
	do {
	    printf ("\nSet device pathname 'lp'");
	    if ((pnum[0] != '\0') && (pnum[1] == '\0'))
                (void) sprintf (buf, "%s%s", "/dev/tty0", pnum);
            else
                (void) sprintf (buf, "%s%s", "/dev/tty", pnum);
	} while (SetVal ("lp", buf) < 0);
	
	do {
	    printf ("\nSet accounting file 'af'");
            if (pnum[0] == '0' )
                (void) sprintf (buf, "%s", "/usr/adm/lpacct");
            else
                (void) sprintf (buf, "%s%s%s", "/usr/adm/lp", pnum, "acct");
	} while (SetVal ("af", buf) < 0);
    }

    /* Spooling directory is set for ALL printers, including 'remote' */

    do {
        printf ("\nSet spooler directory 'sd'");
        if (pnum[0] == '0' )
            (void) sprintf (buf, "%s", "/usr/spool/lpd");
        else
            (void) sprintf (buf, "%s%s", "/usr/spool/lpd", pnum);
    } while (SetVal ("sd", buf) < 0);

    if (strcmp (ptype, "remote") != 0)
    {
        do {
            printf ("\nSet printer error log file 'lf'");
            if (pnum[0] == '0' )
                (void) sprintf (buf, "/usr/adm/lperr");
            else
                (void) sprintf (buf, "/usr/adm/lp%serr", pnum);
        } while (SetVal ("lf", buf) < 0);
    }
    for ( i = 0; tab[i].name; ++i ) {
	if ( strcmp (tab[i].name, "lp" ) == 0 ) {
	    lp_entry = &tab[i];
	    break;
	}
    }
    if (!lp_entry) {
	printf("\nInternal Error, no \"lp\" entry");
	return(QUIT);
    }
    if (lp_entry->used == YES && lp_entry->nvalue != NULL) {
	if (strlen(lp_entry->nvalue) > 8 &&
	    strncmp(lp_entry->nvalue, "/dev/tty", 8) == 0) {
	    /*
	     * Serial printer connection
	     */
	    do {
		printf("\nSet printer connection type 'ct'");
		(void) sprintf(buf, "%s", "dev");
	    } while (SetVal("ct", buf) < 0);

	    if (strcmp (buf, "lat") == 0) {
		if (stat(lp_entry->nvalue, &st) == 0
		    && major(st.st_rdev) == LAT_MAJORDEV) {
		    int k;
		    int OP_or_OS_set=0;

		    for (k=0; k < 2; k++) {
			if (k)
			printf("\nYou must enter a value for 'ts'");

			do {
			    printf("\nSet terminal server name 'ts'");
			    (void) sprintf(buf, "");
			} while (SetVal ("ts", buf) < 0);

			if (buf[0] != '\0') break;
		    }

		    for (k=0; !OP_or_OS_set && k < 2; k++) {
			if (k)
			printf("\nYou must enter a value for either 'op' or 'os'\n");
			do {
			    printf("\nSet terminal server output port 'op'");
			    (void) sprintf(buf, "");
			} while (SetVal ("op", buf) < 0);
			if (buf[0] != '\0') OP_or_OS_set++;
			do {
			    printf("\nSet terminal server output service 'os'");
			    (void) sprintf(buf, "");
			} while (SetVal ("os", buf) < 0);
			if (buf[0] != '\0') OP_or_OS_set++;
		    }

		} else {

		    printf("\nThe tty you are currently using is not a LAT configured tty. \n\
You must configure a tty for LAT use, see MAKEDEV(8) and lcp(8) \n\
for more details.");

		    return(QUIT);	

		}
	    } else {
		/*
		 * if it's a serial printer not parallel
		 * include baud rate
		 */
		do {
		    printf ("\nSet printer baud rate 'br'");
		    (void) sprintf (buf, "%s", "9600");
		} while (SetVal ("br", buf) < 0);
	    }
	} else {
	    /*
	     * lp field does not appear to be a tty device
	     * Don't use the tty ioctl fields
	     */
	    static char *not_used_tab[] = { "br", "fc", "fs", "xc", "xs", 0 };
	    register char **p;

	    for (p = not_used_tab; *p; p++) {
		for ( i = 0; tab[i].name; ++i ) {
		    if ( strcmp (tab[i].name, *p) == 0 ) {
			tab[i].used = NO;
			break;
		    }
		}
	    }
	}
    }
    if (strcmp (ptype, "printserver") == 0) 
    {
	do {
	   printf("\nSet printserver output filter 'of'\n\
retype default exactly with NODE replaced by printserver node name\n");
	   printf("\nFor a printserver running TCP/IP, use 'iplpscomm' instead of 'lpscomm'\n");
	   sprintf(buf, "%s", "");
	} while  (SetVal ("of", buf) < 0);
    }

    if (strcmp (ptype, "remote") == 0) 
    {
	/*
	 * It is remote but we still have to add
	 *     :lp=:\
	 * in the /etc/printcap file.
	 */
	/* Find index for 'lp' */
	for ( i = 0; tab[i].name; ++i )
	  if ( strcmp(tab[i].name,"lp") == 0 )
	    break;
	tab[i].used = YES;
	*tab[i].svalue = 0;  /* make lp="" for the printcap */
	do {
            printf ("\nSet remote system name 'rm'");
		(void) sprintf(buf,"");
        } while (SetVal ("rm", buf) < 0);
	do {
            printf ("\nSet remote system printer name 'rp'");
		(void) sprintf(buf,"");
        } while (SetVal ("rp", buf) < 0);
    }

    /*********************************
    *  modify default field values
    *********************************/
    printf (h_symsel);
    for (i = 0,j=0; tab[i].name != 0; ++i){
        printf (" %s ", tab[i].name);
	if (j++ > 14){
    		printf ("\n");
		j = 0;
	}
    }
    printf ("\n");

    done = FALSE;
    for (;;)
    {
	while (!done)
	{
		printf ("\nEnter symbol name: ");
		switch (getcmd ())
		{
		    case GOT_SYMBOL:
			DoSymbol ();	/* Don't have to special case sd, the
					 * spooling directory since the entry
					 * is being added. It still can be
					 * changed since it doesn't exist yet.
					 */
			break;
		    case HELP:
			PrintHelp (h_symsel);
    			for (i = 0,j=0; tab[i].name != 0; ++i){
        			printf (" %s ", tab[i].name);
				if (j++ > 14){
    					printf ("\n");
					j = 0;
				}
    			}
			printf ("\n");
			break;
		    case NOREPLY:
			break;
		    case PRINT:
			Print (USED);
			break;
		    case LIST:
			Print (ALL);
			break;
		    case QUIT:
			done = TRUE;
			break;
		    default:
			printf ("\nInvalid choice, try again.\n");
			break;
		}
	}
	if (Verified () == TRUE)
	    break;
	else
	{
	    printf("Do you wish to continue with this entry?  [y] ");
		yn = 'y';
	    if (YesNo (yn) == FALSE) {
		return(QUIT);		/* no, they wish to abort */
	    }
	    else
	        done = FALSE;
	}
    }
    return (OK);
}

/****************************************************
*  find matching printer by name and copy over fields
*  loop through default table, find match and assign.
*****************************************************/
MatchPrinter ()
{
    int     found, done;	/* flags	*/
    int     length;		/* strlen return */
    char    *addr;		/* malloc return */
    int     i, j, k;		/* temp indices	 */
    int yn;                     /* yes - no answer */
    int     gotprinter;         /* true if a printer type is found */

    /****************************
    *  get printer type
    ****************************/
    found = FALSE;
    while (!found)
    {
	done = FALSE;
	while (!done)
	{
           printf ("\nFor more information on the specific printer types\n");
	   printf ("Enter `printer?'\n");
	   printf ("\nEnter the FULL name of one of the following printer types:\n");
		    for (i = 0,j=0; printer[i].name != 0; j++,++i){
			printf ("%s ", printer[i].name);
			if (j > 12){
		    		printf ("\n");
				j=0;
			}
		    }
	    printf ("\nor press RETURN for [unknown] : ");

	    switch (getsymbol ())
	    {
                case PRINTER_INFO:
                     SpecificPrinter();
                     break;
		case GOT_SYMBOL:
		default:
		    strcpy (ptype, symbolname);
		    done = TRUE;
		    break;
		case HELP:
		    PrintHelp (h_type);
		    break;
		case QUIT:
		    return (QUIT);
		    break;
		case NOREPLY:
		    printf ("\nUsing 'unknown' for printer type, OK? [ n ] ");
			yn = 'n';
		    if (YesNo (yn) == TRUE) {
		        done = TRUE;
			strcpy (ptype, UNKNOWN);
		    }
		    break;
	    }
	}

	/****************************************************
	*  loop through printer table, find match   DJG#3
        *  Note: The array  printer[i].name ends with a NULL.
	*****************************************************/

        for (i = 0, gotprinter = 0; printer[i].name; i++) {
		if (strcmp (printer[i].name, ptype) == 0) {
			gotprinter ++;
			break;
		}
	}

	if (!gotprinter)
	{
	    printf ("\nDon't know about printer '%s'\n", ptype);
	    printf ("\nEnter 'y' to try again, or 'n' to use 'unknown' [y]: ");
		yn = 'y';
	    if (YesNo (yn) == FALSE)
	    {
		strcpy (ptype, UNKNOWN);
		found = TRUE;
	    } else {
		found = FALSE;
	    }
	}
	else { /* found a printer type */
	        found = TRUE;
	}
    }

    /**************************************************************
    * loop thru printer values and assign to corresponding
    * default new values - note: `i' contains correct printer index
    **************************************************************/

    for (j = 0; printer[i].entry[j].name; ++j)
    {
	/******************************
	*  loop through default table
	*******************************/

	for (k = 0; tab[k].name; ++k)
	{
	    if (strcmp (printer[i].entry[j].name, tab[k].name) == 0)
	    {
		length = strlen (printer[i].entry[j].svalue) + 1;
		if ((addr = (char *) malloc (length)) == NULL)
		{
		    printf ("\nmalloc: not enough space for symbols!\n");
		    return (ERROR);
		}
		tab[k].nvalue = addr;
		strcpy (tab[k].nvalue, printer[i].entry[j].svalue);
		tab[k].used = YES;
	    }
	}
    }
    return (OK);
}

/********************************************
* get help information on a specific printer
*********************************************/
SpecificPrinter()
{
    int   done;
    int   i, j;


    done = FALSE;

    printf ("\nEntering PRINTER TYPE help information MODE\n");
    printf ("\nEnter the printer type for specific information\n");
    printf ("               Enter '?' for help, 'quit' to exit : ");
    while (!done) {
      switch (getprnttype()) {
         case LA50:
              PrintHelp (h_la50);
              break;
         case LA75:
              PrintHelp (h_la75);
              break;
         case LA100:
              PrintHelp (h_la100);
              break;
         case LA120:
              PrintHelp (h_la120);
              break;
         case LA210:
              PrintHelp (h_la210);
              break;
         case LCG01:
              PrintHelp (h_lcg01);
              break;
         case LG01:
              PrintHelp (h_lg01);
              break;
         case LG02:
              PrintHelp (h_lg02);
              break;
         case LG31:
              PrintHelp (h_lg31);
              break;
         case LJ250:
              PrintHelp (h_lj250);
              break;
         case LN01:
              PrintHelp (h_ln01);
              break;
         case LN01S:
              PrintHelp (h_ln01s);
              break;
         case LN03:
              PrintHelp (h_ln03);
              break;
         case LN03S:
              PrintHelp (h_ln03s);
              break;
         case LN03R:
              PrintHelp (h_ln03r);
              break;
         case LP25:
              PrintHelp (h_lp25);
              break;
         case LP26:
              PrintHelp (h_lp26);
              break;
         case LP27:
              PrintHelp (h_lp27);
              break;
         case LP29:
              PrintHelp (h_lp29);
              break;
         case LQP02:
              PrintHelp (h_lqp02);
              break;
         case LQP03:
              PrintHelp (h_lqp03);
              break;
         case LVP16:
              PrintHelp (h_lvp16);
              break;
	 case PRINTSERVER:
	      PrintHelp (h_printserver);
	      break;
         case REMOTE:
              PrintHelp (h_remote);
              break;
         case NOTKNOWN:
              PrintHelp (h_unknown);
              break;
         case PTHELP:
              PrintHelp (h_printype);
              break;
         case PTQUIT:
              done = TRUE;
              break;
         case NOT_SUPPORTED:
              printf ("\n\nThe printer type %s is NOT SUPPORTED by DIGITAL - No Information\n\n", printertype);
              break;
         case PTNOREPLY:
         default:
              break;
        }
	if (!done) {
       		for (i = 0,j=0; printer[i].name != 0; j++,++i){
	   		printf ("%s ", printer[i].name);
	   		if (j > 12){
		   		printf ("\n");
		   		j=0;
	   		}
       		}
	}
	else {
		printf ("\n\n");
	}
       printf ("  unknown ");
       printf ("\nEnter the printer type for specific information\n");
       printf ("               Enter '?' for help, 'quit' to exit : ");
    }
    printf ("\nLeaving PRINTER TYPE help information MODE\n");
    printf ("\n\nReturning to Selection of Printer Type for ADDING a New Printer\n\n");
}

/*****************************
*  add synonyms
*****************************/
AddSyn ()
{
    int     done, status;

    done = FALSE;
    while (!done && strlen (pname) < BUFLEN)
    {
        printf ("\nEnter printer synonym: ");
	switch (getcmd ())
	{
	    case GOT_SYMBOL:
		status = pgetent (bp, symbolname);
		if (status == -1) {
			badfile(PRINTCAP);
		}
		if (status == 1)
		    printf ("\nSynonym is already in use, try something else.\n");
		else
		    if (strlen (pname) + strlen (symbolname) > (BUFLEN - 1))
			printf ("\nSynonym too long, truncating to %d characters.\n", BUFLEN);
		    else
		    {
			strcat (pname, "|");
			strcat (pname, symbolname);
			if ((strchr (symbolname, '\t') != NULL) || 
                            (strchr (symbolname, ' ') != NULL))    /* Then last synonym */
				return (TRUE);                     /* DJG#8 */
		    }
		break;
	    case HELP:
		PrintHelp (h_synonym);
		break;
	    case QUIT:
		return (TRUE);
		break;
	    case NOREPLY:
		return (TRUE);
		break;
	    default:
		printf ("\nInvalid choice, try again.\n");
		break;
	}
    }
    return(OK);
}

/*********************************
*  set default values
*  Returns -1 on error, 0 if ok
*********************************/
SetVal (val, buf)
char   *val;			/* two-letter symbol	 */
char   *buf;			/* preset value		 */
{
    int     i;			/* temp index		 */
    char    line[LEN];		/* temp buffer		 */

    /******************