conference.c

/*
 * $Id: conference.c,v 0.39 1998/07/26 16:41:57 ceder Exp $
 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996  Lysator Academic Computer Association.
 *
 * This file is part of the LysKOM server.
 * 
 * LysKOM is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by 
 * the Free Software Foundation; either version 1, or (at your option) 
 * any later version.
 * 
 * LysKOM is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with LysKOM; see the file COPYING.  If not, write to
 * Lysator, c/o ISY, Linkoping University, S-581 83 Linkoping, SWEDEN,
 * or the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, 
 * MA 02139, USA.
 *
 * Please mail bug reports to bug-lyskom@lysator.liu.se. 
 */
/*
 * conference.c
 *
 * All atomic calls that deals with conferences.
 */

static const char *
rcsid = "$Id: conference.c,v 0.39 1998/07/26 16:41:57 ceder Exp $";
#include "rcs.h"
USE(rcsid);

#include <ctype.h>
#include <stdio.h>
#include <time.h>
#include <setjmp.h>
#ifdef HAVE_STDARG_H
#  include <stdarg.h>
#endif
#include <sys/types.h>

#include "s-string.h"
#include "kom-types.h"
#include "log.h"
#include "services.h"
#include "s-string.h"
#include "cache.h"
#include "misc-types.h"
#include "s-collat-tabs.h"
#include "manipulate.h"
#include "server/smalloc.h"
#include "config.h"
#include "parser.h"
#include "com.h"
#include "async.h"
#include "connections.h"
#include "internal-connections.h"
#include "kom-errno.h"
#include "lyskomd.h"
#include "debug.h"
#include "send-async.h"
#include "param.h"
#include "aux-items.h"
#include "local-to-global.h"

/*
 * Defined in conference.c. This will go away when we use regexp-matching.
 * This is only temporary. FIXME+++***
 */
extern Conf_no       *conf_table;

/*
 * Static functions
 */

/*
 * Delete a conference. Delete all references to this conf.
 */

static void
do_delete_conf (Conf_no      conf_no,
		Conference * conf_c) /* Not NULL */
{
    int i;
    
    if ( do_set_presentation(conf_no, conf_c, 0) != OK )
    {
	log("ERROR: do_delete_conf() - couldn't unmark presentation.\n");
    }
    
    if ( do_set_etc_motd(conf_no, conf_c, 0) != OK )
    {
	log("ERROR: do_delete_conf() - couldn't unmark motd.\n");
    }

    /* Delete all members */
    /* Note that because of the way do_sub_member is written it is important */
    /* that the loop is executed this way. */
    for ( i = conf_c->members.no_of_members - 1; i >= 0; i-- )
    {
	do_sub_member( conf_no, conf_c, conf_c->members.members + i,
		      conf_c->members.members[ i ].member, NULL, NULL);
    }

    sfree( conf_c->members.members );
    conf_c->members.members = NULL;
    
    /* Delete the name */

    s_clear( &conf_c->name );
    cached_change_name( conf_no, EMPTY_STRING);
    
    /* texts */

    /*
     * The texts are not deleted at once, but since they now have no recipient
     * they will not live long.
     */

    /* ??? Note that there will still be a recipient in the texts, but it
       will not exist in reality. This might cause problems. A do_sub_recpt()
       should maybe be used. */
    /* Yes, do!  Also, send out asynchronous message about deleted conf. */

    l2g_clear(&conf_c->texts);

    cached_delete_conf( conf_no );
    
    return;
}

/*
 * Functions that are exported to the server.
 */

/*
 * Return TRUE if NAME is not already used. Set kom_errno to
 * KOM_LONG_STR or KOM_BAD_NAME if it fails.
 */

Bool
legal_name( String name )
{
    if (name.len == 0 || name.len > param.conf_name_len )
    {
        err_stat = 0;
	kom_errno = KOM_LONG_STR;
	return FALSE;
    }

    while( name.len-- )
    {
#ifdef HAVE_LOCALE_H
	if (param.force_iso_8859_1
	    ? (*name.string < ' ' ||
	       (*name.string > 126 && *name.string < ' ' + 128))
	    : !isprint(*name.string))
	{
            err_stat = 0;
	    kom_errno = KOM_BAD_NAME;
	    return FALSE;
	}
#else
	if (*name.string < ' ' ||
	    (*name.string > 126 && *name.string < ' ' + 128))
	{
            err_stat = 0;
	    kom_errno = KOM_BAD_NAME;
	    return FALSE;
	}
#endif
	name.string++;
    }

    return TRUE;
}

/*
 * Return TRUE if name is unique, or if the only match is conf_no. Use 0
 * as conf_no if it should not be allowed to be changed.
 */
Bool
unique_name( const String name, Conf_no conf_no )
{
    Parse_info   parse_info;
    Parse_token *name_token;
    Parse_token *existing_token;
    Bool	 exact_match_found;
    Bool	 diff_found;
    int i;
    int n;
        
    parse_info = parse(name, match_table, FALSE, TRUE,
		       s_fcrea_str(WHITESPACE),
		       DEFAULT_COLLAT_TAB);

    if ( parse_info.no_of_matches == 0 ) /* Doesn't match any name. */
    {
	sfree(parse_info.indexes);
	return TRUE;
    }

    if ( parse_info.no_of_matches == -1 ) /* Error. */
    {
	log("unique_name(): parse returned error.\n");
	sfree(parse_info.indexes);
	return FALSE;
    }
    
    if ( parse_info.no_of_matches == 1 && parse_info.indexes[ 0 ] == -1 )
    {
	/* Empty name is not allowed. */
	sfree(parse_info.indexes);
	return FALSE;
    }
    
    /* The name matches some conference. Check if they are equal. */

    name_token = tokenize(name, s_fcrea_str(WHITESPACE));

    exact_match_found = FALSE;
    
    for ( i = 0; !exact_match_found && i < parse_info.no_of_matches; i++ )
    {
	existing_token = match_table[ parse_info.indexes[ i ] ].tokens;
	diff_found = FALSE;
	
	for ( n = 0;
	     (!diff_found && !s_empty(existing_token[ n ].word)
	      && !s_empty(name_token[ n ].word));
	     ++n)
	{
	    if ( !s_usr_streq(existing_token[ n ].word,
			      name_token[ n ].word,
			      DEFAULT_COLLAT_TAB) )
	    {
		diff_found = TRUE;
	    }
	}

	if (! s_empty(existing_token[ n ].word)
	    || ! s_empty(name_token[ n ].word) )
	{
	    /* The length (number of words) differed. */
	    diff_found = TRUE;
	}

	if ( !diff_found && conf_table[ parse_info.indexes[ i ] ] != conf_no )
	    exact_match_found = TRUE;
    }
	    
    sfree(parse_info.indexes);
    free_tokens(name_token);
    return exact_match_found ? FALSE : TRUE;		
}

/*
 * Create a conference.
 */
static Conf_no
do_create_conf(String	 name,
	       Pers_no	 creator,
	       Conf_no	 supervisor,
	       Conf_no	 super_conf,
	       Conf_type type,
               Aux_item_list *aux)
{
    Conf_no 	 conf_no;
    Conference * conf_c;
    
    /* Prepare, then check the aux items */

    /* Allocate memory for conf_c */

    conf_no = cached_create_conf( name );

    if ( (conf_c = cached_get_conf_stat( conf_no ) ) == NULL)
    {
	restart_kom("create_conf() - can't get conf_stat");
    }

    conf_c->creator	= creator;
    conf_c->creation_time = time(NULL);
    conf_c->presentation= 0;		/* No presentation yet */
    conf_c->supervisor	= supervisor;
    conf_c->permitted_submitters = 0;
    conf_c->super_conf	= super_conf;
    conf_c->type	= type;
    conf_c->last_written= conf_c->creation_time;
    conf_c->msg_of_day	= 0;
    conf_c->nice	= param.default_nice;
    conf_c->highest_aux = 0;

    prepare_aux_item_list(aux, creator);
    if (conf_stat_check_add_aux_item_list(conf_c,
                                          conf_no,
                                          aux,
                                          creator,
                                          TRUE) != OK)
    {
        cached_delete_conf(conf_no);
        return 0;
    }

    conf_stat_add_aux_item_list(conf_c, conf_no, aux, creator);

    mark_conference_as_changed (conf_no);

    return conf_no;
}


/*
 * Return TRUE if viewer is a supervisor to CONF.
 */

Bool
is_supervisor(Conf_no conf,
              Conference *conf_c,
              Pers_no viewer,
              Person *viewer_p)
{
    if (viewer == conf)	/* A person is ALWAYS supervisor to	*/
        return TRUE;		/* his/her own mailbox!		*/

    return is_strictly_supervisor(conf, conf_c, viewer, viewer_p);
}


Bool
is_strictly_supervisor(Conf_no      conf,
                       Conference * conf_c, /* May be NULL */
                       Pers_no      viewer,
                       Person     * viewer_p) /* May be NULL */
{
    if (viewer == 0)		/* Not yet logged in. */
	return FALSE;

    if ( conf_c == NULL )	/* Get conference if unknown to the caller */
	GET_C_STAT( conf_c, conf, FALSE );
    
    if ( !conf_c->supervisor )
        return FALSE;
	
    if (viewer == conf_c->supervisor)
        return TRUE;

    if ( viewer_p == NULL )
	GET_P_STAT(viewer_p, viewer, FALSE);

    if ( locate_membership(conf_c->supervisor, viewer_p) != NULL)
	return TRUE;
    
    return FALSE;
}


/*
 * Atomic functions
 */

/*
 * Change name of a person or conference. You must be supervisor
 * of the conference to use this call.
 */
extern Success
change_name (Conf_no	   conf_no,
	     const String  new_name)
{
    Conference * conf_c;
    Access	 acc;

    CHK_LOGIN(FAILURE);
    GET_C_STAT(conf_c, conf_no, FAILURE);

    acc = access_perm (conf_no, conf_c, ACTPERS, ACT_P);

    if ( acc <= none )
    {
        err_stat = conf_no;
	kom_errno = KOM_UNDEF_CONF;
	return FAILURE;
    }

    if ( !ACT_P->privileges.change_name
	|| (acc != unlimited && !ENA(admin, 3)))
    {
        err_stat = conf_no;
	kom_errno = KOM_PERM;
	return FAILURE;
    }

    if ( !legal_name( new_name ) )
    {
	/* kom_errno will be set by legal_name(). */
	return FAILURE;
    }

    if ( !unique_name( new_name, conf_no ) )
    {
        err_stat = 0;
	kom_errno = KOM_CONF_EXISTS;
	return FAILURE;
    }

    async_new_name(conf_no, conf_c->name, new_name);

    s_strcpy(&conf_c->name, new_name);
    mark_conference_as_changed(conf_no);

    cached_change_name(conf_no, new_name);

    return OK;
}

/*
 * Create a conference: Default modes:
 *	ACTPERS becomes supervisor and super_conf.
 *	Anyone can submitt texts.
 *	Noone (not even the creator) is a member in the conf.
 *
 * If ANYONE_CAN_CREATE_NEW_CONFS (#defined in config.h) is not true
 * you must have the 'create_conf' capability.
 *
 * It is currently not allowed to have a conference that is secret
 * and not rd_prot. This restriction might be lifted in the future
 * (but I don't understand the use of such a conference...)
 */

static Conf_no
create_conf_generic(const String  name,
                    Conf_type	  type,
                    Aux_item_list *aux)
{
    Conf_no	 conf_no;
    
    CHK_LOGIN(0);

    if (param.anyone_can_create_new_confs == FALSE
	&& !HAVE_PRIV(create_conf) )
    {
        err_stat = 0;
	kom_errno = KOM_PERM;
	return 0;
    }

    if ( !legal_name( name ) )
    {
	/* kom_errno will be set by legal_name(). */
	return 0;
    }

    if ( !unique_name( name, 0 ) )
    {
        err_stat = 0;
	kom_errno = KOM_CONF_EXISTS;
	return 0;
    }

    if ( type.letter_box )	/* A letter_box can only be created via */
    {				/* create_person.			*/
	kom_errno = KOM_PERM;
	return 0;
    }

    if ( type.secret && !type.rd_prot )
    {
        err_stat = 0;
	kom_errno = KOM_SECRET_PUBLIC;
	return 0;
    }
    
    conf_no = do_create_conf(name, ACTPERS, ACTPERS, ACTPERS, type, aux);

    if ( conf_no != 0)
    {
	ACT_P->created_confs++;
	mark_person_as_changed( ACTPERS );
    }
    
    return conf_no;
}

Conf_no
create_conf_old(const String name,
                Conf_type    type)
{
    return create_conf_generic(name, type, NULL);
}

Conf_no
create_conf(const String name,
            Conf_type    type,
            Aux_item_list *aux)
{
    Conf_no     conf;

    conf = create_conf_generic(name, type, aux);
    if (conf != 0)
    {
        /* Send message no. 2 */
    }

    return conf;
}



/*
 * Log out a person from any connection he might be logged on to.
 */
static void
logout_person(Pers_no pers_no)
{
    Session_no i = 0;
    Connection *real_active_connection;

    real_active_connection = active_connection;

    while ( (i = traverse_connections(i)) != 0)
    {
	active_connection = get_conn_by_number(i);

	if ( active_connection->pers_no == pers_no )
	    logout();
    }

    active_connection = real_active_connection;
}

/*
 * Delete a conference or person. You must be supervisor of the
 * conference to be allowed to delete it.
 */
extern Success
delete_conf (Conf_no	conf_no )
{
    Conference	   * conf_c;
    Access	     acc;
    
    CHK_LOGIN(FAILURE);
    GET_C_STAT(conf_c, conf_no, FAILURE);

    acc = access_perm (conf_no, conf_c, ACTPERS, ACT_P);
    
    if ( acc != unlimited )
    {
        err_stat = conf_no;
	kom_errno = (acc <= none) ? KOM_UNDEF_CONF : KOM_PERM ;
	return FAILURE;
    }

    if ( conf_c->type.letter_box )
    {
	/* Make sure the person that is deleted is not logged in. */

	logout_person (conf_no);

	if ( do_delete_pers (conf_no) != OK )
	{
	    log("ERROR: delete_conf(): can't delete person.\n");
	}
    }

    do_delete_conf (conf_no, conf_c);

    return OK;
}

/*
 * Map conference name to number. Can be done without logging in.
 * Secret conferences will not be returned unless ACTPERS is supervisor
 * of, or member in, that conference.
 */
extern Success
lookup_name (const String    name,
	     Conf_list_old * result)
{
    Conf_no	* no, * no_copy;
    Conf_type   * type, *type_copy;
    int		i;
    
    if ( cached_lookup_name( name, result ) != OK )
	return FAILURE;

    no = no_copy = result->conf_nos;
    type = type_copy = result->type_of_conf;

    for ( i = result->no_of_conf_nos; i > 0; i-- )
    {
	if ( fast_access_perm (*no, ACTPERS, ACT_P) <= none )
	    --result->no_of_conf_nos;
	else
	{
	    *no_copy++ = *no;
	    *type_copy++ = *type;
	}

	++no;
	++type;
    }
    return OK;
}

extern Success
lookup_z_name (const String       name,
	       int                want_persons,
	       int                want_confs,
	       Conf_z_info_list * result)
{
    Conf_no	 *no;
    Conf_type    *type;
    Conf_z_info  *res;
    int		  i;
    int           n_filtered;
    Conf_list_old raw_matches;
    
    if (cached_lookup_name(name, &raw_matches) != OK)
	return FAILURE;

    no = raw_matches.conf_nos;
    type = raw_matches.type_of_conf;
    n_filtered = raw_matches.no_of_conf_nos;
    for (i = raw_matches.no_of_conf_nos; i > 0; i--)
    {
	if (*no == 0)
	    restart_kom("Internal error detected in lookup_z_name");

	if ((type->letter_box ? want_persons : want_confs) == 0
	    || fast_access_perm(*no, ACTPERS, ACT_P) <= none)
	{
	    *no = 0;
	    n_filtered--;
	}

	no++;
	type++;
    }

    result->no_of_confs = n_filtered;
    result->confs = tmp_alloc(n_filtered * sizeof(Conf_z_info));
    no = raw_matches.conf_nos;
    type = raw_matches.type_of_conf;
    res = result->confs;
    for (i = raw_matches.no_of_conf_nos; i > 0; i--)
    {
	if (*no != 0)
	{
	    res->conf_no = *no;
	    res->type = *type;
	    res->name = cached_get_name(*no);
	    res++;
	}
	no++;
	type++;
    }

    if (res != result->confs + n_filtered) 
	restart_kom("Internal error in lookup_z_name");

    return OK;
}

static Success
do_lookup (const String    name,
	   Conf_no_list * result,
	   Bool want_persons)
{
    Conf_list_old raw_match;
    unsigned long i;
    unsigned short retsize;

    if ( cached_lookup_name( name, &raw_match ) != OK )
	return FAILURE;

    /* Find out how much space we need to allocate */
    retsize = 0;
    for (i = 0; i < raw_match.no_of_conf_nos; i++)
    {
	/* Don't call check access permissions here. It doesn't matter
	   that much if we allocate slightly too much memory. */
	if (raw_match.type_of_conf[i].letter_box == want_persons)
	{
	    retsize++;
	    /* i is "unsigned long", and retsize is "unsigned short".
	       They should probably both be "Conf_no" or
	       "Conf_no_iterator".  This should never be a problem in
	       practice as long as Conf_no is a short. */
	    if (retsize == 0)
	    {
		log("WNG: do_lookup: far too many matches\n");
		--retsize;
	    }
	}
    }

    result->conf_nos = tmp_alloc(sizeof(Conf_no) * retsize);
    result->no_of_confs = 0;

    for (i = 0; i < raw_match.no_of_conf_nos; i++)
    {
	if (raw_match.type_of_conf[i].letter_box == want_persons
	    && fast_access_perm (raw_match.conf_nos[i],
				 ACTPERS, ACT_P) > none )
	{
	    result->conf_nos[result->no_of_confs++] = raw_match.conf_nos[i];
	    if (result->no_of_confs > retsize)
		restart_kom("ERROR: conference.c: do_lookup: error.\n");
	}
    }

    return OK;
}

extern  Success
lookup_person (const String  pattern,
	       Conf_no_list  *result)
{
    return do_lookup(pattern, result, TRUE);
}

extern  Success
lookup_conf (const String  pattern,
	     Conf_no_list  *result)
{
    return do_lookup(pattern, result, FALSE);
}



/*
 * Get status for a conference.
 */

extern Success
get_conf_stat(Conf_no         conf_no,
              Conference    * result)
{
    Aux_item_list    filtered;

    if (get_conf_stat_old(conf_no, result) == OK)
    {
        filter_aux_item_list(&result->aux_item_list,
                             &filtered,
                             ACTPERS,
                             ACT_P);
        result->aux_item_list = filtered;
        return OK;
    }

    return FAILURE;
}

extern  Success
get_conf_stat_old (Conf_no		  conf_no,
                   Conference           * result )
{
    Conference * conf_c;
    Access	 acc;
        
    GET_C_STAT(conf_c, conf_no, FAILURE);

    acc = access_perm (conf_no, conf_c, ACTPERS, ACT_P);

    if ( acc == error )
	return FAILURE;

    if ( acc == none )
    {
        err_stat = conf_no;
	kom_errno = KOM_UNDEF_CONF;
	return FAILURE;
    }

    *result = *conf_c;

    return OK;
}

/*
 * Get small status for a conference
 *
 * This call should not result in reading the conference from disk, hence
 * the use of fast_access_perm. Please keep it that way.
 */

extern Success
get_uconf_stat (Conf_no		conf_no,
	       Small_conf     * result)
{
    Access		acc;
    Small_conf	      * conf_c;

    conf_c = cached_get_small_conf_stat(conf_no);
    if (conf_c != NULL)
	acc = fast_access_perm (conf_no, ACTPERS, ACT_P);
    else
	acc = error;

    switch (acc)
    {
    case error:
	/* FIXME: ERROR: kom_errno may be incorrectly set at this point! */
	return FAILURE;
    case none:
        err_stat = conf_no;
	kom_errno = KOM_UNDEF_CONF;
	return FAILURE;
    default:
	*result = *conf_c;
	return OK;
    }
}

extern  Success
get_conf_stat_older (Conf_no	  conf_no,
                     int		  mask,
                     Conference	* result )
{
    Conference * conf_c;
    Access	 acc;
        
    GET_C_STAT(conf_c, conf_no, FAILURE);

    acc = access_perm (conf_no, conf_c, ACTPERS, ACT_P);

    if ( acc == error )
	return FAILURE;

    if ( acc == none )
    {
        err_stat = conf_no;
	kom_errno = KOM_UNDEF_CONF;
	return FAILURE;
    }

    *result = *conf_c;

    if ( !(mask & 1) )
	result->name = EMPTY_STRING;	

    return OK;
}


		
/*
 * Set or delete the presentation of a conference. If text_no == 0 there
 * will be no presentation.
 *
 * The text's mark-count will be increased so that it will not be deleted
 * when it gets old.
 *
 * BUGS: This should probably be a Info_type 'presentation to conf no #'
 *	 for at least two reasons:
 *		1) Given the text, there is no way to know that it
 *		   is a presentation unless what the user writes
 *		   tells you so.
 *		2) Presentations should always be readable by everyone.
 *		   But to be readable an open conference needs to be
 *		   recipient of the text. Since all presentations should
 *		   go to the presentation-confs (that is the clients
 *		   responsibility!) this is no big problem, but it depends
 *		   somewhat on how the text-garber is implemented.
 */

extern Success
set_presentation (Conf_no	conf_no,
		  Text_no	text_no )
{
    Conference * conf_c;
    Access	 acc;
    
    CHK_LOGIN(FAILURE);
    GET_C_STAT(conf_c, conf_no, FAILURE);

    acc = access_perm(conf_no, conf_c, ACTPERS, ACT_P);
    
    if ( acc < unlimited )
    {
        err_stat = conf_no;
	kom_errno = (acc <= none) ? KOM_UNDEF_CONF : KOM_PERM;
	return FAILURE;
    }

    return do_set_presentation(conf_no, conf_c, text_no);
}

/*
 * Set a message-of-the-day for a conference. There should normally
 * be no motd unless something extraordinary happens. If there is
 * a motd the client should show it as soon as possible.
 *
 * Only the supervisor can change the motd.
 *
 * BUG: +++ There is no asynchronous message that reports new motds.
 */
extern Success
set_etc_motd(	Conf_no		conf_no,
		Text_no		text_no )
{
    Conference * conf_c;
    Access	 acc;
    BUGDECL;
    
    CHK_LOGIN(FAILURE);
    GET_C_STAT(conf_c, conf_no, FAILURE);

    if ( (acc = access_perm(conf_no, conf_c, ACTPERS, ACT_P)) < unlimited )
    {
        err_stat = conf_no;
	kom_errno = (acc <= none ) ? KOM_UNDEF_CONF : KOM_PERM;
	BUG(("set_etc_motd failed. Conf %ld Text %ld Acc %ld < %ld (%d).\n",
	     (u_long)conf_no, (u_long)text_no, (u_long)acc,
	     (u_long)unlimited, acc < unlimited));
	return FAILURE;
    }

    return do_set_etc_motd(conf_no, conf_c, text_no);
}

/*
 * Set a new supervisor for a conference. May only be used by
 * the old supervisor.
 *
 * NEW_SUPER is either a person or a conference number. If it is a
 * conference number it means that all the members in NEW_SUPER become
 * supervisors to CONF_NO. (NEW_SUPER should normally be rd_prot to
 * prevent anyone from makeing themselves supervisors).
 */
extern Success
set_supervisor(	Conf_no	 conf_no,
		Conf_no	 new_super )
{
    Conference * conf_c;
    
    CHK_LOGIN(FAILURE);
    GET_C_STAT(conf_c, conf_no, FAILURE);
    if (new_super != 0)
	CHK_EXIST(new_super, FAILURE);

    if ( !is_supervisor(conf_no, conf_c, ACTPERS, ACT_P) &&
         !ENA(wheel, 8) &&
         !ENA(admin, 6) )
    {
        err_stat = conf_no;
	kom_errno = conf_c->type.secret ? KOM_UNDEF_CONF : KOM_PERM;
	return FAILURE;
    }
    
    conf_c->supervisor = new_super;
    mark_conference_as_changed( conf_no );
	
    return OK;
}

/*
 * Allow certain users to submit texts to CONF_NO.
 *
 * If NEW_PERM_SUB == 0 anyone may submit texts.
 * If it is a person only that person can submit texts to CONF_NO.
 * If it is a conference only the members in that conference can
 * submit texts.
 *
 * If anyone tries to submit a text to a conference he is not allowed
 * to submit texts to the text will silently be redirected to the
 * superconf. If he is not allowed to submit to that conference either
 * it will be redirected again and so forth, but there is a limit
 * (MAX_SUPER_CONF_LOOP) on how many redirections will be done.
 *
 * It is possible to have a secret conference as super_conf. Users
 * will then be able to send texts to it, but they will not see
 * where the text went...
 */
extern Success
set_permitted_submitters (Conf_no  conf_no,
			  Conf_no  new_perm_sub ) 
{
    Conference * conf_c;
    
    CHK_LOGIN(FAILURE);
    if (new_perm_sub != 0)
	CHK_EXIST(new_perm_sub, FAILURE);
    GET_C_STAT(conf_c, conf_no, FAILURE);

    if ( !is_supervisor(conf_no, conf_c, ACTPERS, ACT_P) &&
         !ENA(wheel, 8) &&
         !ENA(admin, 6) )
    {
        err_stat = conf_no;
	kom_errno = conf_c->type.secret ? KOM_UNDEF_CONF : KOM_PERM;
	return FAILURE;
    }
	
    conf_c->permitted_submitters = new_perm_sub;
    mark_conference_as_changed( conf_no );
	
    return OK;
}

/*
 * Set the super_conf of CONF_NO. This call may only be used of a
 * supervisor of CONF_NO.
 *
 * See documentation for set_permitted_submitters().
 */
extern Success
set_super_conf (Conf_no  conf_no,
		Conf_no  new_super_conf )
{
    Conference * conf_c;
    
    CHK_LOGIN(FAILURE);
    GET_C_STAT(conf_c, conf_no, FAILURE);
    if (new_super_conf != 0)
	CHK_EXIST(new_super_conf, FAILURE);

    if ( !is_supervisor(conf_no, conf_c, ACTPERS, ACT_P) &&
         !ENA(wheel, 8) &&
         !ENA(admin, 5) )
    {
        err_stat = conf_no;
	kom_errno = conf_c->type.secret ? KOM_UNDEF_CONF : KOM_PERM;
	return FAILURE;
    }

    conf_c->super_conf = new_super_conf;
    mark_conference_as_changed( conf_no );
	
    return OK;
}

/*
 * Set the type of a conference. Only the supervisor of a conference can
 * set the conf_type. The letter_box flag can not be changed.
 *
 * BUG: It is allowed to set the type to 'secret' for persons. I don't
 * think we want it to be that way.
 * Well, I do /DCB.
 */
extern Success
set_conf_type (Conf_no    conf_no,
	       Conf_type  type )
{
    Conference  * conf_c;
    Access	  acc;
        
    CHK_LOGIN(FAILURE);
    GET_C_STAT(conf_c, conf_no, FAILURE);

    if ( type.secret && !type.rd_prot )
    {
        err_stat = 0;
	kom_errno = KOM_SECRET_PUBLIC;
	return FAILURE;
    }

    acc = access_perm (conf_no, conf_c, ACTPERS, ACT_P) ;
    
    if ( acc < unlimited )
    {
        err_stat = conf_no;
	kom_errno = ( acc <= none ) ? KOM_UNDEF_CONF : KOM_PERM ;
	return FAILURE;
    }
    
    if ( type.letter_box != conf_c->type.letter_box )
    {
        err_stat = conf_no;
	kom_errno = KOM_LETTER_BOX;
	return FAILURE;
    }

    conf_c->type = type;
    mark_conference_as_changed (conf_no);

    return OK;
}


/*
 * Set garb_nice for a conference. This controls how long messages
 * to a conference will live. The argument is probably the number of
 * days a message will live. Only the supervisor of the conference
 * may change the garb_nice.
 */
extern Success
set_garb_nice(	Conf_no		conf_no,
		Garb_nice	nice	)	/* number of days */
{
    Conference * conf_c;
    Access	 acc;
        
    CHK_LOGIN(FAILURE);
    GET_C_STAT(conf_c, conf_no, FAILURE);

    acc = access_perm (conf_no, conf_c, ACTPERS, ACT_P);
    
    if ( acc < unlimited )
    {
        err_stat = conf_no;
	kom_errno = (acc <= none) ? KOM_UNDEF_CONF : KOM_PERM;
	return FAILURE;
    }

    conf_c->nice = nice;
    mark_conference_as_changed( conf_no );

    return OK;
}

/*
 * Set expire for a conference. This controls nothing at the moment, but
 * will probably control when a conference is killed automatically by
 * the server in cases of extreme inactivity.
 */
extern Success
set_expire(	Conf_no		conf_no,
		Garb_nice	expire	)	/* number of days */
{
    Conference * conf_c;
    Access	 acc;
        
    CHK_LOGIN(FAILURE);
    GET_C_STAT(conf_c, conf_no, FAILURE);

    acc = access_perm (conf_no, conf_c, ACTPERS, ACT_P);
    
    if ( acc < unlimited )
    {
        err_stat = conf_no;
	kom_errno = (acc <= none) ? KOM_UNDEF_CONF : KOM_PERM;
	return FAILURE;
    }

    conf_c->expire = expire;
    mark_conference_as_changed( conf_no );

    return OK;
}

/*
 * Change presentation of a conference. If text_no is 0, there will be
 * no presentation.
 */

Success
do_set_presentation(Conf_no 	 conf_no,
		    Conference * conf_c,
		    Text_no	 text_no)
{
    Text_stat * old_pres;
    Text_stat * new_pres = NULL; /* Initialized to stop gcc complaining
				  * about this being used uninitialized.
				  * This initialization is in fact not needed
				  * since it would not be used uninitialized.*/

    /* Check that the new presentation exists before deleting the old*/

    if ( text_no != 0 )
    {
	GET_T_STAT(new_pres, text_no, FAILURE);
	if ( new_pres->no_of_marks >= param.max_marks_text )
	{
	    log("%s(%d, ptr, %lu): New presentation has %d marks.\n", 
		"LIMIT: do_set_presentation",
		conf_no, (unsigned long)text_no, new_pres->no_of_marks);
            err_stat = text_no;
	    kom_errno = KOM_MARK_LIMIT;
	    return FAILURE;
	}
    }
    
    /* Unmark the previous presentation if it exists. */

    if ( conf_c->presentation != 0
	&& (old_pres = cached_get_text_stat(conf_c->presentation)) != NULL)
    {
	if ( old_pres->no_of_marks > 0 )
	{
	    --old_pres->no_of_marks;
	    mark_text_as_changed( conf_c->presentation );
	}
	else
	{
	    log("ERROR: do_set_presentation(): Old presentation not marked\n");
	}
    }

    /* Mark the new presentation */

    if ( text_no != 0 )
    {
	++new_pres->no_of_marks;
	mark_text_as_changed( text_no );
    }
    
    conf_c->presentation = text_no;
    mark_conference_as_changed( conf_no );

    return OK;
}

/*
 * Change motd of a conference. If text_no is 0, there will be
 * no motd.
 */

Success
do_set_etc_motd(Conf_no      conf_no,
		Conference * conf_c,
		Text_no      text_no)
{
    Text_stat * old_motd;
    Text_stat * new_motd = NULL; /* To stop gcc complaining. */

    /* Check that the new motd exists before deleting the old*/

    if ( text_no != 0 )
    {
	GET_T_STAT(new_motd, text_no, FAILURE);
	if ( new_motd->no_of_marks >= param.max_marks_text )
	{
	    log("LIMIT: do_set_motd(%d, ptr, %lu): New motd has %d marks.\n",
		conf_no, (unsigned long)text_no, new_motd->no_of_marks);
            err_stat = text_no;
	    kom_errno = KOM_MARK_LIMIT;
	    return FAILURE;
	}
    }
    
    /* Unmark the previous motd if it exists. */

    if ( conf_c->msg_of_day != 0
	&& (old_motd = cached_get_text_stat(conf_c->msg_of_day)) != NULL)
    {
	if ( old_motd->no_of_marks > 0 )
	{
	    --old_motd->no_of_marks;
	    mark_text_as_changed( conf_c->msg_of_day );
	}
	else
	{
	    log("ERROR: do_set_motd(): Old motd not marked\n");
	}
    }

    /* Mark the new motd */

    if ( text_no != 0 )
    {
	++new_motd->no_of_marks;
	mark_text_as_changed( text_no );
    }
    
    conf_c->msg_of_day = text_no;
    mark_conference_as_changed( conf_no );

    return OK;
}


extern Success
modify_conf_info(Conf_no        conf_no,
                 Number_list   *items_to_delete, 
                 Aux_item_list *aux)
{
    Conference     *conf;

    CHK_LOGIN(FAILURE);
    GET_C_STAT(conf, conf_no, FAILURE);

    /* Check if we may delete and add the items */

    prepare_aux_item_list(aux, ACTPERS);

    if (check_delete_aux_item_list(items_to_delete,&conf->aux_item_list)!=OK)
        return FAILURE;
    delete_aux_item_list(items_to_delete, &conf->aux_item_list,
                         CONF_OBJECT_TYPE,
                         conf_no, conf);

    if (conf_stat_check_add_aux_item_list(conf, conf_no, aux, ACTPERS,
                                          FALSE) != OK)
    {
        undelete_aux_item_list(items_to_delete, &conf->aux_item_list,
                         CONF_OBJECT_TYPE,
                         conf_no, conf);
        return FAILURE;
    }

    /* Then add the items */
    
    conf_stat_add_aux_item_list(conf, conf_no, aux, ACTPERS);


    /* FIXME: async_conf_changed(conf_no, conf);  */
    mark_conference_as_changed(conf_no);

    return OK;
}