[moira.git] / server / qvalidate.c

/*
 *	$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_RLOCK:
            status = readlock_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){
           com_err(whoami,0,"validation failed type=%ld, code=%ld\n",vo->type, status);
           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 (sqlca.sqlcode == 100){
        fprintf(stderr,"readlock_table: no matching rows found for %s\n",
                stmt_buf);
        return(MR_INTERNAL);
    }
    if (ingres_errno) 
        return(mr_errcode);
    if (sqlca.sqlerrd[2] != 1)
      return(vo->error);
    else
      return(MR_EXISTS);
}

/*
 * Get a read lock on the table by accessing the magic lock
 * record.  Certain tables are constructed so that they contain
 * an id field whose value is zero and a modtime field.  We 
 * manipulate the modtime field of the id 0 record to effect 
 * locking of the table
 */

readlock_table(vo)
    struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
        int id;
        char buf[256];
        char *tbl, *idfield;
    EXEC SQL END DECLARE SECTION;

    tbl=vo->table;
    idfield=vo->idfield;
    sprintf(buf,"SELECT %s FROM %s WHERE %s.%s = 0",
        vo->idfield, vo->table, vo->table, vo->idfield);
    EXEC SQL PREPARE stmt FROM :buf;
    EXEC SQL DESCRIBE stmt INTO SQLDA;
    EXEC SQL DECLARE rcsr CURSOR FOR stmt;
    EXEC SQL OPEN rcsr;
    EXEC SQL FETCH rcsr USING DESCRIPTOR :SQLDA;
    /* Check for no matching rows found - this is 
     * flagged as an internal error since the table should
     * have a magic lock record.
     */
    if (sqlca.sqlcode == 100){
        EXEC SQL CLOSE rcsr;
        com_err(whoami,0,"readlock_table: no matching rows found for %s\n",
                buf);
        return(MR_INTERNAL);
    }
    EXEC SQL CLOSE rcsr;
    if (ingres_errno)
        return(mr_errcode);
    if (sqlca.sqlcode)
        return(vo->error);
    return(MR_EXISTS);  /* validate_fields expects us to return
                           * this value if everything went okay
                           */
}

/* 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
f7e925bb	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	#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
	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_RLOCK:
144	status = readlock_table(vo);
145	break;
146	case V_WILD:
147	status = convert_wildcards(argv[vo->index]);
148	break;
149
150	case V_UPWILD:
151	status = convert_wildcards_uppercase(argv[vo->index]);
152	break;
153
154	}
155
156	if (status != MR_EXISTS){
157	com_err(whoami,0,"validation failed type=%ld, code=%ld\n",vo->type, status);
158	return(status);
159	}
160	vo++;
161	}
162
163	if (ingres_errno) return(mr_errcode);
164	return(MR_SUCCESS);
165	}
166
167
168	/* validate_chars: verify that there are no illegal characters in
169	* the string. Legal characters are printing chars other than
170	* ", *, ?, \, [ and ].
171	*/
172	static int illegalchars[] = {
173	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^@ - ^O */
174	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^P - ^_ */
175	0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* SPACE - / */
176	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 0 - ? */
177	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* : - O */
178	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, /* P - _ */
179	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ` - o */
180	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* p - ^? */
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	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
184	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
185	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
186	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
187	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
188	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
189	};
190
191	validate_chars(s)
192	register char *s;
193	{
194	while (*s)
195	if (illegalchars[*s++])
196	return(MR_BAD_CHAR);
197	return(MR_EXISTS);
198	}
199
200
201	validate_id(q, argv, vo)
202	struct query *q;
203	char *argv[];
204	register struct valobj *vo;
205	{
206	EXEC SQL BEGIN DECLARE SECTION;
207	char name, tbl, namefield, idfield;
208	int id, rowcount;
209	EXEC SQL END DECLARE SECTION;
210	int status;
211	register char *c;
212
213	name = argv[vo->index];
214	tbl = vo->table;
215	namefield = vo->namefield;
216	idfield = vo->idfield;
217
218	if ((!strcmp(tbl, "users") && !strcmp(namefield, "login")) \|\|
219	!strcmp(tbl, "machine") \|\|
220	!strcmp(tbl, "subnet") \|\|
221	!strcmp(tbl, "filesys") \|\|
222	!strcmp(tbl, "list") \|\|
223	!strcmp(tbl, "cluster") \|\|
224	!strcmp(tbl, "strings")) {
225	if (!strcmp(tbl, "machine") \|\| !strcmp(tbl, "subnet"))
226	for (c = name; c; c++) if (islower(c)) c = toupper(c);
227	status = name_to_id(name, tbl, &id);
228	if (status == 0) {
229	(int )argv[vo->index] = id;
230	return(MR_EXISTS);
231	} else if (status == MR_NO_MATCH && !strcmp(tbl, "strings") &&
232	(q->type == APPEND \|\| q->type == UPDATE)) {
233	id=add_string(name);
234	cache_entry(name, "STRING", id);
235	(int )argv[vo->index] = id;
236	return(MR_EXISTS);
237	} else if (status == MR_NO_MATCH \|\| status == MR_NOT_UNIQUE)
238	return(vo->error);
239	else
240	return(status);
241	}
242
243	if (!strcmp(namefield, "uid")) {
244	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = %s",idfield,tbl,namefield,name);
245	} else {
246	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = '%s'",idfield,tbl,namefield,name);
247	}
248	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
249	if(sqlca.sqlcode)
250	return(MR_INTERNAL);
251	EXEC SQL DECLARE csr127 CURSOR FOR stmt;
252	EXEC SQL OPEN csr127;
253	rowcount=0;
254	EXEC SQL FETCH csr127 USING DESCRIPTOR :SQLDA;
255	if(sqlca.sqlcode == 0) {
256	rowcount++;
257	EXEC SQL FETCH csr127 USING DESCRIPTOR :SQLDA;
258	if(sqlca.sqlcode == 0) rowcount++;
259	}
260	EXEC SQL CLOSE csr127;
261	if (ingres_errno)
262	return(mr_errcode);
263
264	if (rowcount != 1) return(vo->error);
265	bcopy(SQLDA->sqlvar[0].sqldata,argv[vo->index],sizeof(int));
266	return(MR_EXISTS);
267	}
268
269	validate_name(argv, vo)
270	char *argv[];
271	register struct valobj *vo;
272	{
273	EXEC SQL BEGIN DECLARE SECTION;
274	char name, tbl, *namefield;
275	int rowcount;
276	EXEC SQL END DECLARE SECTION;
277	register char *c;
278
279	name = argv[vo->index];
280	tbl = vo->table;
281	namefield = vo->namefield;
282	if (!strcmp(tbl, "servers") && !strcmp(namefield, "name")) {
283	for (c = name; *c; c++)
284	if (islower(*c))
285	c = toupper(c);
286	}
287	sprintf(stmt_buf,"SELECT DISTINCT COUNT(*) FROM %s WHERE %s.%s = '%s'",
288	tbl,tbl,namefield,name);
289	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
290	if(sqlca.sqlcode)
291	return(MR_INTERNAL);
292	EXEC SQL DECLARE csr128 CURSOR FOR stmt;
293	EXEC SQL OPEN csr128;
294	EXEC SQL FETCH csr128 USING DESCRIPTOR :SQLDA;
295	rowcount = (int )SQLDA->sqlvar[0].sqldata;
296	EXEC SQL CLOSE csr128;
297
298	if (ingres_errno) return(mr_errcode);
299	return ((rowcount == 1) ? MR_EXISTS : vo->error);
300	}
301
302	validate_date(argv, vo)
303	char *argv[];
304	struct valobj *vo;
305	{
306	EXEC SQL BEGIN DECLARE SECTION;
307	char *idate;
308	double dd;
309	int errorno;
310	EXEC SQL END DECLARE SECTION;
311
312	idate = argv[vo->index];
313	EXEC SQL SELECT interval('years',date(:idate)-date('today')) INTO :dd;
314
315	if (sqlca.sqlcode != 0 \|\| dd > 5.0) return(MR_DATE);
316	return(MR_EXISTS);
317	}
318
319
320	validate_rename(argv, vo)
321	char *argv[];
322	struct valobj *vo;
323	{
324	EXEC SQL BEGIN DECLARE SECTION;
325	char name, tbl, namefield, idfield;
326	int id;
327	EXEC SQL END DECLARE SECTION;
328	int status;
329	register char *c;
330
331	c = name = argv[vo->index];
332	while (*c)
333	if (illegalchars[*c++])
334	return(MR_BAD_CHAR);
335	tbl = vo->table;
336	/* minor kludge to upcasify machine names */
337	if (!strcmp(tbl, "machine"))
338	for (c = name; c; c++) if (islower(c)) c = toupper(c);
339	namefield = vo->namefield;
340	idfield = vo->idfield;
341	id = -1;
342	if (idfield == 0) {
343	if (!strcmp(argv[vo->index], argv[vo->index - 1]))
344	return(MR_EXISTS);
345	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = LEFT('%s',SIZE(%s))",
346	namefield,tbl,namefield,name,namefield);
347	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
348	if(sqlca.sqlcode)
349	return(MR_INTERNAL);
350	EXEC SQL DECLARE csr129 CURSOR FOR stmt;
351	EXEC SQL OPEN csr129;
352	EXEC SQL FETCH csr129 USING DESCRIPTOR :SQLDA;
353	if(sqlca.sqlcode == 0) id=1; else id=0;
354	EXEC SQL CLOSE csr129;
355
356	if (ingres_errno) return(mr_errcode);
357	if (id)
358	return(vo->error);
359	else
360	return(MR_EXISTS);
361	}
362	status = name_to_id(name, tbl, &id);
363	if (status == MR_NO_MATCH \|\| id == (int )argv[vo->index - 1])
364	return(MR_EXISTS);
365	else
366	return(vo->error);
367	}
368
369
370	validate_type(argv, vo)
371	char *argv[];
372	register struct valobj *vo;
373	{
374	EXEC SQL BEGIN DECLARE SECTION;
375	char *typename;
376	char *val;
377	int cnt;
378	EXEC SQL END DECLARE SECTION;
379	register char *c;
380
381	typename = vo->table;
382	c = val = argv[vo->index];
383	while (*c) {
384	if (illegalchars[*c++])
385	return(MR_BAD_CHAR);
386	}
387
388	/* uppercase type fields */
389	for (c = val; c; c++) if (islower(c)) c = toupper(c);
390
391	EXEC SQL SELECT COUNT(trans) INTO :cnt FROM alias
392	WHERE name = :typename AND type='TYPE' AND trans = :val;
393	if (ingres_errno) return(mr_errcode);
394	return (cnt ? MR_EXISTS : vo->error);
395	}
396
397	/* validate member or type-specific data field */
398
399	validate_typedata(q, argv, vo)
400	register struct query *q;
401	register char *argv[];
402	register struct valobj *vo;
403	{
404	EXEC SQL BEGIN DECLARE SECTION;
405	char *name;
406	char *field_type;
407	char data_type[129];
408	int id;
409	EXEC SQL END DECLARE SECTION;
410	int status;
411	register char *c;
412
413	/* get named object */
414	name = argv[vo->index];
415
416	/* get field type string (known to be at index-1) */
417	field_type = argv[vo->index-1];
418
419	/* get corresponding data type associated with field type name */
420	EXEC SQL SELECT trans INTO :data_type FROM alias
421	WHERE name = :field_type AND type='TYPEDATA';
422	if (ingres_errno) return(mr_errcode);
423	if (sqlca.sqlerrd[2] != 1) return(MR_TYPE);
424
425	/* now retrieve the record id corresponding to the named object */
426	if (dbg_index(data_type, ' '))
427	*dbg_index(data_type, ' ') = 0;
428	if (!strcmp(data_type, "user")) {
429	/* USER */
430	if (dbg_index(name, '@'))
431	return(MR_USER);
432	status = name_to_id(name, data_type, &id);
433	if (status && (status == MR_NO_MATCH \|\| status == MR_NOT_UNIQUE))
434	return(MR_USER);
435	if (status) return(status);
436	} else if (!strcmp(data_type, "list")) {
437	/* LIST */
438	status = name_to_id(name, data_type, &id);
439	if (status && status == MR_NOT_UNIQUE)
440	return(MR_LIST);
441	if (status == MR_NO_MATCH) {
442	/* if idfield is non-zero, then if argv[0] matches the string
443	* that we're trying to resolve, we should get the value of
444	* numvalues.[idfield] for the id.
445	*/
446	if (vo->idfield && !strcmp(argv[0], argv[vo->index])) {
447	set_next_object_id(q->validate->object_id, q->rtable, 0);
448	name = vo->idfield;
449	EXEC SQL REPEATED SELECT value INTO :id FROM numvalues
450	WHERE name = :name;
451	if (sqlca.sqlerrd[2] != 1) return(MR_LIST);
452	} else
453	return(MR_LIST);
454	} else if (status) return(status);
455	} else if (!strcmp(data_type, "machine")) {
456	/* MACHINE */
457	for (c = name; c; c++) if (islower(c)) c = toupper(c);
458	status = name_to_id(name, data_type, &id);
459	if (status && (status == MR_NO_MATCH \|\| status == MR_NOT_UNIQUE))
460	return(MR_MACHINE);
461	if (status) return(status);
462	} else if (!strcmp(data_type, "string")) {
463	/* STRING */
464	status = name_to_id(name, data_type, &id);
465	if (status && status == MR_NOT_UNIQUE)
466	return(MR_STRING);
467	if (status == MR_NO_MATCH) {
468	if (q->type != APPEND && q->type != UPDATE) return(MR_STRING);
469	id=add_string(name);
470	cache_entry(name, "STRING", id);
471	} else if (status) return(status);
472	} else if (!strcmp(data_type, "none")) {
473	id = 0;
474	} else {
475	return(MR_TYPE);
476	}
477
478	/* now set value in argv */
479	(int )argv[vo->index] = id;
480
481	return (MR_EXISTS);
482	}
483
484
485	/* Lock the table named by the validation object */
486
487	lock_table(vo)
488	struct valobj *vo;
489	{
490	sprintf(stmt_buf,"UPDATE %s SET modtime='now' WHERE %s.%s = 0",
491	vo->table,vo->table,vo->idfield);
492	EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
493	if (sqlca.sqlcode == 100){
494	fprintf(stderr,"readlock_table: no matching rows found for %s\n",
495	stmt_buf);
496	return(MR_INTERNAL);
497	}
498	if (ingres_errno)
499	return(mr_errcode);
500	if (sqlca.sqlerrd[2] != 1)
501	return(vo->error);
502	else
503	return(MR_EXISTS);
504	}
505
506	/*
507	* Get a read lock on the table by accessing the magic lock
508	* record. Certain tables are constructed so that they contain
509	* an id field whose value is zero and a modtime field. We
510	* manipulate the modtime field of the id 0 record to effect
511	* locking of the table
512	*/
513
514	readlock_table(vo)
515	struct valobj *vo;
516	{
517	EXEC SQL BEGIN DECLARE SECTION;
518	int id;
519	char buf[256];
520	char tbl, idfield;
521	EXEC SQL END DECLARE SECTION;
522
523	tbl=vo->table;
524	idfield=vo->idfield;
525	sprintf(buf,"SELECT %s FROM %s WHERE %s.%s = 0",
526	vo->idfield, vo->table, vo->table, vo->idfield);
527	EXEC SQL PREPARE stmt FROM :buf;
528	EXEC SQL DESCRIBE stmt INTO SQLDA;
529	EXEC SQL DECLARE rcsr CURSOR FOR stmt;
530	EXEC SQL OPEN rcsr;
531	EXEC SQL FETCH rcsr USING DESCRIPTOR :SQLDA;
532	/* Check for no matching rows found - this is
533	* flagged as an internal error since the table should
534	* have a magic lock record.
535	*/
536	if (sqlca.sqlcode == 100){
537	EXEC SQL CLOSE rcsr;
538	com_err(whoami,0,"readlock_table: no matching rows found for %s\n",
539	buf);
540	return(MR_INTERNAL);
541	}
542	EXEC SQL CLOSE rcsr;
543	if (ingres_errno)
544	return(mr_errcode);
545	if (sqlca.sqlcode)
546	return(vo->error);
547	return(MR_EXISTS); /* validate_fields expects us to return
548	* this value if everything went okay
549	*/
550	}
551
552	/* Check the database at startup time. For now this just resets the
553	* inprogress flags that the DCM uses.
554	*/
555
556	sanity_check_database()
557	{
558	}
559
560
561	/* Dynamic SQL support routines */
562	MR_SQLDA_T *mr_alloc_SQLDA()
563	{
564	MR_SQLDA_T *it;
565	short *null_indicators;
566	register int j;
567
568	if((it=(MR_SQLDA_T *)malloc(sizeof(MR_SQLDA_T)))==NULL) {
569	com_err(whoami, MR_NO_MEM, "setting up SQLDA");
570	exit(1);
571	}
572
573	if((null_indicators=(short *)calloc(QMAXARGS,sizeof(short)))==NULL) {
574	com_err(whoami, MR_NO_MEM, "setting up SQLDA null indicators");
575	exit(1);
576	}
577
578	for(j=0; j<QMAXARGS; j++) {
579	if((it->sqlvar[j].sqldata=(char *)malloc(sizeof(short)+ARGLEN))==NULL) {
580	com_err(whoami, MR_NO_MEM, "setting up SQLDA variables");
581	exit(1);
582	}
583	it->sqlvar[j].sqllen=ARGLEN;
584	it->sqlvar[j].sqlind=null_indicators+j;
585	null_indicators[j]=0;
586	}
587	it->sqln=QMAXARGS;
588	return it;
589	}
590
591
592	/* Use this after FETCH USING DESCRIPTOR one or more
593	* result columns may contain NULLs. This routine is
594	* not currently needed, since db/schema creates all
595	* columns with a NOT NULL WITH DEFAULT clause.
596	*
597	* This is currently dead flesh, since no Moira columns
598	* allow null values; all use default values.
599	*/
600	mr_fix_nulls_in_SQLDA(da)
601	MR_SQLDA_T *da;
602	{
603	register IISQLVAR *var;
604	register int j;
605	int *intp;
606
607	for(j=0, var=da->sqlvar; j<da->sqld; j++, var++) {
608	switch(var->sqltype) {
609	case -IISQ_CHA_TYPE:
610	if(*var->sqlind)
611	*var->sqldata='\0';
612	break;
613	case -IISQ_INT_TYPE:
614	if(*var->sqlind) {
615	intp=(int *)var->sqldata;
616	*intp=0;
617	}
618	break;
619	}
620	}
621	}
622
623	/* Convert normal Unix-style wildcards to SQL voodoo */
624	convert_wildcards(arg)
625	char *arg;
626	{
627	static char buffer[ARGLEN];
628	register char s, d;
629
630	for(d=buffer,s=arg;*s;s++) {
631	switch(*s) {
632	case '': d++='%'; *d++='%'; break;
633	case '?': *d++='_'; break;
634	case '_':
635	case '[':
636	case ']': d++=''; d++ = s; break;
637	case '%': d++=''; d++='%'; d++='%'; break;
638	default: d++ = s; break;
639	}
640	}
641	*d='\0';
642
643	/* Copy back into argv */
644	strcpy(arg,buffer);
645
646	return(MR_EXISTS);
647	}
648
649	/* This version includes uppercase conversion, for things like gmac.
650	* This is necessary because "LIKE" doesn't work with "uppercase()".
651	* Including it in a wildcard routine saves making two passes over
652	* the argument string.
653	*/
654	convert_wildcards_uppercase(arg)
655	char *arg;
656	{
657	static char buffer[ARGLEN];
658	register char s, d;
659
660	for(d=buffer,s=arg;*s;s++) {
661	switch(*s) {
662	case '': d++='%'; *d++='%'; break;
663	case '?': *d++='_'; break;
664	case '_':
665	case '[':
666	case ']': d++=''; d++ = s; break;
667	case '%': d++=''; d++='%'; d++='%'; break;
668	default: d++=toupper(s); break; /* This is the only diff. */
669	}
670	}
671	*d='\0';
672
673	/* Copy back into argv */
674	strcpy(arg,buffer);
675
676	return(MR_EXISTS);
677	}
678
679
680	/* Looks like it's time to build an abstraction barrier, Yogi */
681	mr_select_any(stmt)
682	EXEC SQL BEGIN DECLARE SECTION;
683	char *stmt;
684	EXEC SQL END DECLARE SECTION;
685	{
686	int result=0;
687
688	EXEC SQL PREPARE stmt FROM :stmt;
689	EXEC SQL DESCRIBE stmt INTO :SQLDA;
690	if(SQLDA->sqld==0) /* Not a SELECT */
691	return(MR_INTERNAL);
692	EXEC SQL DECLARE csr CURSOR FOR stmt;
693	EXEC SQL OPEN csr;
694	EXEC SQL FETCH csr USING DESCRIPTOR :SQLDA;
695	if(sqlca.sqlcode==0)
696	result=MR_EXISTS;
697	else if((sqlca.sqlcode<0) && mr_errcode)
698	result=mr_errcode;
699	else
700	result=0;
701	EXEC SQL CLOSE csr;
702	return(result);
703	}
704
705
706
707	/* Adds a string to the string table. Returns the id number.
708	*
709	*/
710	int add_string(name)
711	EXEC SQL BEGIN DECLARE SECTION;
712	char *name;
713	EXEC SQL END DECLARE SECTION;
714	{
715	EXEC SQL BEGIN DECLARE SECTION;
716	char buf[256];
717	int id;
718	EXEC SQL END DECLARE SECTION;
719
720	EXEC SQL SELECT value INTO :id FROM numvalues WHERE name = 'strings_id';
721	id++;
722	EXEC SQL UPDATE numvalues SET value = :id WHERE name = 'strings_id';
723
724	/* Use sprintf to get around problem with doubled single quotes */
725	sprintf(buf,"INSERT INTO strings (string_id, string) VALUES (%d, '%s')",id,name);
726	EXEC SQL EXECUTE IMMEDIATE :buf;
727
728	return(id);
729	}
730