Subversion Repositories planix.SVN

#include "common.h"

#include "send.h"

static String* s_parseq(String*, String*);

/* exports */

dest *dlist;

extern dest*

d_new(String *addr)

{

	dest *dp;

	dp = (dest *)mallocz(sizeof(dest), 1);

	if (dp == 0) {

		perror("d_new");

		exit(1);

	}

	dp->same = dp;

	dp->nsame = 1;

	dp->nchar = 0;

	dp->next = dp;

	dp->addr = escapespecial(addr);

	dp->parent = 0;

	dp->repl1 = dp->repl2 = 0;

	dp->status = d_undefined;

	return dp;

}

extern void

d_free(dest *dp)

{

	if (dp != 0) {

		s_free(dp->addr);

		s_free(dp->repl1);

		s_free(dp->repl2);

		free((char *)dp);

	}

}

/* The following routines manipulate an ordered list of items.  Insertions

 * are always to the end of the list.  Deletions are from the beginning.

 *

 * The list are circular witht the `head' of the list being the last item

 * added.

 */

/*  Get first element from a circular list linked via 'next'. */

extern dest *

d_rm(dest **listp)

{

	dest *dp;

	if (*listp == 0)

		return 0;

	dp = (*listp)->next;

	if (dp == *listp)

		*listp = 0;

	else

		(*listp)->next = dp->next;

	dp->next = dp;

	return dp;

}

/*  Insert a new entry at the end of the list linked via 'next'. */

extern void

d_insert(dest **listp, dest *new)

{

	dest *head;

	if (*listp == 0) {

		*listp = new;

		return;

	}

	if (new == 0)

		return;

	head = new->next;

	new->next = (*listp)->next;

	(*listp)->next = head;

	*listp = new;

	return;

}

/*  Get first element from a circular list linked via 'same'. */

extern dest *

d_rm_same(dest **listp)

{

	dest *dp;

	if (*listp == 0)

		return 0;

	dp = (*listp)->same;

	if (dp == *listp)

		*listp = 0;

	else

		(*listp)->same = dp->same;

	dp->same = dp;

	return dp;

}

/* Look for a duplicate on the same list */

int

d_same_dup(dest *dp, dest *new)

{

	dest *first = dp;

	if(new->repl2 == 0)

		return 1;

	do {

		if(strcmp(s_to_c(dp->repl2), s_to_c(new->repl2))==0)

			return 1;

		dp = dp->same;

	} while(dp != first);

	return 0;

}

/* Insert an entry into the corresponding list linked by 'same'.  Note that

 * the basic structure is a list of lists.

 */

extern void

d_same_insert(dest **listp, dest *new)

{

	dest *dp;

	int len;

	if(new->status == d_pipe || new->status == d_cat) {

		len = new->repl2 ? strlen(s_to_c(new->repl2)) : 0;

		if(*listp != 0){

			dp = (*listp)->next;

			do {

				if(dp->status == new->status

				&& strcmp(s_to_c(dp->repl1), s_to_c(new->repl1))==0){

					/* remove duplicates */

					if(d_same_dup(dp, new))

						return;

					/* add to chain if chain small enough */

					if(dp->nsame < MAXSAME

					&& dp->nchar + len < MAXSAMECHAR){

						new->same = dp->same;

						dp->same = new;

						dp->nchar += len + 1;

						dp->nsame++;

						return;

					}

				}

				dp = dp->next;

			} while (dp != (*listp)->next);

		}

		new->nchar = strlen(s_to_c(new->repl1)) + len + 1;

	}

	new->next = new;

	d_insert(listp, new);

}

/*

 *  Form a To: if multiple destinations.

 *  The local! and !local! checks are artificial intelligence,

 *  there should be a better way.

 */

extern String*

d_to(dest *list)

{

	dest *np, *sp;

	String *s;

	int i, n;

	char *cp;

	s = s_new();

	s_append(s, "To: ");

	np = list;

	i = n = 0;

	do {

		np = np->next;

		sp = np;

		do {

			sp = sp->same;

			cp = s_to_c(sp->addr);

			/* hack to get local! out of the names */

			if(strncmp(cp, "local!", 6) == 0)

				cp += 6;

			if(n > 20){	/* 20 to appease mailers complaining about long lines */

				s_append(s, "\n\t");

				n = 0;

			}

			if(i != 0){

				s_append(s, ", ");

				n += 2;

			}

			s_append(s, cp);

			n += strlen(cp);

			i++;

		} while(sp != np);

	} while(np != list);

	return unescapespecial(s);

}

/* expand a String of destinations into a linked list of destiniations */

extern dest *

s_to_dest(String *sp, dest *parent)

{

	String *addr;

	dest *list=0;

	dest *new;

	if (sp == 0)

		return 0;

	addr = s_new();

	while (s_parseq(sp, addr)!=0) {

		addr = escapespecial(addr);

		if(shellchars(s_to_c(addr))){

			while(new = d_rm(&list))

				d_free(new);

			break;

		}

		new = d_new(addr);

		new->parent = parent;

		new->authorized = parent->authorized;

		d_insert(&list, new);

		addr = s_new();

	}

	s_free(addr);

	return list;

}

#define isspace(c) ((c)==' ' || (c)=='\t' || (c)=='\n')

/*  Get the next field from a String.  The field is delimited by white space.

 *  Anything delimited by double quotes is included in the string.

 */

static String*

s_parseq(String *from, String *to)

{

	int c;

	if (*from->ptr == '\0')

		return 0;

	if (to == 0)

		to = s_new();

	for (c = *from->ptr;!isspace(c) && c != 0; c = *(++from->ptr)){

		s_putc(to, c);

		if(c == '"'){

			for (c = *(++from->ptr); c && c != '"'; c = *(++from->ptr))

				s_putc(to, *from->ptr);

			s_putc(to, '"');

			if(c == 0)

				break;

		}

	}

	s_terminate(to);

	/* crunch trailing white */

	while(isspace(*from->ptr))

		from->ptr++;

	return to;

}