[moira.git] / server / qvalidate.dc

/*
 *	$Source$
 *	$Author$
 *	$Header$
 *
 *	Copyright (C) 1987 by the Massachusetts Institute of Technology
 *	For copying and distribution information, please see the file
 *	<mit-copyright.h>.
 *
 */

#ifndef lint
static char *rcsid_qsupport_dc = "$Header$";
#endif lint

#include <mit-copyright.h>
#include <unistd.h>
#include "query.h"
#include "mr_server.h"
#include <ctype.h>
EXEC SQL INCLUDE sqlca;
EXEC SQL INCLUDE sqlda;
#include "qrtn.h"

extern char *whoami;
extern int ingres_errno, mr_errcode;

EXEC SQL BEGIN DECLARE SECTION;
extern char stmt_buf[];
EXEC SQL END DECLARE SECTION;

EXEC SQL WHENEVER SQLERROR CALL ingerr;


/* Validation Routines */

validate_row(q, argv, v)
    register struct query *q;
    char *argv[];
    register struct validate *v;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name;
    char qual[128];
    int rowcount;
    EXEC SQL END DECLARE SECTION;

    /* build where clause */
    build_qual(v->qual, v->argc, argv, qual);

    if (log_flags & LOG_VALID)
	/* tell the logfile what we're doing */
	com_err(whoami, 0, "validating row: %s", qual);

    /* look for the record */
    sprintf(stmt_buf,"SELECT COUNT (*) FROM %s WHERE %s",q->rtable,qual);
    EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
    if(sqlca.sqlcode)
      return(MR_INTERNAL);
    EXEC SQL DECLARE csr126 CURSOR FOR stmt;
    EXEC SQL OPEN csr126;
    EXEC SQL FETCH csr126 USING DESCRIPTOR :SQLDA;
    EXEC SQL CLOSE csr126;
    rowcount = *(int *)SQLDA->sqlvar[0].sqldata;

    if (ingres_errno) return(mr_errcode);
    if (rowcount == 0) return(MR_NO_MATCH);
    if (rowcount > 1) return(MR_NOT_UNIQUE);
    return(MR_EXISTS);
}

validate_fields(q, argv, vo, n)
    struct query *q;
    register char *argv[];
    register struct valobj *vo;
    register int n;
{
    register int status;

    while (--n >= 0) {
	switch (vo->type) {
	case V_NAME:
	    if (log_flags & LOG_VALID)
		com_err(whoami, 0, "validating %s in %s: %s",
		    vo->namefield, vo->table, argv[vo->index]);
	    status = validate_name(argv, vo);
	    break;

	case V_ID:
	    if (log_flags & LOG_VALID)
		com_err(whoami, 0, "validating %s in %s: %s",
		    vo->idfield, vo->table, argv[vo->index]);
	    status = validate_id(q, argv, vo);
	    break;

	case V_DATE:
	    if (log_flags & LOG_VALID)
		com_err(whoami, 0, "validating date: %s", argv[vo->index]);
	    status = validate_date(argv, vo);
	    break;

	case V_TYPE:
	    if (log_flags & LOG_VALID)
		com_err(whoami, 0, "validating %s type: %s",
		    vo->table, argv[vo->index]);
	    status = validate_type(argv, vo);
	    break;

	case V_TYPEDATA:
	    if (log_flags & LOG_VALID)
		com_err(whoami, 0, "validating typed data (%s): %s",
		    argv[vo->index - 1], argv[vo->index]);
	    status = validate_typedata(q, argv, vo);
	    break;

	case V_RENAME:
	    if (log_flags & LOG_VALID)
	        com_err(whoami, 0, "validating rename %s in %s",
			argv[vo->index], vo->table);
	    status = validate_rename(argv, vo);
	    break;

	case V_CHAR:
	    if (log_flags & LOG_VALID)
	      com_err(whoami, 0, "validating chars: %s", argv[vo->index]);
	    status = validate_chars(argv[vo->index]);
	    break;

	case V_SORT:
	    status = MR_EXISTS;
	    break;

	case V_LOCK:
	    status = lock_table(vo);
	    break;

	case V_WILD:
	    status = convert_wildcards(argv[vo->index]);
	    break;

	case V_UPWILD:
	    status = convert_wildcards_uppercase(argv[vo->index]);
	    break;

	}

	if (status != MR_EXISTS) return(status);
	vo++;
    }

    if (ingres_errno) return(mr_errcode);
    return(MR_SUCCESS);
}


/* validate_chars: verify that there are no illegal characters in
 * the string.  Legal characters are printing chars other than
 * ", *, ?, \, [ and ].
 */
static int illegalchars[] = {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^@ - ^O */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^P - ^_ */
    0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* SPACE - / */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 0 - ? */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* : - O */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, /* P - _ */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ` - o */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* p - ^? */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
};

validate_chars(s)
register char *s;
{
    while (*s)
      if (illegalchars[*s++])
	return(MR_BAD_CHAR);
    return(MR_EXISTS);
}


validate_id(q, argv, vo)
    struct query *q;
    char *argv[];
    register struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name, *tbl, *namefield, *idfield;
    int id, rowcount;
    EXEC SQL END DECLARE SECTION;
    int status;
    register char *c;

    name = argv[vo->index];
    tbl = vo->table;
    namefield = vo->namefield;
    idfield = vo->idfield;

    if ((!strcmp(tbl, "users") && !strcmp(namefield, "login")) ||
	!strcmp(tbl, "machine") ||
	!strcmp(tbl, "subnet") ||
	!strcmp(tbl, "filesys") ||
	!strcmp(tbl, "list") ||
	!strcmp(tbl, "cluster") ||
	!strcmp(tbl, "strings")) {
	if (!strcmp(tbl, "machine") || !strcmp(tbl, "subnet"))
	  for (c = name; *c; c++) if (islower(*c)) *c = toupper(*c);
	status = name_to_id(name, tbl, &id);
	if (status == 0) {
	    *(int *)argv[vo->index] = id;
	    return(MR_EXISTS);
	} else if (status == MR_NO_MATCH && !strcmp(tbl, "strings") &&
		   (q->type == APPEND || q->type == UPDATE)) {
	    id=add_string(name);
	    cache_entry(name, "STRING", id);
	    *(int *)argv[vo->index] = id;
	    return(MR_EXISTS);
	} else if (status == MR_NO_MATCH || status == MR_NOT_UNIQUE)
	  return(vo->error);
	else
	  return(status);
    }

    if (!strcmp(namefield, "uid")) {
	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = %s",idfield,tbl,namefield,name);
    } else {
	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = '%s'",idfield,tbl,namefield,name);
    }
    EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
    if(sqlca.sqlcode)
      return(MR_INTERNAL);
    EXEC SQL DECLARE csr127 CURSOR FOR stmt;
    EXEC SQL OPEN csr127;
    rowcount=0;
    EXEC SQL FETCH csr127 USING DESCRIPTOR :SQLDA;
    if(sqlca.sqlcode == 0) {
	rowcount++;
	EXEC SQL FETCH csr127 USING DESCRIPTOR :SQLDA;
	if(sqlca.sqlcode == 0) rowcount++;
    }
    EXEC SQL CLOSE csr127;
    if (ingres_errno)
      return(mr_errcode);

    if (rowcount != 1) return(vo->error);
    bcopy(SQLDA->sqlvar[0].sqldata,argv[vo->index],sizeof(int));
    return(MR_EXISTS);
}

validate_name(argv, vo)
    char *argv[];
    register struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name, *tbl, *namefield;
    int rowcount;
    EXEC SQL END DECLARE SECTION;
    register char *c;

    name = argv[vo->index];
    tbl = vo->table;
    namefield = vo->namefield;
    if (!strcmp(tbl, "servers") && !strcmp(namefield, "name")) {
	for (c = name; *c; c++)
	  if (islower(*c))
	    *c = toupper(*c);
    }
    sprintf(stmt_buf,"SELECT DISTINCT COUNT(*) FROM %s WHERE %s.%s = '%s'",
	    tbl,tbl,namefield,name);
    EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
    if(sqlca.sqlcode)
      return(MR_INTERNAL);
    EXEC SQL DECLARE csr128 CURSOR FOR stmt;
    EXEC SQL OPEN csr128;
    EXEC SQL FETCH csr128 USING DESCRIPTOR :SQLDA;
    rowcount = *(int *)SQLDA->sqlvar[0].sqldata;
    EXEC SQL CLOSE csr128;

    if (ingres_errno) return(mr_errcode);
    return ((rowcount == 1) ? MR_EXISTS : vo->error);
}

validate_date(argv, vo)
    char *argv[];
    struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *idate;
    double dd;
    int errorno;
    EXEC SQL END DECLARE SECTION;

    idate = argv[vo->index];
    EXEC SQL SELECT interval('years',date(:idate)-date('today')) INTO :dd;

    if (sqlca.sqlcode != 0 || dd > 5.0) return(MR_DATE);
    return(MR_EXISTS);
}


validate_rename(argv, vo)
char *argv[];
struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name, *tbl, *namefield, *idfield;
    int id;
    EXEC SQL END DECLARE SECTION;
    int status;
    register char *c;

    c = name = argv[vo->index];
    while (*c)
      if (illegalchars[*c++])
	return(MR_BAD_CHAR);
    tbl = vo->table;
    /* minor kludge to upcasify machine names */
    if (!strcmp(tbl, "machine"))
	for (c = name; *c; c++) if (islower(*c)) *c = toupper(*c);
    namefield = vo->namefield;
    idfield = vo->idfield;
    id = -1;
    if (idfield == 0) {
	if (!strcmp(argv[vo->index], argv[vo->index - 1]))
	  return(MR_EXISTS);
	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = LEFT('%s',SIZE(%s))",
		namefield,tbl,namefield,name,namefield);
	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
	if(sqlca.sqlcode)
	  return(MR_INTERNAL);
        EXEC SQL DECLARE csr129 CURSOR FOR stmt;
	EXEC SQL OPEN csr129;
        EXEC SQL FETCH csr129 USING DESCRIPTOR :SQLDA;
	if(sqlca.sqlcode == 0) id=1; else id=0;
	EXEC SQL CLOSE csr129;

	if (ingres_errno) return(mr_errcode);
	if (id)
	  return(vo->error);
	else
	  return(MR_EXISTS);
    }
    status = name_to_id(name, tbl, &id);
    if (status == MR_NO_MATCH || id == *(int *)argv[vo->index - 1])
      return(MR_EXISTS);
    else
      return(vo->error);
}


validate_type(argv, vo)
    char *argv[];
    register struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *typename;
    char *val;
    int cnt;
    EXEC SQL END DECLARE SECTION;
    register char *c;

    typename = vo->table;
    c = val = argv[vo->index];
    while (*c) {
	if (illegalchars[*c++])
	  return(MR_BAD_CHAR);
    }

    /* uppercase type fields */
    for (c = val; *c; c++) if (islower(*c)) *c = toupper(*c);

    EXEC SQL SELECT COUNT(trans) INTO :cnt FROM alias
      WHERE name = :typename AND type='TYPE' AND trans = :val;
    if (ingres_errno) return(mr_errcode);
    return (cnt ? MR_EXISTS : vo->error);
}

/* validate member or type-specific data field */

validate_typedata(q, argv, vo)
    register struct query *q;
    register char *argv[];
    register struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name;
    char *field_type;
    char data_type[129];
    int id;
    EXEC SQL END DECLARE SECTION;
    int status;
    char *index();
    register char *c;

    /* get named object */
    name = argv[vo->index];

    /* get field type string (known to be at index-1) */
    field_type = argv[vo->index-1];

    /* get corresponding data type associated with field type name */
    EXEC SQL SELECT trans INTO :data_type FROM alias
      WHERE name = :field_type AND type='TYPEDATA';
    if (ingres_errno) return(mr_errcode);
    if (sqlca.sqlerrd[2] != 1) return(MR_TYPE);

    /* now retrieve the record id corresponding to the named object */
    if (index(data_type, ' '))
	*index(data_type, ' ') = 0;
    if (!strcmp(data_type, "user")) {
	/* USER */
	if (index(name, '@'))
	  return(MR_USER);
	status = name_to_id(name, data_type, &id);
	if (status && (status == MR_NO_MATCH || status == MR_NOT_UNIQUE))
	  return(MR_USER);
	if (status) return(status);
    } else if (!strcmp(data_type, "list")) {
	/* LIST */
	status = name_to_id(name, data_type, &id);
	if (status && status == MR_NOT_UNIQUE)
	  return(MR_LIST);
	if (status == MR_NO_MATCH) {
	    /* if idfield is non-zero, then if argv[0] matches the string
	     * that we're trying to resolve, we should get the value of
	     * numvalues.[idfield] for the id.
	     */
	    if (vo->idfield && !strcmp(argv[0], argv[vo->index])) {
		set_next_object_id(q->validate->object_id, q->rtable, 0);
		name = vo->idfield;
		EXEC SQL REPEATED SELECT value INTO :id FROM numvalues
		  WHERE name = :name;
		if (sqlca.sqlerrd[2] != 1) return(MR_LIST);
	    } else
	      return(MR_LIST);
	} else if (status) return(status);
    } else if (!strcmp(data_type, "machine")) {
	/* MACHINE */
	for (c = name; *c; c++) if (islower(*c)) *c = toupper(*c);
	status = name_to_id(name, data_type, &id);
	if (status && (status == MR_NO_MATCH || status == MR_NOT_UNIQUE))
	  return(MR_MACHINE);
	if (status) return(status);
    } else if (!strcmp(data_type, "string")) {
	/* STRING */
	status = name_to_id(name, data_type, &id);
	if (status && status == MR_NOT_UNIQUE)
	  return(MR_STRING);
	if (status == MR_NO_MATCH) {
	    if (q->type != APPEND && q->type != UPDATE) return(MR_STRING);
	    id=add_string(name);
	    cache_entry(name, "STRING", id);
	} else if (status) return(status);
    } else if (!strcmp(data_type, "none")) {
	id = 0;
    } else {
	return(MR_TYPE);
    }

    /* now set value in argv */
    *(int *)argv[vo->index] = id;

    return (MR_EXISTS);
}


/* Lock the table named by the validation object */

lock_table(vo)
struct valobj *vo;
{
    sprintf(stmt_buf,"UPDATE %s SET modtime='now' WHERE %s.%s = 0",
	    vo->table,vo->table,vo->idfield);
    EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
    if (ingres_errno) return(mr_errcode);
    if (sqlca.sqlerrd[2] != 1)
      return(vo->error);
    else
      return(MR_EXISTS);
}


/* Check the database at startup time.  For now this just resets the
 * inprogress flags that the DCM uses.
 */

sanity_check_database()
{
}


/* Dynamic SQL support routines */
MR_SQLDA_T *mr_alloc_SQLDA()
{
    MR_SQLDA_T *it;
    short *null_indicators;
    register int j;

    if((it=(MR_SQLDA_T *)malloc(sizeof(MR_SQLDA_T)))==NULL) {
	com_err(whoami, MR_NO_MEM, "setting up SQLDA");
	exit(1);
    }

    if((null_indicators=(short *)calloc(QMAXARGS,sizeof(short)))==NULL) {
	com_err(whoami, MR_NO_MEM, "setting up SQLDA null indicators");
	exit(1);
    }

    for(j=0; j<QMAXARGS; j++) {
	if((it->sqlvar[j].sqldata=(char *)malloc(sizeof(short)+ARGLEN))==NULL) {
	    com_err(whoami, MR_NO_MEM, "setting up SQLDA variables");
	    exit(1);
	}
	it->sqlvar[j].sqllen=ARGLEN;
	it->sqlvar[j].sqlind=null_indicators+j;
	null_indicators[j]=0;
    }
    it->sqln=QMAXARGS;
    return it;
}


/* Use this after FETCH USING DESCRIPTOR one or more
 * result columns may contain NULLs.  This routine is
 * not currently needed, since db/schema creates all
 * columns with a NOT NULL WITH DEFAULT clause.
 *
 * This is currently dead flesh, since no Moira columns
 * allow null values; all use default values.
 */
mr_fix_nulls_in_SQLDA(da)
    MR_SQLDA_T *da;
{
    register IISQLVAR *var;
    register int j;
    int *intp;

    for(j=0, var=da->sqlvar; j<da->sqld; j++, var++) {
	switch(var->sqltype) {
	  case -IISQ_CHA_TYPE:
	    if(*var->sqlind)
	      *var->sqldata='\0';
	    break;
	  case -IISQ_INT_TYPE:
	    if(*var->sqlind) {
		intp=(int *)var->sqldata;
		*intp=0;
	    }
	    break;
	}
    }
}

/* Convert normal Unix-style wildcards to SQL voodoo */
convert_wildcards(arg)
    char *arg;
{
    static char buffer[ARGLEN];
    register char *s, *d;

    for(d=buffer,s=arg;*s;s++) {
	switch(*s) {
	  case '*': *d++='%'; *d++='%'; break;
	  case '?': *d++='_'; break;
	  case '_':
	  case '[':
	  case ']': *d++='*'; *d++ = *s; break;
	  case '%': *d++='*'; *d++='%'; *d++='%'; break;
	  default: *d++ = *s; break;
	}
    }
    *d='\0';

    /* Copy back into argv */
    strcpy(arg,buffer);

    return(MR_EXISTS);
}

/* This version includes uppercase conversion, for things like gmac.
 * This is necessary because "LIKE" doesn't work with "uppercase()".
 * Including it in a wildcard routine saves making two passes over
 * the argument string.
 */
convert_wildcards_uppercase(arg)
    char *arg;
{
    static char buffer[ARGLEN];
    register char *s, *d;

    for(d=buffer,s=arg;*s;s++) {
	switch(*s) {
	  case '*': *d++='%'; *d++='%'; break;
	  case '?': *d++='_'; break;
	  case '_':
	  case '[':
	  case ']': *d++='*'; *d++ = *s; break;
	  case '%': *d++='*'; *d++='%'; *d++='%'; break;
	  default: *d++=toupper(*s); break;       /* This is the only diff. */
	}
    }
    *d='\0';

    /* Copy back into argv */
    strcpy(arg,buffer);

    return(MR_EXISTS);
}


/* Looks like it's time to build an abstraction barrier, Yogi */
mr_select_any(stmt)
    EXEC SQL BEGIN DECLARE SECTION; 
    char *stmt;
    EXEC SQL END DECLARE SECTION; 
{
    int result=0;

    EXEC SQL PREPARE stmt FROM :stmt;
    EXEC SQL DESCRIBE stmt INTO :SQLDA;
    if(SQLDA->sqld==0)                       /* Not a SELECT */
        return(MR_INTERNAL);        
    EXEC SQL DECLARE csr CURSOR FOR stmt;
    EXEC SQL OPEN csr;
    EXEC SQL FETCH csr USING DESCRIPTOR :SQLDA;
    if(sqlca.sqlcode==0) 
        result=MR_EXISTS;
    else if((sqlca.sqlcode<0) && mr_errcode)
        result=mr_errcode;
    else
        result=0;
    EXEC SQL CLOSE csr;
    return(result);
} 


/*  Adds a string to the string table.  Returns the id number.
 * 
 */
int add_string(name)
    EXEC SQL BEGIN DECLARE SECTION; 
    char *name;
    EXEC SQL END DECLARE SECTION;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char buf[256];
    int id;
    EXEC SQL END DECLARE SECTION; 

    EXEC SQL SELECT value INTO :id FROM numvalues WHERE name = 'strings_id';
    id++;
    EXEC SQL UPDATE numvalues SET value = :id WHERE name = 'strings_id';
    
    /* Use sprintf to get around problem with doubled single quotes */
    sprintf(buf,"INSERT INTO strings (string_id, string) VALUES (%d, '%s')",id,name);
    EXEC SQL EXECUTE IMMEDIATE :buf;
 
    return(id);
}
Commit	Line	Data
73cf66ba	1	/*
	2	* $Source$
	3	* $Author$
	4	* $Header$
	5	*
	6	* Copyright (C) 1987 by the Massachusetts Institute of Technology
	7	* For copying and distribution information, please see the file
	8	* <mit-copyright.h>.
	9	*
	10	*/
	11
	12	#ifndef lint
	13	static char *rcsid_qsupport_dc = "$Header$";
	14	#endif lint
	15
	16	#include <mit-copyright.h>
	17	#include <unistd.h>
	18	#include "query.h"
	19	#include "mr_server.h"
	20	#include <ctype.h>
	21	EXEC SQL INCLUDE sqlca;
	22	EXEC SQL INCLUDE sqlda;
	23	#include "qrtn.h"
	24
	25	extern char *whoami;
	26	extern int ingres_errno, mr_errcode;
	27
	28	EXEC SQL BEGIN DECLARE SECTION;
	29	extern char stmt_buf[];
	30	EXEC SQL END DECLARE SECTION;
	31
	32	EXEC SQL WHENEVER SQLERROR CALL ingerr;
	33
	34
	35	/* Validation Routines */
	36
	37	validate_row(q, argv, v)
	38	register struct query *q;
	39	char *argv[];
	40	register struct validate *v;
	41	{
	42	EXEC SQL BEGIN DECLARE SECTION;
	43	char *name;
	44	char qual[128];
	45	int rowcount;
	46	EXEC SQL END DECLARE SECTION;
	47
	48	/* build where clause */
	49	build_qual(v->qual, v->argc, argv, qual);
	50
	51	if (log_flags & LOG_VALID)
	52	/* tell the logfile what we're doing */
	53	com_err(whoami, 0, "validating row: %s", qual);
	54
	55	/* look for the record */
	56	sprintf(stmt_buf,"SELECT COUNT (*) FROM %s WHERE %s",q->rtable,qual);
	57	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
	58	if(sqlca.sqlcode)
	59	return(MR_INTERNAL);
	60	EXEC SQL DECLARE csr126 CURSOR FOR stmt;
	61	EXEC SQL OPEN csr126;
	62	EXEC SQL FETCH csr126 USING DESCRIPTOR :SQLDA;
	63	EXEC SQL CLOSE csr126;
	64	rowcount = (int )SQLDA->sqlvar[0].sqldata;
65
66	if (ingres_errno) return(mr_errcode);
67	if (rowcount == 0) return(MR_NO_MATCH);
68	if (rowcount > 1) return(MR_NOT_UNIQUE);
69	return(MR_EXISTS);
70	}
71
72	validate_fields(q, argv, vo, n)
73	struct query *q;
74	register char *argv[];
75	register struct valobj *vo;
76	register int n;
77	{
78	register int status;
79
80	while (--n >= 0) {
81	switch (vo->type) {
82	case V_NAME:
83	if (log_flags & LOG_VALID)
84	com_err(whoami, 0, "validating %s in %s: %s",
85	vo->namefield, vo->table, argv[vo->index]);
86	status = validate_name(argv, vo);
87	break;
88
89	case V_ID:
90	if (log_flags & LOG_VALID)
91	com_err(whoami, 0, "validating %s in %s: %s",
92	vo->idfield, vo->table, argv[vo->index]);
93	status = validate_id(q, argv, vo);
94	break;
95
96	case V_DATE:
97	if (log_flags & LOG_VALID)
98	com_err(whoami, 0, "validating date: %s", argv[vo->index]);
99	status = validate_date(argv, vo);
100	break;
101
102	case V_TYPE:
103	if (log_flags & LOG_VALID)
104	com_err(whoami, 0, "validating %s type: %s",
105	vo->table, argv[vo->index]);
106	status = validate_type(argv, vo);
107	break;
108
109	case V_TYPEDATA:
110	if (log_flags & LOG_VALID)
111	com_err(whoami, 0, "validating typed data (%s): %s",
112	argv[vo->index - 1], argv[vo->index]);
113	status = validate_typedata(q, argv, vo);
114	break;
115
116	case V_RENAME:
117	if (log_flags & LOG_VALID)
118	com_err(whoami, 0, "validating rename %s in %s",
119	argv[vo->index], vo->table);
120	status = validate_rename(argv, vo);
121	break;
122
123	case V_CHAR:
124	if (log_flags & LOG_VALID)
125	com_err(whoami, 0, "validating chars: %s", argv[vo->index]);
126	status = validate_chars(argv[vo->index]);
127	break;
128
129	case V_SORT:
130	status = MR_EXISTS;
131	break;
132
133	case V_LOCK:
134	status = lock_table(vo);
135	break;
136
137	case V_WILD:
138	status = convert_wildcards(argv[vo->index]);
139	break;
140
141	case V_UPWILD:
142	status = convert_wildcards_uppercase(argv[vo->index]);
143	break;
144
145	}
146
147	if (status != MR_EXISTS) return(status);
148	vo++;
149	}
150
151	if (ingres_errno) return(mr_errcode);
152	return(MR_SUCCESS);
153	}
154
155
156	/* validate_chars: verify that there are no illegal characters in
157	* the string. Legal characters are printing chars other than
158	* ", *, ?, \, [ and ].
159	*/
160	static int illegalchars[] = {
161	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^@ - ^O */
162	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^P - ^_ */
163	0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* SPACE - / */
164	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 0 - ? */
165	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* : - O */
166	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, /* P - _ */
167	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ` - o */
168	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* p - ^? */
169	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
170	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
171	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
172	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
173	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
174	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
175	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
176	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
177	};
178
179	validate_chars(s)
180	register char *s;
181	{
182	while (*s)
183	if (illegalchars[*s++])
184	return(MR_BAD_CHAR);
185	return(MR_EXISTS);
186	}
187
188
189	validate_id(q, argv, vo)
190	struct query *q;
191	char *argv[];
192	register struct valobj *vo;
193	{
194	EXEC SQL BEGIN DECLARE SECTION;
195	char name, tbl, namefield, idfield;
196	int id, rowcount;
197	EXEC SQL END DECLARE SECTION;
198	int status;
199	register char *c;
200
201	name = argv[vo->index];
202	tbl = vo->table;
203	namefield = vo->namefield;
204	idfield = vo->idfield;
205
206	if ((!strcmp(tbl, "users") && !strcmp(namefield, "login")) \|\|
207	!strcmp(tbl, "machine") \|\|
208	!strcmp(tbl, "subnet") \|\|
209	!strcmp(tbl, "filesys") \|\|
210	!strcmp(tbl, "list") \|\|
211	!strcmp(tbl, "cluster") \|\|
212	!strcmp(tbl, "strings")) {
213	if (!strcmp(tbl, "machine") \|\| !strcmp(tbl, "subnet"))
214	for (c = name; c; c++) if (islower(c)) c = toupper(c);
215	status = name_to_id(name, tbl, &id);
216	if (status == 0) {
217	(int )argv[vo->index] = id;
218	return(MR_EXISTS);
219	} else if (status == MR_NO_MATCH && !strcmp(tbl, "strings") &&
220	(q->type == APPEND \|\| q->type == UPDATE)) {
221	id=add_string(name);
222	cache_entry(name, "STRING", id);
223	(int )argv[vo->index] = id;
224	return(MR_EXISTS);
225	} else if (status == MR_NO_MATCH \|\| status == MR_NOT_UNIQUE)
226	return(vo->error);
227	else
228	return(status);
229	}
230
231	if (!strcmp(namefield, "uid")) {
232	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = %s",idfield,tbl,namefield,name);
233	} else {
234	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = '%s'",idfield,tbl,namefield,name);
235	}
236	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
237	if(sqlca.sqlcode)
238	return(MR_INTERNAL);
239	EXEC SQL DECLARE csr127 CURSOR FOR stmt;
240	EXEC SQL OPEN csr127;
241	rowcount=0;
242	EXEC SQL FETCH csr127 USING DESCRIPTOR :SQLDA;
243	if(sqlca.sqlcode == 0) {
244	rowcount++;
245	EXEC SQL FETCH csr127 USING DESCRIPTOR :SQLDA;
246	if(sqlca.sqlcode == 0) rowcount++;
247	}
248	EXEC SQL CLOSE csr127;
249	if (ingres_errno)
250	return(mr_errcode);
251
252	if (rowcount != 1) return(vo->error);
253	bcopy(SQLDA->sqlvar[0].sqldata,argv[vo->index],sizeof(int));
254	return(MR_EXISTS);
255	}
256
257	validate_name(argv, vo)
258	char *argv[];
259	register struct valobj *vo;
260	{
261	EXEC SQL BEGIN DECLARE SECTION;
262	char name, tbl, *namefield;
263	int rowcount;
264	EXEC SQL END DECLARE SECTION;
265	register char *c;
266
267	name = argv[vo->index];
268	tbl = vo->table;
269	namefield = vo->namefield;
270	if (!strcmp(tbl, "servers") && !strcmp(namefield, "name")) {
271	for (c = name; *c; c++)
272	if (islower(*c))
273	c = toupper(c);
274	}
275	sprintf(stmt_buf,"SELECT DISTINCT COUNT(*) FROM %s WHERE %s.%s = '%s'",
276	tbl,tbl,namefield,name);
277	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
278	if(sqlca.sqlcode)
279	return(MR_INTERNAL);
280	EXEC SQL DECLARE csr128 CURSOR FOR stmt;
281	EXEC SQL OPEN csr128;
282	EXEC SQL FETCH csr128 USING DESCRIPTOR :SQLDA;
283	rowcount = (int )SQLDA->sqlvar[0].sqldata;
284	EXEC SQL CLOSE csr128;
285
286	if (ingres_errno) return(mr_errcode);
287	return ((rowcount == 1) ? MR_EXISTS : vo->error);
288	}
289
290	validate_date(argv, vo)
291	char *argv[];
292	struct valobj *vo;
293	{
294	EXEC SQL BEGIN DECLARE SECTION;
295	char *idate;
296	double dd;
297	int errorno;
298	EXEC SQL END DECLARE SECTION;
299
300	idate = argv[vo->index];
301	EXEC SQL SELECT interval('years',date(:idate)-date('today')) INTO :dd;
302
303	if (sqlca.sqlcode != 0 \|\| dd > 5.0) return(MR_DATE);
304	return(MR_EXISTS);
305	}
306
307
308	validate_rename(argv, vo)
309	char *argv[];
310	struct valobj *vo;
311	{
312	EXEC SQL BEGIN DECLARE SECTION;
313	char name, tbl, namefield, idfield;
314	int id;
315	EXEC SQL END DECLARE SECTION;
316	int status;
317	register char *c;
318
319	c = name = argv[vo->index];
320	while (*c)
321	if (illegalchars[*c++])
322	return(MR_BAD_CHAR);
323	tbl = vo->table;
324	/* minor kludge to upcasify machine names */
325	if (!strcmp(tbl, "machine"))
326	for (c = name; c; c++) if (islower(c)) c = toupper(c);
327	namefield = vo->namefield;
328	idfield = vo->idfield;
329	id = -1;
330	if (idfield == 0) {
331	if (!strcmp(argv[vo->index], argv[vo->index - 1]))
332	return(MR_EXISTS);
333	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = LEFT('%s',SIZE(%s))",
334	namefield,tbl,namefield,name,namefield);
335	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
336	if(sqlca.sqlcode)
337	return(MR_INTERNAL);
338	EXEC SQL DECLARE csr129 CURSOR FOR stmt;
339	EXEC SQL OPEN csr129;
340	EXEC SQL FETCH csr129 USING DESCRIPTOR :SQLDA;
341	if(sqlca.sqlcode == 0) id=1; else id=0;
342	EXEC SQL CLOSE csr129;
343
344	if (ingres_errno) return(mr_errcode);
345	if (id)
346	return(vo->error);
347	else
348	return(MR_EXISTS);
349	}
350	status = name_to_id(name, tbl, &id);
351	if (status == MR_NO_MATCH \|\| id == (int )argv[vo->index - 1])
352	return(MR_EXISTS);
353	else
354	return(vo->error);
355	}
356
357
358	validate_type(argv, vo)
359	char *argv[];
360	register struct valobj *vo;
361	{
362	EXEC SQL BEGIN DECLARE SECTION;
363	char *typename;
364	char *val;
365	int cnt;
366	EXEC SQL END DECLARE SECTION;
367	register char *c;
368
369	typename = vo->table;
370	c = val = argv[vo->index];
371	while (*c) {
372	if (illegalchars[*c++])
373	return(MR_BAD_CHAR);
374	}
375
376	/* uppercase type fields */
377	for (c = val; c; c++) if (islower(c)) c = toupper(c);
378
379	EXEC SQL SELECT COUNT(trans) INTO :cnt FROM alias
380	WHERE name = :typename AND type='TYPE' AND trans = :val;
381	if (ingres_errno) return(mr_errcode);
382	return (cnt ? MR_EXISTS : vo->error);
383	}
384
385	/* validate member or type-specific data field */
386
387	validate_typedata(q, argv, vo)
388	register struct query *q;
389	register char *argv[];
390	register struct valobj *vo;
391	{
392	EXEC SQL BEGIN DECLARE SECTION;
393	char *name;
394	char *field_type;
395	char data_type[129];
396	int id;
397	EXEC SQL END DECLARE SECTION;
398	int status;
399	char *index();
400	register char *c;
401
402	/* get named object */
403	name = argv[vo->index];
404
405	/* get field type string (known to be at index-1) */
406	field_type = argv[vo->index-1];
407
408	/* get corresponding data type associated with field type name */
409	EXEC SQL SELECT trans INTO :data_type FROM alias
410	WHERE name = :field_type AND type='TYPEDATA';
411	if (ingres_errno) return(mr_errcode);
412	if (sqlca.sqlerrd[2] != 1) return(MR_TYPE);
413
414	/* now retrieve the record id corresponding to the named object */
415	if (index(data_type, ' '))
416	*index(data_type, ' ') = 0;
417	if (!strcmp(data_type, "user")) {
418	/* USER */
419	if (index(name, '@'))
420	return(MR_USER);
421	status = name_to_id(name, data_type, &id);
422	if (status && (status == MR_NO_MATCH \|\| status == MR_NOT_UNIQUE))
423	return(MR_USER);
424	if (status) return(status);
425	} else if (!strcmp(data_type, "list")) {
426	/* LIST */
427	status = name_to_id(name, data_type, &id);
428	if (status && status == MR_NOT_UNIQUE)
429	return(MR_LIST);
430	if (status == MR_NO_MATCH) {
431	/* if idfield is non-zero, then if argv[0] matches the string
432	* that we're trying to resolve, we should get the value of
433	* numvalues.[idfield] for the id.
434	*/
435	if (vo->idfield && !strcmp(argv[0], argv[vo->index])) {
436	set_next_object_id(q->validate->object_id, q->rtable, 0);
437	name = vo->idfield;
438	EXEC SQL REPEATED SELECT value INTO :id FROM numvalues
439	WHERE name = :name;
440	if (sqlca.sqlerrd[2] != 1) return(MR_LIST);
441	} else
442	return(MR_LIST);
443	} else if (status) return(status);
444	} else if (!strcmp(data_type, "machine")) {
445	/* MACHINE */
446	for (c = name; c; c++) if (islower(c)) c = toupper(c);
447	status = name_to_id(name, data_type, &id);
448	if (status && (status == MR_NO_MATCH \|\| status == MR_NOT_UNIQUE))
449	return(MR_MACHINE);
450	if (status) return(status);
451	} else if (!strcmp(data_type, "string")) {
452	/* STRING */
453	status = name_to_id(name, data_type, &id);
454	if (status && status == MR_NOT_UNIQUE)
455	return(MR_STRING);
456	if (status == MR_NO_MATCH) {
457	if (q->type != APPEND && q->type != UPDATE) return(MR_STRING);
458	id=add_string(name);
459	cache_entry(name, "STRING", id);
460	} else if (status) return(status);
461	} else if (!strcmp(data_type, "none")) {
462	id = 0;
463	} else {
464	return(MR_TYPE);
465	}
466
467	/* now set value in argv */
468	(int )argv[vo->index] = id;
469
470	return (MR_EXISTS);
471	}
472
473
474	/* Lock the table named by the validation object */
475
476	lock_table(vo)
477	struct valobj *vo;
478	{
479	sprintf(stmt_buf,"UPDATE %s SET modtime='now' WHERE %s.%s = 0",
480	vo->table,vo->table,vo->idfield);
481	EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
482	if (ingres_errno) return(mr_errcode);
483	if (sqlca.sqlerrd[2] != 1)
484	return(vo->error);
485	else
486	return(MR_EXISTS);
487	}
488
489
490	/* Check the database at startup time. For now this just resets the
491	* inprogress flags that the DCM uses.
492	*/
493
494	sanity_check_database()
495	{
496	}
497
498
499	/* Dynamic SQL support routines */
500	MR_SQLDA_T *mr_alloc_SQLDA()
501	{
502	MR_SQLDA_T *it;
503	short *null_indicators;
504	register int j;
505
506	if((it=(MR_SQLDA_T *)malloc(sizeof(MR_SQLDA_T)))==NULL) {
507	com_err(whoami, MR_NO_MEM, "setting up SQLDA");
508	exit(1);
509	}
510
511	if((null_indicators=(short *)calloc(QMAXARGS,sizeof(short)))==NULL) {
512	com_err(whoami, MR_NO_MEM, "setting up SQLDA null indicators");
513	exit(1);
514	}
515
516	for(j=0; j<QMAXARGS; j++) {
6612addc	517	if((it->sqlvar[j].sqldata=(char *)malloc(sizeof(short)+ARGLEN))==NULL) {
73cf66ba	518	com_err(whoami, MR_NO_MEM, "setting up SQLDA variables");
	519	exit(1);
	520	}
	521	it->sqlvar[j].sqllen=ARGLEN;
	522	it->sqlvar[j].sqlind=null_indicators+j;
	523	null_indicators[j]=0;
	524	}
	525	it->sqln=QMAXARGS;
	526	return it;
	527	}
	528
	529
	530	/* Use this after FETCH USING DESCRIPTOR one or more
	531	* result columns may contain NULLs. This routine is
	532	* not currently needed, since db/schema creates all
	533	* columns with a NOT NULL WITH DEFAULT clause.
	534	*
	535	* This is currently dead flesh, since no Moira columns
	536	* allow null values; all use default values.
	537	*/
	538	mr_fix_nulls_in_SQLDA(da)
	539	MR_SQLDA_T *da;
	540	{
	541	register IISQLVAR *var;
	542	register int j;
	543	int *intp;
	544
	545	for(j=0, var=da->sqlvar; j<da->sqld; j++, var++) {
	546	switch(var->sqltype) {
	547	case -IISQ_CHA_TYPE:
	548	if(*var->sqlind)
	549	*var->sqldata='\0';
	550	break;
	551	case -IISQ_INT_TYPE:
	552	if(*var->sqlind) {
	553	intp=(int *)var->sqldata;
	554	*intp=0;
	555	}
	556	break;
	557	}
	558	}
	559	}
	560
73cf66ba	561	/* Convert normal Unix-style wildcards to SQL voodoo */
	562	convert_wildcards(arg)
	563	char *arg;
	564	{
	565	static char buffer[ARGLEN];
	566	register char s, d;
	567
	568	for(d=buffer,s=arg;*s;s++) {
	569	switch(*s) {
	570	case '': d++='%'; *d++='%'; break;
	571	case '?': *d++='_'; break;
	572	case '_':
	573	case '[':
	574	case ']': d++=''; d++ = s; break;
	575	case '%': d++=''; d++='%'; d++='%'; break;
	576	default: d++ = s; break;
	577	}
	578	}
	579	*d='\0';
	580
	581	/* Copy back into argv */
	582	strcpy(arg,buffer);
	583
	584	return(MR_EXISTS);
	585	}
	586
	587	/* This version includes uppercase conversion, for things like gmac.
	588	* This is necessary because "LIKE" doesn't work with "uppercase()".
	589	* Including it in a wildcard routine saves making two passes over
	590	* the argument string.
	591	*/
	592	convert_wildcards_uppercase(arg)
	593	char *arg;
	594	{
	595	static char buffer[ARGLEN];
	596	register char s, d;
	597
	598	for(d=buffer,s=arg;*s;s++) {
	599	switch(*s) {
	600	case '': d++='%'; *d++='%'; break;
	601	case '?': *d++='_'; break;
	602	case '_':
	603	case '[':
	604	case ']': d++=''; d++ = s; break;
	605	case '%': d++=''; d++='%'; d++='%'; break;
	606	default: d++=toupper(s); break; /* This is the only diff. */
	607	}
	608	}
	609	*d='\0';
	610
	611	/* Copy back into argv */
	612	strcpy(arg,buffer);
	613
	614	return(MR_EXISTS);
	615	}
	616
	617
	618	/* Looks like it's time to build an abstraction barrier, Yogi */
	619	mr_select_any(stmt)
	620	EXEC SQL BEGIN DECLARE SECTION;
	621	char *stmt;
	622	EXEC SQL END DECLARE SECTION;
	623	{
	624	int result=0;
625
626	EXEC SQL PREPARE stmt FROM :stmt;
627	EXEC SQL DESCRIBE stmt INTO :SQLDA;
628	if(SQLDA->sqld==0) /* Not a SELECT */
629	return(MR_INTERNAL);
630	EXEC SQL DECLARE csr CURSOR FOR stmt;
631	EXEC SQL OPEN csr;
632	EXEC SQL FETCH csr USING DESCRIPTOR :SQLDA;
633	if(sqlca.sqlcode==0)
634	result=MR_EXISTS;
635	else if((sqlca.sqlcode<0) && mr_errcode)
636	result=mr_errcode;
637	else
638	result=0;
639	EXEC SQL CLOSE csr;
640	return(result);
641	}
642
643
644
645	/* Adds a string to the string table. Returns the id number.
646	*
647	*/
648	int add_string(name)
649	EXEC SQL BEGIN DECLARE SECTION;
650	char *name;
651	EXEC SQL END DECLARE SECTION;
652	{
653	EXEC SQL BEGIN DECLARE SECTION;
654	char buf[256];
655	int id;
656	EXEC SQL END DECLARE SECTION;
657
658	EXEC SQL SELECT value INTO :id FROM numvalues WHERE name = 'strings_id';
659	id++;
660	EXEC SQL UPDATE numvalues SET value = :id WHERE name = 'strings_id';
661
662	/* Use sprintf to get around problem with doubled single quotes */
663	sprintf(buf,"INSERT INTO strings (string_id, string) VALUES (%d, '%s')",id,name);
664	EXEC SQL EXECUTE IMMEDIATE :buf;
665
666	return(id);
667	}
668