[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;

#ifdef _DEBUG_MALLOC_INC
#undef index
#define dbg_index(str1,c)             DBindex(__FILE__, __LINE__, str1, c)
#else
#define dbg_index index
#endif

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