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