[moira.git] / clients / moira / printer.c

#if (!defined(lint) && !defined(SABER))
  static char rcsid_module_c[] = "$Header$";
#endif lint

/*	This is the file printer.c for the MOIRA Client, which allows a nieve
 *      user to quickly and easily maintain most parts of the MOIRA database.
 *	It Contains: Functions for handling the printers.
 *	
 *	Created: 	8/16/88
 *	By:		Theodore Y. Ts'o
 *
 *      $Source$
 *      $Author$
 *      $Header$
 *	
 *  	Copyright 1988 by the Massachusetts Institute of Technology.
 *
 *	For further information on copyright and distribution 
 *	see the file mit-copyright.h
 */

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <moira.h>
#include <moira_site.h>
#include <menu.h>

#include "mit-copyright.h"
#include "defs.h"
#include "f_defs.h"
#include "globals.h"

#define DEFAULT_MACHINE "E40-PRINT-SERVER-1.MIT.EDU"

/*	Function Name: SetDefaults
 *	Description: sets the default values for filesystem additions.
 *	Arguments: info - an array of char pointers to recieve defaults. 
 *	Returns: char ** (this array, now filled).
 */

static char ** 
SetDefaults(info, name)
char ** info;
char * name;
{
    char spool_dir[256];

    strcpy(spool_dir, "/usr/spool/printer/");
    strcat(spool_dir, name);
    
    info[PCAP_NAME] =   	Strsave(name);
    info[PCAP_SPOOL_HOST] =	Strsave(DEFAULT_MACHINE);
    info[PCAP_SPOOL_DIR] =	Strsave(spool_dir);
    info[PCAP_RPRINTER] =	Strsave(name);
    info[PCAP_QSERVER] =	Strsave("\\[NONE\\]");
    info[PCAP_AUTH] =		Strsave("1");
    info[PCAP_PRICE] =		Strsave("10");
    info[PCAP_COMMENTS] = 	Strsave("");
    info[PCAP_MODTIME] = info[PCAP_MODBY] = info[PCAP_MODWITH] = NULL;
    
    info[PCAP_END] = NULL;
    return(info);
}

/*	Function Name: GetPcapInfo
 *	Description: Stores the info in a queue.
 *	Arguments: name - name of the item to get information on.
 *	Returns: a pointer to the first element in the queue or null
 * 		if printer not found.
 */

static struct qelem *
GetPcapInfo(name)
char *name;

{
    int stat;
    struct qelem *elem = NULL;

    if ( (stat = do_mr_query("get_printcap_entry", 1, &name,
			      StoreInfo, (char *)&elem)) != 0) {
	    com_err(program_name, stat, " in GetPcapInfo");
	    return(NULL);
    }
    return(QueueTop(elem));
}

/*	Function Name: PrintPcapInfo
 *	Description: Yet another specialized print function.
 *	Arguments: info - all info about this Printer.
 *	Returns: none
 */

static void
PrintPcapInfo(info)
char ** info;
{
    char buf[BUFSIZ];
    
    if (!info)	{		/* If no informaion */
	    Put_message("PrintPcapInfo called with null info!");
	    return;
    }
    sprintf(buf, "Printer: %-35s Spool host: %s", info[PCAP_NAME],
	    info[PCAP_SPOOL_HOST]);
    Put_message(buf);
    sprintf(buf, "Spool directory: %-27s Remote Printer Name: %s",
	    info[PCAP_SPOOL_DIR], info[PCAP_RPRINTER]);
    Put_message(buf);
    sprintf(buf, "Authentication: %-3s Price/page: %-3s  Quota Server: %s",
	    atoi(info[PCAP_AUTH]) ? "yes" : "no",
	    info[PCAP_PRICE], info[PCAP_QSERVER]);
    Put_message(buf);
    sprintf(buf, "Comments: %s", info[PCAP_COMMENTS]);
    Put_message(buf);
    sprintf(buf, MOD_FORMAT, info[PCAP_MODBY], info[PCAP_MODTIME], 
	    info[PCAP_MODWITH]);
    Put_message(buf);
}

/*	Function Name: AskPcapInfo.
 *	Description: This function askes the user for information about a 
 *                   printer and saves it into a structure.
 *	Arguments: info - a pointer the the structure to put the
 *                             info into.
 *	Returns: none.
 */

static char **
AskPcapInfo(info)
char ** info;
{
    char temp_buf[BUFSIZ];

    Put_message("");
    sprintf(temp_buf, "Printcap entry for %s.", 
	    info[PCAP_NAME]);
    Put_message(temp_buf);
    Put_message("");

    if (GetValueFromUser("Printer Server", &info[PCAP_SPOOL_HOST]) == SUB_ERROR)
      return(NULL);
    info[PCAP_SPOOL_HOST] = canonicalize_hostname(info[PCAP_SPOOL_HOST]);
    if (GetValueFromUser("Spool Directory", &info[PCAP_SPOOL_DIR]) ==
	SUB_ERROR)
      return(NULL);
    if (GetValueFromUser("Remote Printer Name", &info[PCAP_RPRINTER]) ==
	SUB_ERROR)
      return(NULL);
    if (!strcmp(info[PCAP_QSERVER], "[NONE]")) {
	free(info[PCAP_QSERVER]);
	info[PCAP_QSERVER] = strsave("\\[NONE\\]");
    }
    if (GetValueFromUser("Quotaserver for this printer", &info[PCAP_QSERVER]) ==
	SUB_ERROR)
      return(NULL);
    info[PCAP_QSERVER] = canonicalize_hostname(info[PCAP_QSERVER]);
    if (GetYesNoValueFromUser("Authentication required", &info[PCAP_AUTH]) ==
	SUB_ERROR)
      return(NULL);
    if (GetValueFromUser("Price/page", &info[PCAP_PRICE]) == SUB_ERROR)
      return(NULL);
    if (GetValueFromUser("Comments", &info[PCAP_COMMENTS]) == SUB_ERROR)
      return(NULL);
    
    FreeAndClear(&info[PCAP_MODTIME], TRUE);
    FreeAndClear(&info[PCAP_MODBY], TRUE);
    FreeAndClear(&info[PCAP_MODWITH], TRUE);
    
    return(info);
}

/* ---------------- Printer Menu ------------------ */

/*	Function Name: GetPcap
 *	Description: Get Printcap information
 *	Arguments: argc, argv - name of filsys in argv[1].
 *	Returns: DM_NORMAL.
 */

/* ARGSUSED */
int
GetPcap(argc, argv)
int argc;
char **argv;
{
    struct qelem *top;

    top = GetPcapInfo(argv[1]); /* get info. */
    Loop(top, (void *) PrintPcapInfo);
    FreeQueue(top);		/* clean the queue. */
    return (DM_NORMAL);
}

/*	Function Name: RealDeletePcap
 *	Description: Does the real deletion work.
 *	Arguments: info - array of char *'s containing all useful info.
 *                 one_item - a Boolean that is true if only one item 
 *                              in queue that dumped us here.
 *	Returns: none.
 */

void
RealDeletePcap(info, one_item)
char ** info;
Bool one_item;
{
    int stat;

    if ( (stat = do_mr_query("delete_printcap_entry", 1,
			      &info[PCAP_NAME], Scream, NULL)) != 0)
	    com_err(program_name, stat, " printcap entry not deleted.");
    else
	    Put_message("Printcap entry deleted.");
}

/*	Function Name: DeletePcap
 *	Description: Delete a printcap entry given its name.
 *	Arguments: argc, argv - argv[1] is the name of the printer.
 *	Returns: none.
 */

/* ARGSUSED */
 
int
DeletePcap(argc, argv)
int argc;
char **argv;
{
    struct qelem *elem = GetPcapInfo(argv[1]);
    QueryLoop(elem, PrintPcapInfo, RealDeletePcap, "Delete Printer");

    FreeQueue(elem);
    return (DM_NORMAL);
}

/*	Function Name: AddPcap
 *	Description: Add a printcap entry
 *	Arguments: arc, argv - name of printer in argv[1].
 *	Returns: DM_NORMAL.
 */

/* ARGSUSED */
int
AddPcap(argc, argv)
char **argv;
int argc;
{
    char *info[MAX_ARGS_SIZE], **args;
    int stat;

    if ( !ValidName(argv[1]) )
	return(DM_NORMAL);

    if ( (stat = do_mr_query("get_printcap_entry", 1, argv + 1,
			      NullFunc, NULL)) == 0) {
	Put_message ("A Printer by that name already exists.");
	return(DM_NORMAL);
    } else if (stat != MR_NO_MATCH) {
	com_err(program_name, stat, " in AddPcap");
	return(DM_NORMAL);
    } 

    args = AskPcapInfo(SetDefaults(info, argv[1]));
    if (args == NULL) {
	Put_message("Aborted.");
	return(DM_NORMAL);
    }

    if ( (stat = do_mr_query("add_printcap_entry", CountArgs(args), args, 
			      NullFunc, NULL)) != 0)
	com_err(program_name, stat, " in AddPcap");

    FreeInfo(info);
    return (DM_NORMAL);
}


/*	Function Name: ChangePcap
 *	Description: Do the work of changing a pcap
 *	Arguments: argc, argv - printcap info
 *	Returns: 
 */

int
ChangePcap(info, one_item)
char **info;
Bool one_item;
{
    int stat;
    char **oldinfo;

    oldinfo = CopyInfo(info);
    if (AskPcapInfo(info) == NULL)
      return(DM_QUIT);
    if ((stat = do_mr_query("delete_printcap_entry", 1, &info[PCAP_NAME],
			     Scream, NULL)) != 0) {
	com_err(program_name, stat, " printcap entry not deleted.");
	return(DM_NORMAL);
    }
    if ((stat = do_mr_query("add_printcap_entry", CountArgs(info), info,
			     NullFunc, NULL)) != 0) {
	com_err(program_name, stat, " in ChngPcap");
	if ((stat = do_mr_query("add_printcap_entry", CountArgs(oldinfo) - 3,
				oldinfo, NullFunc, NULL)) != 0)
	  com_err(program_name, stat, " while attempting to put old info back");
    }
    FreeInfo(oldinfo);
    return(DM_NORMAL);
}


/*	Function Name: ChngPcap
 *	Description:   Update the printcap information
 *	Arguments:     argc, argv - name of printer in argv[1].
 *	Returns:       DM_NORMAL.
 */

int
ChngPcap(argc, argv)
    int argc;
    char **argv;
{
    struct qelem *elem = GetPcapInfo(argv[1]);
    QueryLoop(elem, NullPrint, ChangePcap, "Change the printer");
    FreeQueue(elem);
    return(DM_NORMAL);
}


/*	Function Name: SetPdDefaults
 *	Description: sets the default values for palladium additions.
 *	Arguments: info - an array of char pointers to recieve defaults. 
 *	Returns: char ** (this array, now filled).
 */

static char ** 
SetPdDefaults(info, name)
char ** info;
char * name;
{
    info[PD_NAME] =		Strsave(name);
    info[PD_IDENT] =		Strsave("10000");
    info[PD_HOST] =		Strsave(DEFAULT_MACHINE);
    info[PD_MODTIME] = info[PD_MODBY] = info[PD_MODWITH] = NULL;

    info[PD_END] = NULL;
    return(info);
}

/*	Function Name: AskPalladiumInfo.
 *	Description: This function askes the user for information about a 
 *                   printer and saves it into a structure.
 *	Arguments: info - a pointer the the structure to put the
 *                             info into.
 *	Returns: none.
 */

static char **
AskPalladiumInfo(info)
char ** info;
{
    char temp_buf[BUFSIZ];

    Put_message("");
    sprintf(temp_buf, "Palladium Server/Supervisor entry for %s.", 
	    info[PD_NAME]);
    Put_message(temp_buf);
    Put_message("");

    if (GetValueFromUser("RPC Program Number", &info[PD_IDENT]) == SUB_ERROR)
      return(NULL);
    if (GetValueFromUser("Print Server/Supervisor Host", &info[PD_HOST]) ==
	SUB_ERROR)
      return(NULL);
    info[PD_HOST] = canonicalize_hostname(info[PD_HOST]);
    
    FreeAndClear(&info[PD_MODTIME], TRUE);
    FreeAndClear(&info[PD_MODBY], TRUE);
    FreeAndClear(&info[PD_MODWITH], TRUE);
    
    return(info);
}


/*	Function Name: PrintPalladiumInfo
 *	Description: Yet another specialized print function.
 *	Arguments: info - all info about this Printer.
 *	Returns: none
 */

static void
PrintPalladiumInfo(info)
char ** info;
{
    char buf[BUFSIZ];
    
    if (!info)	{		/* If no informaion */
	    Put_message("PrintPalladiumInfo called with null info!");
	    return;
    }

    sprintf(buf, "Name: %-24s Program #: %s  Host: %s",
	    info[PD_NAME], info[PD_IDENT], info[PD_HOST]);
    Put_message(buf);
    sprintf(buf, MOD_FORMAT, info[PD_MODBY], info[PD_MODTIME],
	    info[PD_MODWITH]);
    Put_message(buf);
}


static struct qelem *
GetPalladiumInfo(name)
char *name;
{
    int status;
    struct qelem *elem = NULL;

    if ((status = do_mr_query("get_palladium", 1, &name, StoreInfo, &elem))
	!= 0) {
	com_err(program_name, status, " in GetPalladiumInfo");
	return(NULL);
    }
    return(QueueTop(elem));
}


int ChangePalladium(info, one_item)
char **info;
Bool one_item;
{
    int status;

    if (AskPalladiumInfo(info) == NULL)
      return(DM_QUIT);
    if ((status = do_mr_query("delete_palladium", 1, &info[PD_NAME],
			       Scream, NULL)) != 0) {
	com_err(program_name, status, " palladium entry not deleted.");
	return(DM_NORMAL);
    }
    if ((status = do_mr_query("add_palladium", CountArgs(info), info,
			       NullFunc, NULL)) != 0)
      com_err(program_name, status, " in ChngPalladium");
    return(DM_NORMAL);
}


/*	Function Name: RealDeletePalladium
 *	Description: Does the real deletion work.
 *	Arguments: info - array of char *'s containing all useful info.
 *                 one_item - a Boolean that is true if only one item 
 *                              in queue that dumped us here.
 *	Returns: none.
 */

void
RealDeletePalladium(info, one_item)
char ** info;
Bool one_item;
{
    int stat;

    if ( (stat = do_mr_query("delete_palladium", 1,
			      &info[PD_NAME], Scream, NULL)) != 0)
	    com_err(program_name, stat, " palladium entry not deleted.");
    else
	    Put_message("Palladium entry deleted.");
}


int GetPalladium(argc, argv)
int argc;
char **argv;
{
    struct qelem *top;

    top = GetPalladiumInfo(argv[1]);
    Loop(top, PrintPalladiumInfo);
    FreeQueue(top);
    return(DM_NORMAL);
}


int AddPalladium(argc, argv)
int argc;
char **argv;
{
    char *info[MAX_ARGS_SIZE], **args;
    int status;

    if (!ValidName(argv[1]))
      return(DM_NORMAL);

    if ((status = do_mr_query("get_palladium", 1, &argv[1], NullFunc, NULL))
	== 0) {
	Put_message("A server or supervisor by that name already exists.");
	return(DM_NORMAL);
    } else if (status != MR_NO_MATCH) {
	com_err(program_name, status, " in AddPalladium");
	return(DM_NORMAL);
    }

    args = AskPalladiumInfo(SetPdDefaults(info, argv[1]));
    if (args == NULL) {
	Put_message("Aborted.");
	return(DM_NORMAL);
    }

    if ((status = do_mr_query("add_palladium", CountArgs(args), args,
			       Scream, NULL)) != 0)
      com_err(program_name, status, " in AddPalladium");

    FreeInfo(info);
    return(DM_NORMAL);
}


int ChngPalladium(argc, argv)
int argc;
char **argv;
{
    struct qelem *elem = GetPalladiumInfo(argv[1]);
    QueryLoop(elem, NullPrint, ChangePalladium, "Change the server/supervisor");
    FreeQueue(elem);
    return(DM_NORMAL);
}


int DeletePalladium(argc, argv)
int argc;
char **argv;
{
    struct qelem *elem = GetPalladiumInfo(argv[1]);
    QueryLoop(elem, PrintPalladiumInfo, RealDeletePalladium, "Delete server/supervisor");
    FreeQueue(elem);
    return(DM_NORMAL);
}

int ShowPalladiumAlias(argc, argv)
int argc;
char **argv;
{
    struct qelem *elem = NULL;
    char *qargv[3], buf[BUFSIZ];
    int status;

    qargv[0] = argv[1];
    qargv[1] = "PALLADIUM";
    qargv[2] = argv[2];
    if ((status = do_mr_query("get_alias", 3, qargv, StoreInfo, &elem)) != 0) {
	com_err(program_name, status, " in ShowPalladiumAlias");
	return(DM_NORMAL);
    }
    elem = QueueTop(elem);
    Put_message("");
    while (elem != NULL) {
	char **info = (char **) elem->q_data;
	sprintf(buf, "Printer: %-16s Server/Supervisor: %s", info[0], info[2]);
	Put_message(buf);
	elem = elem->q_forw;
    }

    FreeQueue(QueueTop(elem));
    return(DM_NORMAL);
}

int AddPalladiumAlias(argc, argv)
int argc;
char **argv;
{
    int status;
    char *qargv[3];

    qargv[0] = argv[1];
    qargv[1] = "PALLADIUM";
    qargv[2] = argv[2];
    if ((status = do_mr_query("add_alias", 3, qargv, Scream, NULL)) != 0)
      com_err(program_name, status, " in AddPalladiumAlias");
    return(DM_NORMAL);
}

int DeletePalladiumAlias(argc, argv)
int argc;
char **argv;
{
    int status;
    char *qargv[3];

    qargv[0] = argv[1];
    qargv[1] = "PALLADIUM";
    qargv[2] = argv[2];
    if ((status = do_mr_query("delete_alias", 3, qargv, Scream, NULL)) != 0)
      com_err(program_name, status, " in DeletePalladiumAlias");
    return(DM_NORMAL);
}
Commit	Line	Data
cc5b487a	1	#if (!defined(lint) && !defined(SABER))
	2	static char rcsid_module_c[] = "$Header$";
	3	#endif lint
	4
8defc06b	5	/* This is the file printer.c for the MOIRA Client, which allows a nieve
8defc06b	6	* user to quickly and easily maintain most parts of the MOIRA database.
cc5b487a	7	* It Contains: Functions for handling the printers.
	8	*
	9	* Created: 8/16/88
	10	* By: Theodore Y. Ts'o
	11	*
	12	* $Source$
	13	* $Author$
	14	* $Header$
	15	*
	16	* Copyright 1988 by the Massachusetts Institute of Technology.
	17	*
	18	* For further information on copyright and distribution
	19	* see the file mit-copyright.h
	20	*/
	21
	22	#include <stdio.h>
24419c79	23	#include <string.h>
cc5b487a	24	#include <ctype.h>
8defc06b	25	#include <moira.h>
8defc06b	26	#include <moira_site.h>
cc5b487a	27	#include <menu.h>
	28
	29	#include "mit-copyright.h"
	30	#include "defs.h"
	31	#include "f_defs.h"
	32	#include "globals.h"
cc5b487a	33
cc5b487a	34	#define DEFAULT_MACHINE "E40-PRINT-SERVER-1.MIT.EDU"
	35
	36	/* Function Name: SetDefaults
	37	* Description: sets the default values for filesystem additions.
	38	* Arguments: info - an array of char pointers to recieve defaults.
	39	* Returns: char ** (this array, now filled).
	40	*/
	41
	42	static char **
	43	SetDefaults(info, name)
	44	char ** info;
	45	char * name;
	46	{
	47	char spool_dir[256];
	48
	49	strcpy(spool_dir, "/usr/spool/printer/");
	50	strcat(spool_dir, name);
	51
	52	info[PCAP_NAME] = Strsave(name);
	53	info[PCAP_SPOOL_HOST] = Strsave(DEFAULT_MACHINE);
	54	info[PCAP_SPOOL_DIR] = Strsave(spool_dir);
	55	info[PCAP_RPRINTER] = Strsave(name);
dd233c2d	56	info[PCAP_QSERVER] = Strsave("\\[NONE\\]");
	57	info[PCAP_AUTH] = Strsave("1");
	58	info[PCAP_PRICE] = Strsave("10");
cc5b487a	59	info[PCAP_COMMENTS] = Strsave("");
	60	info[PCAP_MODTIME] = info[PCAP_MODBY] = info[PCAP_MODWITH] = NULL;
	61
	62	info[PCAP_END] = NULL;
	63	return(info);
	64	}
	65
	66	/* Function Name: GetPcapInfo
	67	* Description: Stores the info in a queue.
	68	* Arguments: name - name of the item to get information on.
	69	* Returns: a pointer to the first element in the queue or null
	70	* if printer not found.
	71	*/
	72
	73	static struct qelem *
	74	GetPcapInfo(name)
	75	char *name;
	76
	77	{
	78	int stat;
	79	struct qelem *elem = NULL;
	80
dd233c2d	81	if ( (stat = do_mr_query("get_printcap_entry", 1, &name,
14f99d7d	82	StoreInfo, (char *)&elem)) != 0) {
b98304a9	83	com_err(program_name, stat, " in GetPcapInfo");
cc5b487a	84	return(NULL);
	85	}
	86	return(QueueTop(elem));
	87	}
	88
	89	/* Function Name: PrintPcapInfo
	90	* Description: Yet another specialized print function.
	91	* Arguments: info - all info about this Printer.
	92	* Returns: none
	93	*/
	94
	95	static void
	96	PrintPcapInfo(info)
	97	char ** info;
	98	{
	99	char buf[BUFSIZ];
	100
	101	if (!info) { /* If no informaion */
	102	Put_message("PrintPcapInfo called with null info!");
	103	return;
	104	}
	105	sprintf(buf, "Printer: %-35s Spool host: %s", info[PCAP_NAME],
	106	info[PCAP_SPOOL_HOST]);
	107	Put_message(buf);
	108	sprintf(buf, "Spool directory: %-27s Remote Printer Name: %s",
	109	info[PCAP_SPOOL_DIR], info[PCAP_RPRINTER]);
	110	Put_message(buf);
dd233c2d	111	sprintf(buf, "Authentication: %-3s Price/page: %-3s Quota Server: %s",
	112	atoi(info[PCAP_AUTH]) ? "yes" : "no",
	113	info[PCAP_PRICE], info[PCAP_QSERVER]);
	114	Put_message(buf);
b7fbb301	115	sprintf(buf, "Comments: %s", info[PCAP_COMMENTS]);
cc5b487a	116	Put_message(buf);
	117	sprintf(buf, MOD_FORMAT, info[PCAP_MODBY], info[PCAP_MODTIME],
	118	info[PCAP_MODWITH]);
	119	Put_message(buf);
	120	}
	121
	122	/* Function Name: AskPcapInfo.
	123	* Description: This function askes the user for information about a
	124	* printer and saves it into a structure.
	125	* Arguments: info - a pointer the the structure to put the
	126	* info into.
	127	* Returns: none.
	128	*/
	129
	130	static char **
	131	AskPcapInfo(info)
	132	char ** info;
	133	{
7b53f00f	134	char temp_buf[BUFSIZ];
cc5b487a	135
	136	Put_message("");
	137	sprintf(temp_buf, "Printcap entry for %s.",
1b2e1580	138	info[PCAP_NAME]);
cc5b487a	139	Put_message(temp_buf);
	140	Put_message("");
	141
b7fbb301	142	if (GetValueFromUser("Printer Server", &info[PCAP_SPOOL_HOST]) == SUB_ERROR)
b7fbb301	143	return(NULL);
2aaf43e0	144	info[PCAP_SPOOL_HOST] = canonicalize_hostname(info[PCAP_SPOOL_HOST]);
b7fbb301	145	if (GetValueFromUser("Spool Directory", &info[PCAP_SPOOL_DIR]) ==
	146	SUB_ERROR)
	147	return(NULL);
	148	if (GetValueFromUser("Remote Printer Name", &info[PCAP_RPRINTER]) ==
	149	SUB_ERROR)
	150	return(NULL);
dd233c2d	151	if (!strcmp(info[PCAP_QSERVER], "[NONE]")) {
	152	free(info[PCAP_QSERVER]);
	153	info[PCAP_QSERVER] = strsave("\\[NONE\\]");
	154	}
b7fbb301	155	if (GetValueFromUser("Quotaserver for this printer", &info[PCAP_QSERVER]) ==
	156	SUB_ERROR)
	157	return(NULL);
dd233c2d	158	info[PCAP_QSERVER] = canonicalize_hostname(info[PCAP_QSERVER]);
b7fbb301	159	if (GetYesNoValueFromUser("Authentication required", &info[PCAP_AUTH]) ==
	160	SUB_ERROR)
	161	return(NULL);
	162	if (GetValueFromUser("Price/page", &info[PCAP_PRICE]) == SUB_ERROR)
	163	return(NULL);
	164	if (GetValueFromUser("Comments", &info[PCAP_COMMENTS]) == SUB_ERROR)
	165	return(NULL);
cc5b487a	166
	167	FreeAndClear(&info[PCAP_MODTIME], TRUE);
	168	FreeAndClear(&info[PCAP_MODBY], TRUE);
	169	FreeAndClear(&info[PCAP_MODWITH], TRUE);
	170
	171	return(info);
	172	}
	173
	174	/* ---------------- Printer Menu ------------------ */
	175
	176	/* Function Name: GetPcap
	177	* Description: Get Printcap information
	178	* Arguments: argc, argv - name of filsys in argv[1].
	179	* Returns: DM_NORMAL.
	180	*/
	181
	182	/* ARGSUSED */
	183	int
	184	GetPcap(argc, argv)
	185	int argc;
	186	char **argv;
	187	{
	188	struct qelem *top;
	189
	190	top = GetPcapInfo(argv[1]); /* get info. */
	191	Loop(top, (void *) PrintPcapInfo);
	192	FreeQueue(top); /* clean the queue. */
	193	return (DM_NORMAL);
	194	}
	195
	196	/* Function Name: RealDeletePcap
	197	* Description: Does the real deletion work.
	198	* Arguments: info - array of char *'s containing all useful info.
	199	* one_item - a Boolean that is true if only one item
	200	* in queue that dumped us here.
	201	* Returns: none.
	202	*/
	203
	204	void
	205	RealDeletePcap(info, one_item)
	206	char ** info;
	207	Bool one_item;
	208	{
	209	int stat;
cc5b487a	210
dd233c2d	211	if ( (stat = do_mr_query("delete_printcap_entry", 1,
1b2e1580	212	&info[PCAP_NAME], Scream, NULL)) != 0)
cc5b487a	213	com_err(program_name, stat, " printcap entry not deleted.");
	214	else
	215	Put_message("Printcap entry deleted.");
	216	}
	217
	218	/* Function Name: DeletePcap
	219	* Description: Delete a printcap entry given its name.
	220	* Arguments: argc, argv - argv[1] is the name of the printer.
	221	* Returns: none.
	222	*/
	223
	224	/* ARGSUSED */
	225
	226	int
	227	DeletePcap(argc, argv)
	228	int argc;
	229	char **argv;
	230	{
	231	struct qelem *elem = GetPcapInfo(argv[1]);
	232	QueryLoop(elem, PrintPcapInfo, RealDeletePcap, "Delete Printer");
	233
	234	FreeQueue(elem);
	235	return (DM_NORMAL);
	236	}
	237
	238	/* Function Name: AddPcap
	239	* Description: Add a printcap entry
	240	* Arguments: arc, argv - name of printer in argv[1].
	241	* Returns: DM_NORMAL.
	242	*/
	243
	244	/* ARGSUSED */
	245	int
	246	AddPcap(argc, argv)
	247	char **argv;
	248	int argc;
	249	{
	250	char info[MAX_ARGS_SIZE], *args;
	251	int stat;
	252
	253	if ( !ValidName(argv[1]) )
	254	return(DM_NORMAL);
	255
dd233c2d	256	if ( (stat = do_mr_query("get_printcap_entry", 1, argv + 1,
14f99d7d	257	NullFunc, NULL)) == 0) {
cc5b487a	258	Put_message ("A Printer by that name already exists.");
cc5b487a	259	return(DM_NORMAL);
8defc06b	260	} else if (stat != MR_NO_MATCH) {
cc5b487a	261	com_err(program_name, stat, " in AddPcap");
	262	return(DM_NORMAL);
	263	}
	264
	265	args = AskPcapInfo(SetDefaults(info, argv[1]));
b7fbb301	266	if (args == NULL) {
	267	Put_message("Aborted.");
	268	return(DM_NORMAL);
	269	}
cc5b487a	270
dd233c2d	271	if ( (stat = do_mr_query("add_printcap_entry", CountArgs(args), args,
14f99d7d	272	NullFunc, NULL)) != 0)
cc5b487a	273	com_err(program_name, stat, " in AddPcap");
	274
	275	FreeInfo(info);
	276	return (DM_NORMAL);
	277	}
	278
	279
f03f1f1b	280	/* Function Name: ChangePcap
	281	* Description: Do the work of changing a pcap
	282	* Arguments: argc, argv - printcap info
	283	* Returns:
	284	*/
	285
	286	int
	287	ChangePcap(info, one_item)
	288	char **info;
	289	Bool one_item;
	290	{
	291	int stat;
b98304a9	292	char **oldinfo;
f03f1f1b	293
b98304a9	294	oldinfo = CopyInfo(info);
b7fbb301	295	if (AskPcapInfo(info) == NULL)
b7fbb301	296	return(DM_QUIT);
dd233c2d	297	if ((stat = do_mr_query("delete_printcap_entry", 1, &info[PCAP_NAME],
14f99d7d	298	Scream, NULL)) != 0) {
f03f1f1b	299	com_err(program_name, stat, " printcap entry not deleted.");
	300	return(DM_NORMAL);
	301	}
dd233c2d	302	if ((stat = do_mr_query("add_printcap_entry", CountArgs(info), info,
b98304a9	303	NullFunc, NULL)) != 0) {
f03f1f1b	304	com_err(program_name, stat, " in ChngPcap");
b98304a9	305	if ((stat = do_mr_query("add_printcap_entry", CountArgs(oldinfo) - 3,
	306	oldinfo, NullFunc, NULL)) != 0)
	307	com_err(program_name, stat, " while attempting to put old info back");
	308	}
	309	FreeInfo(oldinfo);
f03f1f1b	310	return(DM_NORMAL);
	311	}
	312
	313
	314	/* Function Name: ChngPcap
	315	* Description: Update the printcap information
	316	* Arguments: argc, argv - name of printer in argv[1].
	317	* Returns: DM_NORMAL.
	318	*/
	319
	320	int
	321	ChngPcap(argc, argv)
	322	int argc;
	323	char **argv;
	324	{
	325	struct qelem *elem = GetPcapInfo(argv[1]);
	326	QueryLoop(elem, NullPrint, ChangePcap, "Change the printer");
	327	FreeQueue(elem);
	328	return(DM_NORMAL);
	329	}
1b2e1580	330
	331
	332	/* Function Name: SetPdDefaults
	333	* Description: sets the default values for palladium additions.
	334	* Arguments: info - an array of char pointers to recieve defaults.
	335	* Returns: char ** (this array, now filled).
	336	*/
	337
	338	static char **
	339	SetPdDefaults(info, name)
	340	char ** info;
	341	char * name;
	342	{
	343	info[PD_NAME] = Strsave(name);
24decb93	344	info[PD_IDENT] = Strsave("10000");
1b2e1580	345	info[PD_HOST] = Strsave(DEFAULT_MACHINE);
	346	info[PD_MODTIME] = info[PD_MODBY] = info[PD_MODWITH] = NULL;
	347
	348	info[PD_END] = NULL;
	349	return(info);
	350	}
	351
	352	/* Function Name: AskPalladiumInfo.
	353	* Description: This function askes the user for information about a
	354	* printer and saves it into a structure.
	355	* Arguments: info - a pointer the the structure to put the
	356	* info into.
	357	* Returns: none.
	358	*/
	359
	360	static char **
	361	AskPalladiumInfo(info)
	362	char ** info;
	363	{
7b53f00f	364	char temp_buf[BUFSIZ];
1b2e1580	365
1b2e1580	366	Put_message("");
24decb93	367	sprintf(temp_buf, "Palladium Server/Supervisor entry for %s.",
1b2e1580	368	info[PD_NAME]);
	369	Put_message(temp_buf);
	370	Put_message("");
	371
b7fbb301	372	if (GetValueFromUser("RPC Program Number", &info[PD_IDENT]) == SUB_ERROR)
	373	return(NULL);
	374	if (GetValueFromUser("Print Server/Supervisor Host", &info[PD_HOST]) ==
	375	SUB_ERROR)
	376	return(NULL);
1b2e1580	377	info[PD_HOST] = canonicalize_hostname(info[PD_HOST]);
	378
	379	FreeAndClear(&info[PD_MODTIME], TRUE);
	380	FreeAndClear(&info[PD_MODBY], TRUE);
	381	FreeAndClear(&info[PD_MODWITH], TRUE);
	382
	383	return(info);
	384	}
	385
	386
	387	/* Function Name: PrintPalladiumInfo
	388	* Description: Yet another specialized print function.
	389	* Arguments: info - all info about this Printer.
	390	* Returns: none
	391	*/
	392
	393	static void
	394	PrintPalladiumInfo(info)
	395	char ** info;
	396	{
	397	char buf[BUFSIZ];
	398
	399	if (!info) { /* If no informaion */
	400	Put_message("PrintPalladiumInfo called with null info!");
	401	return;
	402	}
	403
24decb93	404	sprintf(buf, "Name: %-24s Program #: %s Host: %s",
1b2e1580	405	info[PD_NAME], info[PD_IDENT], info[PD_HOST]);
	406	Put_message(buf);
	407	sprintf(buf, MOD_FORMAT, info[PD_MODBY], info[PD_MODTIME],
	408	info[PD_MODWITH]);
	409	Put_message(buf);
	410	}
	411
	412
	413	static struct qelem *
	414	GetPalladiumInfo(name)
	415	char *name;
	416	{
	417	int status;
	418	struct qelem *elem = NULL;
	419
8defc06b	420	if ((status = do_mr_query("get_palladium", 1, &name, StoreInfo, &elem))
1b2e1580	421	!= 0) {
b98304a9	422	com_err(program_name, status, " in GetPalladiumInfo");
1b2e1580	423	return(NULL);
	424	}
	425	return(QueueTop(elem));
	426	}
	427
	428
	429	int ChangePalladium(info, one_item)
	430	char **info;
	431	Bool one_item;
	432	{
	433	int status;
	434
b7fbb301	435	if (AskPalladiumInfo(info) == NULL)
b7fbb301	436	return(DM_QUIT);
8defc06b	437	if ((status = do_mr_query("delete_palladium", 1, &info[PD_NAME],
1b2e1580	438	Scream, NULL)) != 0) {
	439	com_err(program_name, status, " palladium entry not deleted.");
	440	return(DM_NORMAL);
	441	}
8defc06b	442	if ((status = do_mr_query("add_palladium", CountArgs(info), info,
1b2e1580	443	NullFunc, NULL)) != 0)
	444	com_err(program_name, status, " in ChngPalladium");
	445	return(DM_NORMAL);
	446	}
	447
	448
	449	/* Function Name: RealDeletePalladium
	450	* Description: Does the real deletion work.
	451	* Arguments: info - array of char *'s containing all useful info.
	452	* one_item - a Boolean that is true if only one item
	453	* in queue that dumped us here.
	454	* Returns: none.
	455	*/
	456
	457	void
	458	RealDeletePalladium(info, one_item)
	459	char ** info;
	460	Bool one_item;
	461	{
	462	int stat;
1b2e1580	463
8defc06b	464	if ( (stat = do_mr_query("delete_palladium", 1,
1b2e1580	465	&info[PD_NAME], Scream, NULL)) != 0)
	466	com_err(program_name, stat, " palladium entry not deleted.");
	467	else
	468	Put_message("Palladium entry deleted.");
	469	}
	470
	471
	472	int GetPalladium(argc, argv)
	473	int argc;
	474	char **argv;
	475	{
7b53f00f	476	struct qelem *top;
1b2e1580	477
	478	top = GetPalladiumInfo(argv[1]);
	479	Loop(top, PrintPalladiumInfo);
	480	FreeQueue(top);
	481	return(DM_NORMAL);
	482	}
	483
	484
	485	int AddPalladium(argc, argv)
	486	int argc;
	487	char **argv;
	488	{
	489	char info[MAX_ARGS_SIZE], *args;
	490	int status;
	491
	492	if (!ValidName(argv[1]))
	493	return(DM_NORMAL);
	494
8defc06b	495	if ((status = do_mr_query("get_palladium", 1, &argv[1], NullFunc, NULL))
1b2e1580	496	== 0) {
24decb93	497	Put_message("A server or supervisor by that name already exists.");
1b2e1580	498	return(DM_NORMAL);
8defc06b	499	} else if (status != MR_NO_MATCH) {
1b2e1580	500	com_err(program_name, status, " in AddPalladium");
	501	return(DM_NORMAL);
	502	}
	503
	504	args = AskPalladiumInfo(SetPdDefaults(info, argv[1]));
b7fbb301	505	if (args == NULL) {
	506	Put_message("Aborted.");
	507	return(DM_NORMAL);
	508	}
1b2e1580	509
8defc06b	510	if ((status = do_mr_query("add_palladium", CountArgs(args), args,
1b2e1580	511	Scream, NULL)) != 0)
	512	com_err(program_name, status, " in AddPalladium");
	513
	514	FreeInfo(info);
	515	return(DM_NORMAL);
	516	}
	517
	518
	519	int ChngPalladium(argc, argv)
	520	int argc;
	521	char **argv;
	522	{
	523	struct qelem *elem = GetPalladiumInfo(argv[1]);
24decb93	524	QueryLoop(elem, NullPrint, ChangePalladium, "Change the server/supervisor");
1b2e1580	525	FreeQueue(elem);
	526	return(DM_NORMAL);
	527	}
	528
	529
	530	int DeletePalladium(argc, argv)
	531	int argc;
	532	char **argv;
	533	{
	534	struct qelem *elem = GetPalladiumInfo(argv[1]);
24decb93	535	QueryLoop(elem, PrintPalladiumInfo, RealDeletePalladium, "Delete server/supervisor");
1b2e1580	536	FreeQueue(elem);
	537	return(DM_NORMAL);
	538	}
	539
	540	int ShowPalladiumAlias(argc, argv)
	541	int argc;
	542	char **argv;
	543	{
	544	struct qelem *elem = NULL;
	545	char *qargv[3], buf[BUFSIZ];
	546	int status;
	547
	548	qargv[0] = argv[1];
	549	qargv[1] = "PALLADIUM";
	550	qargv[2] = argv[2];
8defc06b	551	if ((status = do_mr_query("get_alias", 3, qargv, StoreInfo, &elem)) != 0) {
1b2e1580	552	com_err(program_name, status, " in ShowPalladiumAlias");
	553	return(DM_NORMAL);
	554	}
	555	elem = QueueTop(elem);
	556	Put_message("");
	557	while (elem != NULL) {
	558	char info = (char ) elem->q_data;
24decb93	559	sprintf(buf, "Printer: %-16s Server/Supervisor: %s", info[0], info[2]);
1b2e1580	560	Put_message(buf);
	561	elem = elem->q_forw;
	562	}
	563
	564	FreeQueue(QueueTop(elem));
	565	return(DM_NORMAL);
	566	}
	567
	568	int AddPalladiumAlias(argc, argv)
	569	int argc;
	570	char **argv;
	571	{
	572	int status;
	573	char *qargv[3];
	574
	575	qargv[0] = argv[1];
	576	qargv[1] = "PALLADIUM";
	577	qargv[2] = argv[2];
8defc06b	578	if ((status = do_mr_query("add_alias", 3, qargv, Scream, NULL)) != 0)
1b2e1580	579	com_err(program_name, status, " in AddPalladiumAlias");
	580	return(DM_NORMAL);
	581	}
	582
	583	int DeletePalladiumAlias(argc, argv)
	584	int argc;
	585	char **argv;
	586	{
	587	int status;
	588	char *qargv[3];
	589
	590	qargv[0] = argv[1];
	591	qargv[1] = "PALLADIUM";
	592	qargv[2] = argv[2];
8defc06b	593	if ((status = do_mr_query("delete_alias", 3, qargv, Scream, NULL)) != 0)
1b2e1580	594	com_err(program_name, status, " in DeletePalladiumAlias");
	595	return(DM_NORMAL);
	596	}