/*	$OpenBSD: names.c,v 1.23 2015/10/16 17:56:07 mmcc Exp $	*/

/*	$NetBSD: names.c,v 1.5 1996/06/08 19:48:32 christos Exp $	*/

/*

 * Copyright (c) 1980, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

/*

 * Mail -- a mail program

 *

 * Handle name lists.

 */

#include "rcv.h"

#include <fcntl.h>

#include "extern.h"

/*

 * Allocate a single element of a name list,

 * initialize its name field to the passed

 * name and return it.

 */

struct name *

nalloc(char *str, int ntype)

{

	struct name *np;

}

/*

 * Find the tail of a list and return it.

 */

struct name *

tailof(struct name *name)

{

	struct name *np;

	np = name;

		np = np->n_flink;

}

/*

 * Extract a list of names from a line,

 * and make a list of names from it.

 * Return the list or NULL if none found.

 */

struct name *

extract(char *line, int ntype)

{

	char *cp;

	struct name *top, *np, *t;

	char *nbuf;

	top = NULL;

	np = NULL;

	cp = line;

		else

		np = t;

	}

}

/*

 * Turn a list of names into a string of the same names.

 */

char *

detract(struct name *np, int ntype)

{

	int s, comma;

	char *cp, *top;

	struct name *p;

	s = 0;

			continue;

	}

	cp = top;

			continue;

	}

}

/*

 * Grab a single word (liberal word)

 * Throw away things between ()'s, and take anything between <>.

 */

char *

yankword(char *ap, char *wbuf)

{

	char *cp, *cp2;

	cp = ap;

			int nesting = 0;

				case '(':

				case ')':

				}

					break;

			}

		else

			break;

	}

			;

	else

			;

}

/*

 * For each recipient in the passed name list with a /

 * in the name, append the message to the end of the named file

 * and remove him from the recipient list.

 *

 * Recipients whose name begins with | are piped through the given

 * program and removed.

 */

struct name *

outof(struct name *names, FILE *fo, struct header *hp)

{

	int c, ispipe;

	struct name *np, *top;

	char *date, *fname;

	FILE *fout, *fin;

	top = names;

	np = names;

		}

		else

		/*

		 * See if we have copied the complete message out yet.

		 * If not, do so.

		 */

			int fd;

			}

			}

		}

		/*

		 * Now either copy "image" to the desired file

		 * or give it as the standard input to the desired

		 * program as appropriate.

		 */

			pid_t pid;

			char *shell;

			/*

			 * XXX

			 * We can't really reuse the same image file,

			 * because multiple piped recipients will

			 * share the same lseek location and trample

			 * on one another.

			 */

			}

			int f;

			}

				fin = NULL;

			}

			}

		}

cant:

		/*

		 * In days of old we removed the entry from the

		 * the list; now for sake of header expansion

		 * we leave it in and mark it as deleted.

		 */

	}

	}

/*

 * Determine if the passed address is a local "send to file" address.

 * If any of the network metacharacters precedes any slashes, it can't

 * be a filename.  We cheat with .'s to allow path names like ./...

 */

int

isfileaddr(char *name)

{

	char *cp;

	}

}

/*

 * Map all of the aliased users in the invoker's mailrc

 * file and insert them into the list.

 * Changed after all these months of service to recursively

 * expand names (2/14/80).

 */

struct name *

usermap(struct name *names)

{

	struct name *new, *np, *cp;

	struct grouphead *gh;

	int metoo;

	new = NULL;

	np = names;

			np = cp;

		}

		else

		np = cp;

	}

}

/*

 * Recursively expand a group name.  We limit the expansion to some

 * fixed level to keep things from going haywire.

 * Direct recursion is not expanded for convenience.

 */

struct name *

gexpand(struct name *nlist, struct grouphead *gh, int metoo, int ntype)

{

	struct group *gp;

	struct grouphead *ngh;

	struct name *np;

	static int depth;

	char *cp;

	}

			goto quote;

			goto quote;

		}

quote:

		/*

		 * At this point should allow to expand

		 * to self if only person in group

		 */

			goto skip;

skip:

	}

}

/*

 * Concatenate the two passed name lists, return the result.

 */

struct name *

cat(struct name *n1, struct name *n2)

{

	struct name *tail;

/*

 * Remove all of the duplicates from the passed name list by

 * insertion sorting them, then checking for dups.

 * Return the head of the new list.

 */

struct name *

elide(struct name *names)

{

	struct name *np, *t, *new;

	struct name *x;

	new = names;

	np = names;

		t = new;

				break;

			t = t->n_flink;

		}

		/*

		 * If we ran out of t's, put the new entry after

		 * the current value of t.

		 */

			t = np;

		}

		/*

		 * Otherwise, put the new entry in front of the

		 * current t.  If at the front of the list,

		 * the new guy becomes the new head of the list.

		 */

			t = np;

			new = t;

		}

		/*

		 * The normal case -- we are inserting into the

		 * middle of the list.

		 */

		x = np;

	}

	/*

	 * Now the list headed up by new is sorted.

	 * Go through it and remove duplicates.

	 */

	np = new;

		t = np;

		}

		/*

		 * Now t points to the last entry with the same name

		 * as np.  Make np point beyond t.

		 */

	}

/*

 * Put another node onto a list of names and return

 * the list.

 */

struct name *

put(struct name *list, struct name *node)

{

}

/*

 * Determine the number of undeleted elements in

 * a name list and return it.

 */

int

count(struct name *np)

{

	int c;

}

/*

 * Delete the given name from a namelist.

 */

struct name *

delname(struct name *np, char *name)

{

	struct name *p;

			}

				continue;

			}

		}

}

/*

 * Pretty print a name list

 * Uncomment it if you need it.

 */

#if 0

void

prettyprint(struct name *name)

{

	struct name *np;

	np = name;

	while (np != NULL) {

		fprintf(stderr, "%s(%d) ", np->n_name, np->n_type);

		np = np->n_flink;

	}

	putc('\n', stderr);

}

#endif