[moira.git] / server / qoldsup.qc

/*
 *  These are query support routines that are specific to the old version
 *  of the protocol.  This file may be removed once support for the old
 *  protocol has been discontinued.
 *
 *	$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_qc = "$Header$";
#endif lint

#include <mit-copyright.h>
#include "query.h"
#include "sms_server.h"
#include <ctype.h>


extern char *whoami;


add_locker() { return(SMS_UNKNOWN_PROC); }
add_user_group() { return(SMS_UNKNOWN_PROC); }


/* Specialized Access Routines */


/**
 ** access_maillist - access_list + disallow adding user-group to maillists
 **
 ** Inputs:
 **   argv[0] - list_id
 **   cl - client name
 **
 **/

access_maillist(q, argv, cl)
    struct query *q;
    char *argv[];
    client *cl;
##{
##  int list_id;
##  int exists;
##  char list_name[32];
    int status;

    if ((status = access_list(q, argv, cl)) != SMS_SUCCESS)
	return(status);
    if (strcmp(q->name, "add_maillist"))
	return(status);

    list_id = *(int *)argv[0];
##  range of l is list
##  repeat retrieve (exists = any(l.#list_id 
##			      where l.group != 0 and l.#list_id = @list_id))
    if (!exists) return(SMS_SUCCESS);
##  repeat retrieve (exists = any(users.login where users.login = l.name and
##						    l.#list_id = @list_id))
    return ((exists) ? SMS_USER_GROUP : SMS_SUCCESS);
##}


\f
/* Setup Routines */


\f
/* FOLLOWUP ROUTINES */

/* followup_gpob: fixes argv[2] based on the IDs currently there and the
 * type in argv[1].  Then completes the upcall to the user.
 *
 * argv[2] is of the form "123:234" where the first integer is the machine
 * ID if it is a pop box, and the second is the string ID if it is an SMTP
 * box.  argv[1] should be "POP", "SMTP", or "NONE".  Boxes of type NONE
 * are skipped.
 *
 * followup_old_gpob does the same thing for old style queries.  The format
 * is a little different and there is one more argument, but the idea is
 * the same.
 */

followup_old_gpob(q, sq, v, action, actarg, cl)
    register struct query *q;
    register struct save_queue *sq;
    register struct validate *v;
    register int (*action)();
    int actarg;
    client *cl;
##{
    char **argv, *p, *index();
    char *ptype;
##  char mach[129], box[129];
##  int id, rowcount;

    /* for each row */
    while (sq_get_data(sq, &argv)) {
	ptype = argv[1];
	sms_trim_args(2, argv);

	if (!strcmp(ptype, "POP")) {
	    id = atoi(argv[2]);
##	    repeat retrieve (mach=machine.name) where machine.mach_id=@id
	    strcpy(box, argv[0]);
	} else if (!strcmp(ptype, "SMTP")) {
	    id = atoi(argv[3]);
##	    repeat retrieve (box=strings.string) where strings.string_id=@id
##	    inquire_equel(rowcount = "rowcount")
	    if (rowcount != 1)
		return(SMS_STRING);
	    p = index(box, '@');
	    if (p) {
		*p++ = 0;
		strcpy(mach, p);
	    } else
		strcpy(mach, "");
	} else /* ptype == "NONE" */ {
	    goto skip;
	}

	free(argv[2]);
	argv[2] = mach;
	free(argv[3]);
	argv[3] = box;
	(*action)(q->vcnt, argv, actarg);
    skip:
	/* free saved data */
	free(argv[0]);
	free(argv[1]);
	free(argv);
    }

    sq_destroy(sq);
    return (SMS_SUCCESS);
##}

\f
/* Specialized query routines */

/* set_user_pobox - this does all of the real work.
 * argv = user_id, type, machine, box
 */
int set_user_pobox(q, argv, cl)
    struct query *q;
    char **argv;
    client *cl;
##{
##  int user, id, rowcount;
##  char *host;
##  char buffer[256];

    host = argv[2];
    user = *(int *)argv[0];

    if (!strcmp(argv[1], "POP")) {
##	repeat retrieve (id=machine.mach_id) where machine.name=uppercase(@host)
##	inquire_equel(rowcount = "rowcount")
	if (rowcount == 0)
	    return(SMS_MACHINE);
##	replace users (potype="POP", pop_id=id) where users.users_id = user
    } else if (!strcmp(argv[1], "SMTP")) {
	sprintf(buffer, "%s@%s", argv[3], host);
##      range of s is strings
##      repeat retrieve (id = s.string_id) where s.string = @buffer
##      inquire_equel (rowcount = "rowcount")
	if (rowcount == 0) {
##          range of v is values
##          repeat retrieve (id = v.value) where v.name = "strings_id"
	    id++;
##          repeat replace v (value = @id) where v.name = "strings_id"
##	    append to strings (string_id = id, string = buffer)
	}
##	repeat replace users (potype="SMTP",box_id=@id) 
##	       where users.users_id = @user
    } else /* argv[1] == "NONE" */ {
##	repeat replace users (potype="NONE") where users.users_id = @user
    }
    set_old_pop_usage(q, argv, 1);
    set_pobox_modtime(q, argv, cl);
    return(SMS_SUCCESS);
##}

followup_delete_pobox(q, argv, cl)
    struct query *q;
    char *argv[];
    client *cl;
{
    set_old_pop_usage(q, argv, -1);
    set_pobox_modtime(q, argv, cl);
    return(SMS_SUCCESS);
}

/** set_old_pop_usage - incr/decr usage count for pop server in serverhosts
 ** table
 **
 ** Inputs:
 **   q->name - "add_pobox" or "delete_pobox"
 **   argv[1] - type
 **   argv[2] - mach_id
 **
 ** Description:
 **   - incr/decr value field in serverhosts table for pop/mach_id
 **
 **/

set_old_pop_usage(q, argv, count)
    struct query *q;
    char *argv[];
##{
##  int mach_id;
##  int n;

    if (bcmp(argv[1], "POP", 3)) return(SMS_SUCCESS);

    mach_id = *(int *)argv[2];
    n = count;

##  range of sh is serverhosts
##  repeat replace sh (value1 = sh.value1 + @n)
##         where sh.service = "pop" and sh.#mach_id = @mach_id

    return(SMS_SUCCESS);
##}


/* Finds "acl_type:acl_name" in the argv (index depends on query) and
 * replaces it with the list or user name.
 */

followup_fix_acl(q, sq, v, action, actarg, cl)
    register struct query *q;
    register struct save_queue *sq;
    register struct validate *v;
    register int (*action)();
    int actarg;
    client *cl;
##{
    char **argv, *p, *index(), *malloc();
##  char *name, *acl;
##  int id, i, rowcount;
    int idx;

    if (!strcmp(q->shortname, "gaml"))
	idx = 1;
    else if (!strcmp(q->shortname, "gamd"))
	idx = 1;
    else
	idx = 2;

    while (sq_get_data(sq, &argv)) {
	name = argv[idx];
	p = index(name, ':');
	*p++ = 0;
	id = atoi(p);
	if ((acl = malloc(33)) == NULL)
	    return(SMS_NO_MEM);
	if (!strcmp(name, "LIST")) {
##	    repeat retrieve (acl = list.#name) where list.list_id = @id
##	    inquire_equel(rowcount = "rowcount")
	    if (rowcount != 1)
		strcpy(acl, "???");
	} else if (!strcmp(name, "USER")) {
##	    repeat retrieve (acl = users.login) where users.users_id = @id
##	    inquire_equel(rowcount = "rowcount")
	    if (rowcount != 1)
		strcpy(acl, "???");
	} else
	  strcpy(acl, "???");
	free(argv[idx]);
	argv[idx] = acl;

	/* send the data */
	(*action)(q->vcnt, argv, actarg);

	/* free saved data */
	for (i = 0; i < q->vcnt; i++) 
	    free(argv[i]);
	free(argv);
    }

    sq_destroy(sq);
    return (SMS_SUCCESS);
##}


/**
 ** get_list_is_group
 ** get_list_is_maillist
 **
 ** Inputs:
 **   argv[0] - list_id
 **
 ** Returns:
 **   {true | false}
 **
 **/

get_list_is_group(q, argv, cl, action, actarg)
    struct query *q;
    char *argv[];
    client *cl;
    int (*action)();
    int actarg;
##{
##  int exists, list_id, rowcount;
    char *result;

    list_id = *(int *)argv[0];

##  range of l is list
##  repeat retrieve (exists = l.group) where l.#list_id = @list_id
##  inquire_equel(rowcount = "rowcount")
    if (rowcount != 1)
	return(SMS_NOT_UNIQUE);

    result = (exists) ? "true" : "false";
    (*action)(1, &result, actarg);
    return(SMS_SUCCESS);
##}

get_list_is_maillist(q, argv, cl, action, actarg)
    struct query *q;
    char *argv[];
    client *cl;
    int (*action)();
    int actarg;
##{
##  int exists, list_id, rowcount;
    char *result;

    list_id = *(int *)argv[0];

##  range of l is list
##  repeat retrieve (exists = l.maillist) where l.#list_id = @list_id
##  inquire_equel(rowcount = "rowcount")
    if (rowcount != 1)
	return(SMS_NOT_UNIQUE);

    result = (exists) ? "true" : "false";
    (*action)(1, &result, actarg);
    return(SMS_SUCCESS);
##}


/* implements the get lists of administrator query.  It's fairly 
 * straightforward, but too complex for the regular query table.
 * First retrieve any lists with a USER acl which matches the 
 * specified user.  Then retrieve any lists with an acl which is a
 * list which has the specified user as a member.
 */

get_lists_of_administrator(q, argv, cl, action, actarg)
    struct query *q;
    char *argv[];
    client *cl;
    int (*action)();
    int actarg;
##{
##  int user;
##  char name[33];
    char *args;

##  range of l is list
##  range of m is members
    user  = *(int *) argv[0];
    args = name;

##  repeat retrieve (name = l.#name) 
##	where l.acl_type = "USER" and l.acl_id = @user {
	    (*action)(1, &args, actarg);
##  }

##  repeat retrieve (name = l.#name)
##	where l.acl_type = "LIST" and l.acl_id = m.#list_id
##	    and m.member_type = "USER" and m.member_id = @user {
	    (*action)(1, &args, actarg);
##  }
    return(SMS_SUCCESS);
##}


/**
 ** Setup routine for add_group
 **
 ** Inputs: none
 **
 ** Description: allocate next gid and store in values table
 **
 **/

setup_add_group(q, argv, cl)
    struct query *q;
    char *argv[];
    client *cl;
##{
##  int ngid, exists, rowcount, list_id;
    int status;

##  range of l is list
##  range of v is values
    list_id = *(int *)argv[0];

##  repeat retrieve (exists = l.group) where l.#list_id = @list_id
    if (exists)
	return(SMS_EXISTS);

##  repeat retrieve (ngid = v.value) where v.name = "gid"
    exists = 1;
    while (exists) {
	ngid++;
##      repeat retrieve (exists = any(l.#gid where l.#gid = @ngid))
    }

##  repeat replace v (value = @ngid) where v.name = "gid"
##  inquire_equel (rowcount = "rowcount")
    if (rowcount != 1) return SMS_INGRES_ERR;
    else return(SMS_SUCCESS);
##}

/**
 ** get_groups_of_user - optimized query for retrieval of all groups to
 **                      which a user belongs
 **
 **/

get_groups_of_user(q, argv, cl, action, actarg)
    struct query *q;
    char *argv[];
    client *cl;
    int (*action)();
    int actarg;
##{
##  int users_id;
##  char list_name[33];
##  char gid[11];
##  int rowcount;
    char *targv[2];

    users_id = *(int *)argv[0];
    targv[0] = list_name;
    targv[1] = gid;

##  range of m is members
##  range of l is list

##  repeat retrieve (list_name = l.name, gid = text(l.#gid))
##         where m.member_id = @users_id and m.member_type = "USER" and
##               m.list_id = l.list_id and l.group != 0
##         sort by #list_name
##  {
	 (*action)(2, targv, actarg);
##  }
##  inquire_equel (rowcount = "rowcount")

    return ((rowcount = 0) ? SMS_NO_MATCH : SMS_SUCCESS);
##}

get_groups_of_all_users(q, argv, cl, action, actarg)
    struct query *q;
    char *argv[];
    client *cl;
    int (*action)();
    int actarg;
##{
##  char login[9];
##  char group[33];
##  char gid[11];
    char *targv[3];
##  int errorno;

    targv[0] = login;
    targv[1] = group;
    targv[2] = gid;

##  range of u is users
##  range of l is list
##  range of m is members

##  set lockmode session where readlock = nolock

##  repeat retrieve (login = u.#login, group = l.name, gid = text(l.#gid))
##         where m.member_type = "USER" and m.member_id = u.users_id and
##               u.status != 0 and m.list_id = l.list_id and l.group != 0
##         sort by #login, #group
##  {
	 (*action)(3, targv, actarg);
##  }

##  inquire_equel (errorno = "errorno")
##  set lockmode session where readlock = system

    return((errorno) ? SMS_INGRES_ERR : SMS_SUCCESS);
##}


/* expand_list_flags - takes the flag value stuffed into list.active of
 * 	the list just created, and expands that value into hidden & public,
 *	then sets the modtime on the list.
 */
expand_list_flags(q, argv, cl)
    struct query *q;
    char **argv;
    client *cl;
##{
##  int id, flags, active, public, hidden, who;
##  char *entity;

    if (!strcmp(q->shortname, "ulis")) {
	id = *(int *)argv[0];
    } else {
##    repeat retrieve (id = values.value) where values.name = "list_id"
    }

##  repeat retrieve (flags = l.#active) where l.list_id = @id
    active = flags & 1;
    public = (flags & 2) >> 1;
    hidden = (flags & 4) >> 2;
    entity = cl->entity;
    who = cl->users_id;
##  repeat replace l (#active = @active, #public = @public, #hidden = @hidden,
##	modtime = "now", modby = @who, modwith = @entity)
##	 where l.list_id = @id
    return(SMS_SUCCESS);
##}


/**
 ** add_new_quota
 ** delete_current_quota - adjust nfsphys values on xxx_quota queries.
 **
 ** Inputs:
 **   argv[0] - mach_id
 **   argv[1] - device
 **   argv[2] - users_id
 **   argv[3] - quota (add_new_quota only)
 **
 ** Description:
 **   delete_current_quota:
 **     - find nfsquota entry
 **     - decrement nfsphys.allocated by nfsquota.quota
 **   add_new_quota
 **     - increment nfsphys.allocated by quota
 **
 **/

add_new_quota(q, argv, cl)
    struct query *q;
    register char *argv[];
    client *cl;
##{
##  int mach_id;
##  char *device;
##  int quota;

    mach_id = *(int*)argv[0];
    device = argv[1];
    quota = *(int *)argv[3];

##  range of np is nfsphys
##  repeat replace np (allocated = np.allocated + @quota)
##      where np.#mach_id = @mach_id and np.#device = @device

    return(SMS_SUCCESS);
##}

delete_current_quota(q, argv, cl)
    struct query *q;
    register char *argv[];
    client *cl;
##{
##  int mach_id;
##  int users_id;
##  char *device;
##  int quota;

    mach_id = *(int *)argv[0];
    device = argv[1];
    users_id = *(int *)argv[2];

##  range of np is nfsphys
##  range of nq is nfsquota
##  repeat retrieve (quota = nq.#quota) 
##      where nq.#mach_id = @mach_id and nq.#device = @device and
##            nq.#users_id = @users_id
##  repeat replace np (allocated = np.allocated - @quota)
##      where np.#mach_id = @mach_id and np.#device = @device
 
    return(SMS_SUCCESS);
##}


/**
 ** delete_locker - special query routine for deleting a user locker
 **
 ** Inputs:
 **   argv[0] - users_id
 ** 
 ** Description:
 **   - get login name from users_id
 **   - get filesys entry from login
 **   - use filesys.mach_id and filesys.name to determine machine/device
 **     pair for nfsphys and nfsquota
 **   - delete filesys entry (label=<login>)
 **   - decrement allocated in nfsphys by quota
 **   - delete nfsquota entry
 **
 ** Errors:
 **   - SMS_FILESYS - no filesys exists for user
 ** 
 **/

delete_locker(q, argv)
    register struct query *q;
    register char *argv[];
##{
##  int users_id;
##  int mach_id;
##  int quota;
##  int rowcount;
##  char login[9];
##  char lname[64];
##  char ndev[32];
    char *rindex();
    register char *c;

    /* copy arguments */
    users_id = *(int *)argv[0];

##  range of u is users
##  range of f is filesys
##  range of np is nfsphys
##  range of nq is nfsquota
##  range of tbs is tblstats

    /* get login name */
##  repeat retrieve (login = u.#login) where u.#users_id = @users_id

    /* get mach_id and locker name from filesys entry; then delete it */
##  repeat retrieve (mach_id = f.#mach_id, lname = f.#name)
##         where f.#label = @login
##  inquire_equel (rowcount = "rowcount")
    if (rowcount == 0) return(SMS_FILESYS);
##  repeat delete f where f.#label = @login

    /* get prefix directory */
    c = rindex(lname, '/');
    *c = 0;

    /* get nfs device */
##  repeat retrieve (ndev = np.device) 
##         where np.#mach_id = @mach_id and np.dir = @lname

    /* get quota from nfsquota entry; then delete entry */
##  repeat retrieve (quota = nq.#quota)
##         where nq.#mach_id = @mach_id and nq.#device = @ndev and
##               nq.#users_id = @users_id
##  repeat delete nq where nq.#mach_id = @mach_id and nq.#device = @ndev and
##                  nq.#users_id = @users_id

    /* decrement nfsphys.allocated */
##  repeat replace np (allocated = np.allocated - @quota)
##         where np.#mach_id = @mach_id and np.#device = @ndev

    /* adjust table statistics */
##  repeat replace tbs (deletes = tbs.deletes + 1, modtime = "now")
##             where tbs.table = "filesys"
##  repeat replace tbs (updates = tbs.updates + 1, modtime = "now")
##             where tbs.table = "nfsphys"
##  repeat replace tbs (deletes = tbs.deletes + 1, modtime = "now")
##             where tbs.table = "nfsquota"

    return(SMS_SUCCESS);
##}
Commit	Line	Data
e8660f0a	1	/*
	2	* These are query support routines that are specific to the old version
	3	* of the protocol. This file may be removed once support for the old
	4	* protocol has been discontinued.
	5	*
	6	* $Source$
	7	* $Author$
	8	* $Header$
	9	*
	10	* Copyright (C) 1987 by the Massachusetts Institute of Technology
c801de4c	11	* For copying and distribution information, please see the file
c801de4c	12	* <mit-copyright.h>.
e8660f0a	13	*
	14	*/
	15
	16	#ifndef lint
	17	static char *rcsid_qsupport_qc = "$Header$";
	18	#endif lint
	19
c801de4c	20	#include <mit-copyright.h>
e8660f0a	21	#include "query.h"
	22	#include "sms_server.h"
	23	#include <ctype.h>
	24
	25
	26	extern char *whoami;
	27
	28
	29	add_locker() { return(SMS_UNKNOWN_PROC); }
	30	add_user_group() { return(SMS_UNKNOWN_PROC); }
	31
	32
	33	/* Specialized Access Routines */
	34
	35
	36	/**
	37	** access_maillist - access_list + disallow adding user-group to maillists
	38	**
	39	** Inputs:
	40	** argv[0] - list_id
	41	** cl - client name
	42	**
	43	**/
	44
	45	access_maillist(q, argv, cl)
	46	struct query *q;
	47	char *argv[];
	48	client *cl;
	49	##{
	50	## int list_id;
	51	## int exists;
	52	## char list_name[32];
	53	int status;
	54
	55	if ((status = access_list(q, argv, cl)) != SMS_SUCCESS)
	56	return(status);
	57	if (strcmp(q->name, "add_maillist"))
	58	return(status);
	59
	60	list_id = (int )argv[0];
	61	## range of l is list
	62	## repeat retrieve (exists = any(l.#list_id
	63	## where l.group != 0 and l.#list_id = @list_id))
	64	if (!exists) return(SMS_SUCCESS);
	65	## repeat retrieve (exists = any(users.login where users.login = l.name and
	66	## l.#list_id = @list_id))
	67	return ((exists) ? SMS_USER_GROUP : SMS_SUCCESS);
	68	##}
	69
	70
	71	\f
	72	/* Setup Routines */
	73
	74
	75	\f
	76	/* FOLLOWUP ROUTINES */
	77
	78	/* followup_gpob: fixes argv[2] based on the IDs currently there and the
	79	* type in argv[1]. Then completes the upcall to the user.
	80	*
	81	* argv[2] is of the form "123:234" where the first integer is the machine
	82	* ID if it is a pop box, and the second is the string ID if it is an SMTP
	83	* box. argv[1] should be "POP", "SMTP", or "NONE". Boxes of type NONE
	84	* are skipped.
85	*
86	* followup_old_gpob does the same thing for old style queries. The format
87	* is a little different and there is one more argument, but the idea is
88	* the same.
89	*/
90
91	followup_old_gpob(q, sq, v, action, actarg, cl)
92	register struct query *q;
93	register struct save_queue *sq;
94	register struct validate *v;
95	register int (*action)();
96	int actarg;
97	client *cl;
98	##{
99	char *argv, p, *index();
100	char *ptype;
101	## char mach[129], box[129];
102	## int id, rowcount;
103
104	/* for each row */
105	while (sq_get_data(sq, &argv)) {
106	ptype = argv[1];
107	sms_trim_args(2, argv);
108
109	if (!strcmp(ptype, "POP")) {
110	id = atoi(argv[2]);
111	## repeat retrieve (mach=machine.name) where machine.mach_id=@id
112	strcpy(box, argv[0]);
113	} else if (!strcmp(ptype, "SMTP")) {
114	id = atoi(argv[3]);
115	## repeat retrieve (box=strings.string) where strings.string_id=@id
116	## inquire_equel(rowcount = "rowcount")
117	if (rowcount != 1)
118	return(SMS_STRING);
119	p = index(box, '@');
120	if (p) {
121	*p++ = 0;
122	strcpy(mach, p);
123	} else
124	strcpy(mach, "");
125	} else /* ptype == "NONE" */ {
126	goto skip;
127	}
128
129	free(argv[2]);
130	argv[2] = mach;
131	free(argv[3]);
132	argv[3] = box;
133	(*action)(q->vcnt, argv, actarg);
134	skip:
135	/* free saved data */
136	free(argv[0]);
137	free(argv[1]);
138	free(argv);
139	}
140
141	sq_destroy(sq);
142	return (SMS_SUCCESS);
143	##}
144
145	\f
146	/* Specialized query routines */
147
148	/* set_user_pobox - this does all of the real work.
149	* argv = user_id, type, machine, box
150	*/
151	int set_user_pobox(q, argv, cl)
152	struct query *q;
153	char **argv;
154	client *cl;
155	##{
156	## int user, id, rowcount;
157	## char *host;
158	## char buffer[256];
159
160	host = argv[2];
161	user = (int )argv[0];
162
163	if (!strcmp(argv[1], "POP")) {
164	## repeat retrieve (id=machine.mach_id) where machine.name=uppercase(@host)
165	## inquire_equel(rowcount = "rowcount")
166	if (rowcount == 0)
167	return(SMS_MACHINE);
168	## replace users (potype="POP", pop_id=id) where users.users_id = user
169	} else if (!strcmp(argv[1], "SMTP")) {
170	sprintf(buffer, "%s@%s", argv[3], host);
171	## range of s is strings
172	## repeat retrieve (id = s.string_id) where s.string = @buffer
173	## inquire_equel (rowcount = "rowcount")
174	if (rowcount == 0) {
175	## range of v is values
176	## repeat retrieve (id = v.value) where v.name = "strings_id"
177	id++;
178	## repeat replace v (value = @id) where v.name = "strings_id"
179	## append to strings (string_id = id, string = buffer)
180	}
181	## repeat replace users (potype="SMTP",box_id=@id)
182	## where users.users_id = @user
183	} else /* argv[1] == "NONE" */ {
184	## repeat replace users (potype="NONE") where users.users_id = @user
185	}
186	set_old_pop_usage(q, argv, 1);
187	set_pobox_modtime(q, argv, cl);
188	return(SMS_SUCCESS);
189	##}
190
191	followup_delete_pobox(q, argv, cl)
192	struct query *q;
193	char *argv[];
194	client *cl;
195	{
196	set_old_pop_usage(q, argv, -1);
197	set_pobox_modtime(q, argv, cl);
198	return(SMS_SUCCESS);
199	}
200
201	/** set_old_pop_usage - incr/decr usage count for pop server in serverhosts
202	** table
203	**
204	** Inputs:
205	** q->name - "add_pobox" or "delete_pobox"
206	** argv[1] - type
207	** argv[2] - mach_id
208	**
209	** Description:
210	** - incr/decr value field in serverhosts table for pop/mach_id
211	**
212	**/
213
214	set_old_pop_usage(q, argv, count)
215	struct query *q;
216	char *argv[];
217	##{
218	## int mach_id;
219	## int n;
220
221	if (bcmp(argv[1], "POP", 3)) return(SMS_SUCCESS);
222
223	mach_id = (int )argv[2];
224	n = count;
225
226	## range of sh is serverhosts
227	## repeat replace sh (value1 = sh.value1 + @n)
228	## where sh.service = "pop" and sh.#mach_id = @mach_id
229
230	return(SMS_SUCCESS);
231	##}
232
233
234	/* Finds "acl_type:acl_name" in the argv (index depends on query) and
235	* replaces it with the list or user name.
236	*/
237
238	followup_fix_acl(q, sq, v, action, actarg, cl)
239	register struct query *q;
240	register struct save_queue *sq;
241	register struct validate *v;
242	register int (*action)();
243	int actarg;
244	client *cl;
245	##{
246	char *argv, p, index(), malloc();
247	## char name, acl;
248	## int id, i, rowcount;
249	int idx;
250
251	if (!strcmp(q->shortname, "gaml"))
252	idx = 1;
253	else if (!strcmp(q->shortname, "gamd"))
254	idx = 1;
255	else
256	idx = 2;
257
258	while (sq_get_data(sq, &argv)) {
259	name = argv[idx];
260	p = index(name, ':');
261	*p++ = 0;
262	id = atoi(p);
263	if ((acl = malloc(33)) == NULL)
264	return(SMS_NO_MEM);
265	if (!strcmp(name, "LIST")) {
266	## repeat retrieve (acl = list.#name) where list.list_id = @id
267	## inquire_equel(rowcount = "rowcount")
268	if (rowcount != 1)
269	strcpy(acl, "???");
270	} else if (!strcmp(name, "USER")) {
271	## repeat retrieve (acl = users.login) where users.users_id = @id
272	## inquire_equel(rowcount = "rowcount")
273	if (rowcount != 1)
274	strcpy(acl, "???");
275	} else
276	strcpy(acl, "???");
277	free(argv[idx]);
278	argv[idx] = acl;
279
280	/* send the data */
281	(*action)(q->vcnt, argv, actarg);
282
283	/* free saved data */
284	for (i = 0; i < q->vcnt; i++)
285	free(argv[i]);
286	free(argv);
287	}
288
289	sq_destroy(sq);
290	return (SMS_SUCCESS);
291	##}
292
293
294	/**
295	** get_list_is_group
296	** get_list_is_maillist
297	**
298	** Inputs:
299	** argv[0] - list_id
300	**
301	** Returns:
302	** {true \| false}
303	**
304	**/
305
306	get_list_is_group(q, argv, cl, action, actarg)
307	struct query *q;
308	char *argv[];
309	client *cl;
310	int (*action)();
311	int actarg;
312	##{
313	## int exists, list_id, rowcount;
314	char *result;
315
316	list_id = (int )argv[0];
317
318	## range of l is list
319	## repeat retrieve (exists = l.group) where l.#list_id = @list_id
320	## inquire_equel(rowcount = "rowcount")
321	if (rowcount != 1)
322	return(SMS_NOT_UNIQUE);
323
324	result = (exists) ? "true" : "false";
325	(*action)(1, &result, actarg);
326	return(SMS_SUCCESS);
327	##}
328
329	get_list_is_maillist(q, argv, cl, action, actarg)
330	struct query *q;
331	char *argv[];
332	client *cl;
333	int (*action)();
334	int actarg;
335	##{
336	## int exists, list_id, rowcount;
337	char *result;
338
339	list_id = (int )argv[0];
340
341	## range of l is list
342	## repeat retrieve (exists = l.maillist) where l.#list_id = @list_id
343	## inquire_equel(rowcount = "rowcount")
344	if (rowcount != 1)
345	return(SMS_NOT_UNIQUE);
346
347	result = (exists) ? "true" : "false";
348	(*action)(1, &result, actarg);
349	return(SMS_SUCCESS);
350	##}
351
352
353	/* implements the get lists of administrator query. It's fairly
354	* straightforward, but too complex for the regular query table.
355	* First retrieve any lists with a USER acl which matches the
356	* specified user. Then retrieve any lists with an acl which is a
357	* list which has the specified user as a member.
358	*/
359
360	get_lists_of_administrator(q, argv, cl, action, actarg)
361	struct query *q;
362	char *argv[];
363	client *cl;
364	int (*action)();
365	int actarg;
366	##{
367	## int user;
368	## char name[33];
369	char *args;
370
371	## range of l is list
372	## range of m is members
373	user = (int ) argv[0];
374	args = name;
375
376	## repeat retrieve (name = l.#name)
377	## where l.acl_type = "USER" and l.acl_id = @user {
378	(*action)(1, &args, actarg);
379	## }
380
381	## repeat retrieve (name = l.#name)
382	## where l.acl_type = "LIST" and l.acl_id = m.#list_id
383	## and m.member_type = "USER" and m.member_id = @user {
384	(*action)(1, &args, actarg);
385	## }
386	return(SMS_SUCCESS);
387	##}
388
389
390	/**
391	** Setup routine for add_group
392	**
393	** Inputs: none
394	**
395	** Description: allocate next gid and store in values table
396	**
397	**/
398
399	setup_add_group(q, argv, cl)
400	struct query *q;
401	char *argv[];
402	client *cl;
403	##{
404	## int ngid, exists, rowcount, list_id;
405	int status;
406
407	## range of l is list
408	## range of v is values
409	list_id = (int )argv[0];
410
411	## repeat retrieve (exists = l.group) where l.#list_id = @list_id
412	if (exists)
413	return(SMS_EXISTS);
414
415	## repeat retrieve (ngid = v.value) where v.name = "gid"
416	exists = 1;
417	while (exists) {
418	ngid++;
419	## repeat retrieve (exists = any(l.#gid where l.#gid = @ngid))
420	}
421
422	## repeat replace v (value = @ngid) where v.name = "gid"
423	## inquire_equel (rowcount = "rowcount")
424	if (rowcount != 1) return SMS_INGRES_ERR;
425	else return(SMS_SUCCESS);
426	##}
427
428	/**
429	** get_groups_of_user - optimized query for retrieval of all groups to
430	** which a user belongs
431	**
432	**/
433
434	get_groups_of_user(q, argv, cl, action, actarg)
435	struct query *q;
436	char *argv[];
437	client *cl;
438	int (*action)();
439	int actarg;
440	##{
441	## int users_id;
442	## char list_name[33];
443	## char gid[11];
444	## int rowcount;
445	char *targv[2];
446
447	users_id = (int )argv[0];
448	targv[0] = list_name;
449	targv[1] = gid;
450
451	## range of m is members
452	## range of l is list
453
454	## repeat retrieve (list_name = l.name, gid = text(l.#gid))
455	## where m.member_id = @users_id and m.member_type = "USER" and
456	## m.list_id = l.list_id and l.group != 0
457	## sort by #list_name
458	## {
459	(*action)(2, targv, actarg);
460	## }
461	## inquire_equel (rowcount = "rowcount")
462
463	return ((rowcount = 0) ? SMS_NO_MATCH : SMS_SUCCESS);
464	##}
465
466	get_groups_of_all_users(q, argv, cl, action, actarg)
467	struct query *q;
468	char *argv[];
469	client *cl;
470	int (*action)();
471	int actarg;
472	##{
473	## char login[9];
474	## char group[33];
475	## char gid[11];
476	char *targv[3];
477	## int errorno;
478
479	targv[0] = login;
480	targv[1] = group;
481	targv[2] = gid;
482
483	## range of u is users
484	## range of l is list
485	## range of m is members
486
487	## set lockmode session where readlock = nolock
488
489	## repeat retrieve (login = u.#login, group = l.name, gid = text(l.#gid))
490	## where m.member_type = "USER" and m.member_id = u.users_id and
491	## u.status != 0 and m.list_id = l.list_id and l.group != 0
492	## sort by #login, #group
493	## {
494	(*action)(3, targv, actarg);
495	## }
496
497	## inquire_equel (errorno = "errorno")
498	## set lockmode session where readlock = system
499
500	return((errorno) ? SMS_INGRES_ERR : SMS_SUCCESS);
501	##}
502
503
504	/* expand_list_flags - takes the flag value stuffed into list.active of
505	* the list just created, and expands that value into hidden & public,
506	* then sets the modtime on the list.
507	*/
508	expand_list_flags(q, argv, cl)
509	struct query *q;
510	char **argv;
511	client *cl;
512	##{
513	## int id, flags, active, public, hidden, who;
514	## char *entity;
515
516	if (!strcmp(q->shortname, "ulis")) {
517	id = (int )argv[0];
518	} else {
519	## repeat retrieve (id = values.value) where values.name = "list_id"
520	}
521
522	## repeat retrieve (flags = l.#active) where l.list_id = @id
523	active = flags & 1;
524	public = (flags & 2) >> 1;
525	hidden = (flags & 4) >> 2;
526	entity = cl->entity;
527	who = cl->users_id;
528	## repeat replace l (#active = @active, #public = @public, #hidden = @hidden,
529	## modtime = "now", modby = @who, modwith = @entity)
530	## where l.list_id = @id
531	return(SMS_SUCCESS);
532	##}
533
534
535	/**
536	** add_new_quota
537	** delete_current_quota - adjust nfsphys values on xxx_quota queries.
538	**
539	** Inputs:
540	** argv[0] - mach_id
541	** argv[1] - device
542	** argv[2] - users_id
543	** argv[3] - quota (add_new_quota only)
544	**
545	** Description:
546	** delete_current_quota:
547	** - find nfsquota entry
548	** - decrement nfsphys.allocated by nfsquota.quota
549	** add_new_quota
550	** - increment nfsphys.allocated by quota
551	**
552	**/
553
554	add_new_quota(q, argv, cl)
555	struct query *q;
556	register char *argv[];
557	client *cl;
558	##{
559	## int mach_id;
560	## char *device;
561	## int quota;
562
563	mach_id = (int)argv[0];
564	device = argv[1];
565	quota = (int )argv[3];
566
567	## range of np is nfsphys
568	## repeat replace np (allocated = np.allocated + @quota)
569	## where np.#mach_id = @mach_id and np.#device = @device
570
571	return(SMS_SUCCESS);
572	##}
573
574	delete_current_quota(q, argv, cl)
575	struct query *q;
576	register char *argv[];
577	client *cl;
578	##{
579	## int mach_id;
580	## int users_id;
581	## char *device;
582	## int quota;
583
584	mach_id = (int )argv[0];
585	device = argv[1];
586	users_id = (int )argv[2];
587
588	## range of np is nfsphys
589	## range of nq is nfsquota
590	## repeat retrieve (quota = nq.#quota)
591	## where nq.#mach_id = @mach_id and nq.#device = @device and
592	## nq.#users_id = @users_id
593	## repeat replace np (allocated = np.allocated - @quota)
594	## where np.#mach_id = @mach_id and np.#device = @device
595
596	return(SMS_SUCCESS);
597	##}
598
599
600	/**
601	** delete_locker - special query routine for deleting a user locker
602	**
603	** Inputs:
604	** argv[0] - users_id
605	**
606	** Description:
607	** - get login name from users_id
608	** - get filesys entry from login
609	** - use filesys.mach_id and filesys.name to determine machine/device
610	** pair for nfsphys and nfsquota
611	** - delete filesys entry (label=<login>)
612	** - decrement allocated in nfsphys by quota
613	** - delete nfsquota entry
614	**
615	** Errors:
616	** - SMS_FILESYS - no filesys exists for user
617	**
618	**/
619
620	delete_locker(q, argv)
621	register struct query *q;
622	register char *argv[];
623	##{
624	## int users_id;
625	## int mach_id;
626	## int quota;
627	## int rowcount;
628	## char login[9];
629	## char lname[64];
630	## char ndev[32];
631	char *rindex();
632	register char *c;
633
634	/* copy arguments */
635	users_id = (int )argv[0];
636
637	## range of u is users
638	## range of f is filesys
639	## range of np is nfsphys
640	## range of nq is nfsquota
641	## range of tbs is tblstats
642
643	/* get login name */
644	## repeat retrieve (login = u.#login) where u.#users_id = @users_id
645
646	/* get mach_id and locker name from filesys entry; then delete it */
647	## repeat retrieve (mach_id = f.#mach_id, lname = f.#name)
648	## where f.#label = @login
649	## inquire_equel (rowcount = "rowcount")
650	if (rowcount == 0) return(SMS_FILESYS);
651	## repeat delete f where f.#label = @login
652
653	/* get prefix directory */
654	c = rindex(lname, '/');
655	*c = 0;
656
657	/* get nfs device */
658	## repeat retrieve (ndev = np.device)
659	## where np.#mach_id = @mach_id and np.dir = @lname
660
661	/* get quota from nfsquota entry; then delete entry */
662	## repeat retrieve (quota = nq.#quota)
663	## where nq.#mach_id = @mach_id and nq.#device = @ndev and
664	## nq.#users_id = @users_id
665	## repeat delete nq where nq.#mach_id = @mach_id and nq.#device = @ndev and
666	## nq.#users_id = @users_id
667
668	/* decrement nfsphys.allocated */
669	## repeat replace np (allocated = np.allocated - @quota)
670	## where np.#mach_id = @mach_id and np.#device = @ndev
671
672	/* adjust table statistics */
673	## repeat replace tbs (deletes = tbs.deletes + 1, modtime = "now")
674	## where tbs.table = "filesys"
675	## repeat replace tbs (updates = tbs.updates + 1, modtime = "now")
676	## where tbs.table = "nfsphys"
677	## repeat replace tbs (deletes = tbs.deletes + 1, modtime = "now")
678	## where tbs.table = "nfsquota"
679
680	return(SMS_SUCCESS);
681	##}