static char rcsid[] = "@(#)$Id: service_list.c,v 1.31 2006/04/09 07:37:08 hurtta Exp $";

/******************************************************************************
 *  The Elm (ME+) Mail System  -  $Revision: 1.31 $   $State: Exp $
 *
 *  Author: Kari Hurtta <hurtta+elm@posti.FMI.FI> (was hurtta+elm@ozone.FMI.FI)
 *****************************************************************************/

#include "headers.h"
#include "ss_imp.h"
#include "connection_imp.h"
#ifdef USE_DLOPEN
#include "shared_imp.h"
#endif
#include "s_me.h"
#include "s_elm.h"

DEBUG_VAR(Debug,__FILE__,"net");

#ifdef REMOTE_MBX

/* Seems that h_errno is macro on AIX */
#ifndef h_errno
extern int h_errno;
#endif

#include <errno.h>
#ifndef ANSI_C
extern int errno;
#endif


struct service_entry * service_list   = NULL;
int                    service_count  = 0;


/* Hard coded */
static struct service_type {
    char * name;
    int    flags;
    PORTS  defport;
} SERVICE_TYPES[] = {
    { "*",       
      STFLAG_browser|STFLAG_mbox|
      STFLAG_is_imap|STFLAG_is_pop |
      STFLAG_smtp_like|
      STFLAG_is_submission|STFLAG_is_smtp,
      PORT_end },
    { "imap",    STFLAG_browser|STFLAG_mbox|STFLAG_is_imap,    PORT_imap4 },
    { "pop",     STFLAG_mbox|STFLAG_is_pop,                    PORT_pop3 },
    { "submission", STFLAG_smtp_like|STFLAG_is_submission,   PORT_submission },
    { "smtp",    STFLAG_smtp_like|STFLAG_is_smtp,              PORT_smtp },
    { NULL,      0,                                            PORT_end },
};


CONST struct service_type *       IMAP_SERVICE     =  & SERVICE_TYPES[1];
CONST struct service_type *        POP_SERVICE     =  & SERVICE_TYPES[2];
CONST struct service_type * SUBMISSION_SERVICE     =  & SERVICE_TYPES[3];
CONST struct service_type *       SMTP_SERVICE     =  & SERVICE_TYPES[4];


static void zero_service_entry P_((struct service_entry *entry,
				   const char *name,
				   const struct service_type *st,
				   int flags));
static void zero_service_entry(entry,name,st,flags)
     struct service_entry *entry;
     CONST char *name;
     CONST struct service_type *st;
     int flags;
{
    bzero((void *)entry,sizeof (*entry));

    entry->flags          = flags;           
    entry->official_name  = safe_strdup(name);
    entry->aliases_list   = 0;
    entry->aliases_count  = 0;
    entry->addr_list      = NULL;
    entry->addr_count     = 0;

    entry->addr_name_list  = NULL;
    entry->addr_name_count = 0;

    entry->service        = st;
    /* ??? */
    entry->port_list      = NULL;
    entry->port_count     = 0;

    entry->option_list    = NULL;
    entry->option_count   = 0;    
}

static void add_addr_name_to_entry P_((struct service_entry *entry,
				       char *name,
				       int malloc_it));
static void add_addr_name_to_entry(entry,name,malloc_it)
     struct service_entry *entry;
     char *name;
     int malloc_it;
{
    entry->addr_name_list = 
	safe_realloc(entry->addr_name_list,
		     (entry->addr_name_count+1) * 
		     sizeof (entry->addr_name_list[0]));
    entry->addr_name_list[entry->addr_name_count++]
	= malloc_it ? safe_strdup(name) : name;
}


static void add_alias_to_entry P_((struct service_entry *entry,
				   const char *name));
static void add_alias_to_entry(entry,name)
     struct service_entry *entry;
     CONST char *name;    
{
    entry->aliases_list = 
	safe_realloc(entry->aliases_list,
		     (entry->aliases_count+1) * 
		     sizeof (entry->aliases_list[0]));
    entry->aliases_list[entry->aliases_count++]
	= safe_strdup(name);
}

static void add_addr_to_entry P_((struct service_entry *entry,
				  SOCKADDR *result));
static void add_addr_to_entry(entry,result)
     struct service_entry *entry;
     SOCKADDR *result;
{
    entry->addr_list = 
	safe_realloc(entry->addr_list,
		     (entry->addr_count+1) * 
		     sizeof (entry->addr_list[0]));
    bzero((void *)&(entry->addr_list[entry->addr_count]),
	  sizeof (entry->addr_list[entry->addr_count]));

    entry->addr_list[entry->addr_count++] = *result;
}

static void add_port_to_entry P_((struct service_entry *entry,
				  int port));
static void add_port_to_entry(entry,port)
     struct service_entry *entry;
     int port;    
{
    entry->port_list = 
	safe_realloc(entry->port_list,
		     (entry->port_count+2) * 
		     sizeof (entry->port_list[0]));

    entry->port_list[entry->port_count++] = port;
    entry->port_list[entry->port_count]   = PORT_end;
}

static int add_option_type_to_entry P_((struct service_entry *entry,
					struct SE_option_type * Y,
					const char * prefix));
static int add_option_type_to_entry(entry,Y,prefix)
     struct service_entry *entry;
     struct SE_option_type * Y;
     CONST char * prefix;
{
    entry->option_list =
	safe_realloc(entry->option_list,
		     (entry->option_count+1) *
		     sizeof (entry->option_list[0]));
    bzero((void *) &(entry->option_list[entry->option_count]),
	   sizeof (entry->option_list[0]));

    entry->option_list[entry->option_count].type   = Y;
    entry->option_list[entry->option_count].prefix = safe_strdup(prefix);
    entry->option_list[entry->option_count].value = NULL;

    Y->zero_options(& (entry->option_list[entry->option_count]));
    return entry->option_count++;
}

static struct service_entry *malloc_service_entry P_((const char *name,
						      const struct 
						      service_type *st));
static struct service_entry *malloc_service_entry(name,st)
     CONST char * name;
     CONST struct service_type *st;
{
    struct service_entry *ret = safe_malloc (sizeof (struct service_entry));

    /* Free this */
    zero_service_entry(ret,name,st,SE_temporary);
   
    return ret;
}

static void merge1_entries P_((struct service_entry *target,
			       struct service_entry *value));
static void merge1_entries(target,value)
     struct service_entry *target;
     struct service_entry *value;
{

    if (target->service == &(SERVICE_TYPES[0])) {
	target->service = value->service;
	if (target->service != &(SERVICE_TYPES[0])) {
	    DPRINT(Debug,10,(&Debug,  "... setting temporary entry for %s to be type %s\n",
			     target->official_name,
			     target->service->name));
	}
    } else if (target->service != value->service &&
	       value->service != &(SERVICE_TYPES[0])) {
	DPRINT(Debug,1,(&Debug,  
			 "... conflicting service entry types. Type %s used, %s ignored\n",
			target->service->name,
			value->service->name
			));
	return;
    }

    
    if (0 != istrcmp(target->official_name,value->official_name)) {
	int j;

	for (j = 0; j < target->aliases_count; j++) {
	    if (0 == istrcmp(value->official_name,target->aliases_list[j]))
		break;
	}
	if (j >= target->aliases_count) 
	    add_alias_to_entry(target,value->official_name);
	
    }

    /* Add missing aliases */
    if (value->aliases_count > 0) {
	int i;

	for (i = 0; i < value->aliases_count; i++) {
	    int j;
	    if (0 == istrcmp(target->official_name,value->aliases_list[i]))
		continue;

	    for (j = 0; j < target->aliases_count; j++) {
		if (0 == istrcmp(value->aliases_list[i],
				 target->aliases_list[j]))
		    break;
	    }
	    if (j >= target->aliases_count) 
		add_alias_to_entry(target,value->aliases_list[i]);
	}
    }
	
    if (value->addr_name_count > 0) {
	int i;
	target->flags |= SE_given_name_addr;

	for (i = 0; i < value->addr_name_count; i++) {
	    int j;

	    for (j = 0; j < target->addr_name_count; j++) {
		if (0 == istrcmp(value->addr_name_list[i],
				 target->addr_name_list[j]))
		    break;		
	    }
	    if (j >= target->addr_name_count)
		add_addr_name_to_entry(target,
				       value->addr_name_list[i],
				       1 /* strdup it */);
	}
    }

    if (value->addr_count > 0 && (value->flags & SE_given_addr)) {
	int i;
	
	if (! (target->flags & SE_given_addr))
	    target->addr_count = 0;   /* Forget cached addresses */

	target->flags |= SE_given_addr;

	for (i = 0; i < value->addr_count; i++) {
	    int j;

	    for (j = 0; j < target->addr_count; j++) {	    

		if (0 == memcmp(&(value->addr_list[i]),
				&(target->addr_list[j]),
				sizeof (value->addr_list[i])))
		    break;
	    }
	    if (j >= target->addr_count)
		add_addr_to_entry(target,& (value->addr_list[i]));
	}
    }
    
    if (value->port_count > 0 && (value->flags & SE_given_port)) {
	int i;
	
	if (! (target->flags & SE_given_port))
	    target->port_count = 0;   /* Forget default port */

	target->flags |= SE_given_port;

	for (i = 0; i < value->port_count; i++) {
	    int j;

	    for (j = 0; j < target->port_count; j++) {	    
		if (value->port_list[i] ==
		    target->port_list[j])
		    break;
	    }

	    if (j >= target->port_count)
		add_port_to_entry(target,value->port_list[i]);	    
	}
    }

    if (value->option_count > 0) {
	int i;

	for (i = 0; i < value->option_count; i++) {
	    int j;
	    int idx = -1;
	    
	    for (j = 0; j < target->option_count; j++) {
		if (0 == strcmp(value->option_list[i].prefix,
				target->option_list[j].prefix))
		    idx = j;
	    }
	    if (-1 == idx) {
		struct SE_option_type * Y = 
#ifdef USE_DLOPEN
		    get_option_type(value->option_list[i].prefix)
#else
		    NULL
#endif
		    ;

		if (!Y) {
		    panic("CONNECTION PANIC",__FILE__,__LINE__,
			  "merge1_entries",
			  "option type disappeared",0);
		    continue;
		}
		
		idx = add_option_type_to_entry(target,Y,
					       value->option_list[i].prefix);
					       
	    }
	    if (SE_option_t_magic != target->option_list[idx].type->magic)
		panic("CONNECTION PANIC",__FILE__,__LINE__,
		      "merge1_entries",
		      "Bad option type magic on service list",0);

	    if (target->option_list[idx].type != value->option_list[i].type)
		panic("CONNECTION PANIC",__FILE__,__LINE__,
                      "merge1_entries",
                      "option type mismatch",0);

	    target->option_list[idx].type->
		merge_options(& (target->option_list[idx]),
			      & (value->option_list[i]) );
	}
    }
}

static void merge_entries P_((struct service_entry **ret,
			      struct service_entry *value));
static void merge_entries(ret,value)
     struct service_entry **ret;
     struct service_entry *value;
{
    if (value == *ret)
	return;

    if (!*ret)
	*ret = value;
    else { 
	if ((*ret)->flags & SE_temporary) {
	    merge1_entries(*ret,value);
	} else {
	    struct service_entry * A = 
		malloc_service_entry((*ret)->official_name,
				     (*ret)->service);
	    merge1_entries(A,*ret);
	    merge1_entries(A,value);
	    *ret = A;
	    DPRINT(Debug,10,(&Debug,  "... making temporary entry for %s from permanent\n",
			    (*ret)->official_name));
	}
    }
}

static int name_ok P_((CONST char *name));
static int name_ok(name)
     CONST char *name;
{
    if ('\0' == *name)
	return 0;

    return strlen(name) == strspn(name,"abcdefghijklmnopqrstuvxyz.-");
}

static void dump_service_entry P_((FILE *f, struct service_entry *entry));
static void dump_service_entry(f,entry)
     FILE *f; 
     struct service_entry *entry;
{
    char * sep = "\t";
    int idx;

    fputs(entry->official_name,f);
    putc('\t',f);
    fputs(entry->service->name,f);
	
    if (entry->flags & SE_given_alias) {
	int y;
	for (y = 0; y < entry->aliases_count; y++) {

	    if (name_ok(entry->aliases_list[y]))
		elm_fprintf(f,FRM("%salias=%s"),
			    sep,entry->aliases_list[y]);
	    else
		elm_fprintf(f,FRM("%salias=%Q"),
			    sep,entry->aliases_list[y]);
		sep = "; ";
	    }
	}

    if (entry->flags & SE_given_name_addr) {
	int y;
	for (y = 0; y < entry->addr_name_count; y++) {
	    if (name_ok(entry->addr_name_list[y]))
		elm_fprintf(f,FRM("%saddr=%s"),
			    sep,entry->addr_name_list[y]);
	    else
		elm_fprintf(f,FRM("%salias=%Q"),
			    sep,entry->addr_name_list[y]);
	    sep = "; ";
	}
    }
	
    if (entry->flags & SE_given_addr) {
	int y;
	for (y = 0; y < entry->addr_count; y++) {
	    SOCKADDR X = entry->addr_list[y];
	    switch (X.sa.sa_family) {
		char * z;
#ifdef I_NETINET_IN
	    case AF_INET:
		z = inet_ntoa(X.sin.sin_addr);
		elm_fprintf(f,FRM("%salias=ip:%Q"),
			    sep,z);
		if (ntohs(X.sin.sin_port) != PORT_end)
		    elm_fprintf(f,FRM(":%d"),
				ntohs(X.sin.sin_port));
		
		sep = "; ";
		break;
#endif
	    default:
		/* none */
		break;
	    }		
	}
    }

    if (entry->flags & SE_given_port) {
	int y;
	for (y = 0; y < entry->port_count; y++) {
	    elm_fprintf(f,FRM("%sport=%d"),
			sep,entry->port_list[y]);
	    sep = "; ";
	}
    }

    for (idx = 0; idx < entry->option_count; idx++) {
	char * val;
	
	if (SE_option_t_magic != entry->option_list[idx].type->magic)
	    panic("CONNECTION PANIC",__FILE__,__LINE__,
		  "dump_service_entry",
		  "Bad option type magic on service list",0);
	
	val = entry->option_list[idx].type->
	    give_values(& (entry->option_list[idx]),
			entry->option_list[idx].prefix);
	
	if (val) {
	    fputs(sep,f);
	    fputs(val,f);
	    free(val); val = NULL;
	}
    }
    putc('\n',f);
}				
   

static struct service_entry *scan_list P_((const char *hostname,
					   int flag));
static struct service_entry *scan_list(hostname,flag)
     CONST char *hostname;
     int flag;
{
    struct service_entry *ret = NULL;
    int i;
    
    for (i = service_count-1; i >= 0; i--) {
	if (0 != (flag & service_list[i].service->flags)) {
	    int j;
	    if (0 == istrcmp(hostname,service_list[i].official_name)) {

#ifdef DEBUG
		if (Debug.active >= 8) {
		    FILE *F;
		    DPRINT(Debug,8,(&Debug,"\n-- found [%d] ",i));
		    F = debug_to_FILE(&Debug);
		    if (F) {
			dump_service_entry(F,&(service_list[i]));
			fclose(F);
		    }
		}
#endif

		/* ret = &(service_list[i]);	     */
		merge_entries(&ret,&(service_list[i]));
	    }
	    
	    for (j = 0; j < service_list[i].aliases_count; j++) {
		if (0 == istrcmp(hostname,service_list[i].aliases_list[j])) {
#ifdef DEBUG
		if (Debug.active >= 8) {
		    FILE *F;
		    DPRINT(Debug,8,(&Debug,"\n-- found [%d] ",i));
		    F = debug_to_FILE(&Debug);
		    if (F) {
			dump_service_entry(F,&(service_list[i]));
			fclose(F);
		    }
		}
#endif

		    /* ret = &(service_list[i]); */
		    merge_entries(&ret,&(service_list[i]));
		}
	    }
	}	
    }

#ifdef DEBUG
    if (Debug.active >= 8 && ret) {
	FILE *F;
	if (ret->flags & SE_temporary) {
	    DPRINT(Debug,8,(&Debug,"\nMERGED        ",i));
	} else {
	    DPRINT(Debug,8,(&Debug,"\nRESULT        ",i));
	}
	F = debug_to_FILE(&Debug);
	if (F) {
	    dump_service_entry(F,ret);
	    fclose(F);
	}
	DPRINT(Debug,8,(&Debug,"\n"));
    }
#endif

    return ret;
}

static struct hostent * lookup_name P_((const char *hostname,int silent));
static struct hostent * lookup_name(hostname,silent)
     CONST char *hostname;
     int silent;
{
    struct hostent *he = NULL;

    lib_transient(CATGETS(elm_msg_cat, MeSet,MeLookingUp,
			  "Looking up %s ..."),
		  hostname);
	
    he = gethostbyname(hostname);
	
    if (!he) {
	DPRINT(Debug,9,(&Debug, 
			"lookup_name: %s: h_errno=%d\n",
			hostname,h_errno));
	    
	/* We are silent about errors if cached
	   data exists
	*/
	if (!silent) {
	    switch(h_errno) {
	    case HOST_NOT_FOUND:
		lib_error(CATGETS(elm_msg_cat, MeSet,MeNoRemoteHost,
				  "No remote mailbox server host: %s"),
			  hostname);		
		break;
	    case NO_ADDRESS:
		lib_error(CATGETS(elm_msg_cat, MeSet,MeNoAddress,
				  "Name %s have not IP-address"),
			  hostname);
		break;
	    case TRY_AGAIN:
		lib_error(CATGETS(elm_msg_cat, MeSet,MeTemporary,
				  "Address for %s is not yet found..."),
			  hostname);
		break;			  
	    default:
		lib_error(CATGETS(elm_msg_cat, MeSet,MeNameError,
				  "Failed to get address for %s"),
			  hostname);
		break;
	    }
	}
    } else {
	lib_transient(CATGETS(elm_msg_cat, MeSet,MeLookingUpOK,
			      "Looking up %s ... OK"),
		      hostname);

    }

    return he;
}

static void fill_address P_((struct service_entry *ret,
			     struct hostent *he));
static void fill_address(ret,he)
     struct service_entry *ret;
     struct hostent *he;
{   
    if (he->h_addr_list) {
	int x;
	for (x = 0; he->h_addr_list[x]; x++) {
	    SOCKADDR X;

	    /* Make compaarision easier */
	    bzero((void *)&X, sizeof X);

	    switch(he->h_addrtype) {
#ifdef I_NETINET_IN
	    case AF_INET:
		X.sin.sin_family = he->h_addrtype;
	        X.sin.sin_port = htons(PORT_end);    /* No port given */

		if (sizeof(X.sin.sin_addr)  != he->h_length) {
		    lib_error(FRM("%s: Bad IP-addr length %d (should be %d)"),
			      he->h_name,he->h_length,
			      sizeof(X.sin.sin_addr));
		    return;
		}
		memcpy(&(X.sin.sin_addr), he->h_addr_list[x], he->h_length);
		add_addr_to_entry(ret,&X);
		break;
#endif			    
	    default:
		lib_error(CATGETS(elm_msg_cat, MeSet,MeUnsupportedAddrType,
				  "Name %s have odd type address"),
			  he->h_name);
		/* NOTE: We do not know on what compoents arbitary
		         sockect address is constructed so we can't
			 fill it
		*/
		return;
	    }
	}
    }
}


struct service_entry * give_service_entry(hostname,flag)
     CONST char *hostname;
     int flag;
{
    struct service_entry *ret;       
    int have_port = 0;   /* set if addresses have port set */

    DPRINT(Debug,9,(&Debug, 
		    "give_service_entry(name=\"%s\",flags=%d)\n",
		    hostname,flag));

    ret = scan_list(hostname,flag);
    /* If on service entry do not have ip addresses
       they needed to be retrieved. Notice that we
       retrieve new entries every time (alternatively
       we should keep track of expiry times).
       However all other data is cached (also addresses if
       them is generated from names given on configuration data)
    */
    if (ret)
	hostname = ret->official_name;

    if (ret && (0 != (ret->flags & SE_given_name_addr) &&
		ret->addr_count == 0 ||
		0 != (ret->flags & SE_rescan_name_addr))) {
	int x;

	/* Clear data on case of rescan */
	if (ret->addr_list) {
	    free(ret->addr_list);
	    ret->addr_list = NULL;
	    ret->addr_count = 0;
	}
	ret->flags   &= ~SE_rescan_name_addr;

	for (x = 0; x < ret->addr_name_count; x++) {
	    struct hostent *he  = 
		lookup_name(ret->addr_name_list[x],0);
	    
	    if (he)
		fill_address(ret,he);
	    else
		ret->flags |= SE_rescan_name_addr;
	}
    }

    if (!ret || 
	0 == (ret->flags & SE_given_addr) &&
	0 == (ret->flags & SE_given_name_addr)) {

	struct hostent *he    = lookup_name(hostname,
					    /* Silent: */
					    ret && ret->addr_count > 0);

	if (he) {  	  
	    /* Now try found entry again ... */
	    if (!ret) { 
		ret = scan_list(he->h_name,flag);
		
		if (!ret && he->h_aliases) {
		    int j;
		    for (j = 0; he->h_aliases[j] && !ret; j++)
			ret = scan_list(he->h_aliases[j],flag);
		}
	    
		/* we need to add hostname to aliases because
		   it was not on there (otherwise entry
		   should have found earlier)
		*/
		if (ret) 
		    add_alias_to_entry(ret,hostname);
	    }
	    
	    if (!ret) {
		struct service_type *st;

		for (st = &SERVICE_TYPES[0]; st->name; st++) {
		    if (flag == (flag &st->flags))
			break;
		}

		if (!st->name)
		    panic("CONNECTION PANIC",__FILE__,__LINE__,
			  "give_service_entry",
			  "Service type do not found", 0);

		ret = malloc_service_entry(hostname,st);

	    }
	
	    if (he->h_aliases) {  /* Add missing aliases */
		int x;
		for (x = 0; he->h_aliases[x]; x++) {
		    int j;
		    for (j=0; j < ret->aliases_count; j++)
			if (0 == istrcmp(he->h_aliases[x],
					 ret->aliases_list[j]))
			    break;
		    if (j >= ret->aliases_count) 
			add_alias_to_entry(ret,he->h_aliases[x]);
		}
	    }

	    if (he->h_addr_list) {
		/* Clear old data */
	    	if (ret->addr_list) {
		    free(ret->addr_list);
		    ret->addr_list = NULL;
		    ret->addr_count = 0;
		}

		fill_address(ret,he);
	    }		
	}    
    }

    if (ret && ret->addr_count > 0) {
	int x;

	for (x = 0; x < ret->addr_count; x++) {
	    switch(ret->addr_list[x].sa.sa_family) {
#ifdef I_NETINET_IN
	    case AF_INET:
		if (ret->addr_list[x].sin.sin_port == htons(PORT_end))
		    have_port = 0;
		break;
#endif
	    default:
		have_port = 0;
		break;
	    }
	}
    }


    if (ret && ret->port_count == 0 && !have_port) {
	PORTS r = PORT_end;
	
	/* builtin definations here */
	if ( PORT_end == ret->service->defport) {
	    
	    /* Caller will define portlist */
	    if (ret->port_list)
	 	free(ret->port_list);
	    ret->port_list = NULL;
	    
	} else 
	    r = ret->service->defport;
	
	if (r != PORT_end) {
	    ret->port_list = safe_realloc(ret->port_list,
					  2 * sizeof (ret->port_list[0]));
	    ret->port_list[0] = r;
	    ret->port_list[1] = PORT_end;
	    ret->port_count  = 1;
	}
    }

    if (ret) {
	DPRINT(Debug,9,(&Debug, 
			"give_service_entry=%p: type=%p (%s)%s\n",
			ret,ret->service,ret->service->name,
			ret->flags & SE_temporary ? ", temporary" : ""));
    } else {
	DPRINT(Debug,9,(&Debug, 
			"give_service_entry=NULL\n"));
    }

    return ret;
}

void free_temporary_service_entry(Y)
     struct service_entry **Y;
{
    if (!(*Y))
	return;

    if ((*Y)->flags  & SE_temporary) {
	int x;

	DPRINT(Debug,12,(&Debug, 
			 "free_temporary_service_entry: Freeing entry %p\n",
			 *Y));
	if ((*Y)->official_name)
	    free((*Y)->official_name);
	(*Y)->official_name = NULL;

	for (x = 0; x < (*Y)->aliases_count; x++) {
	    if ((*Y)->aliases_list[x])
		free((*Y)->aliases_list[x]);
	    (*Y)->aliases_list[x] = NULL;
	}
	if ((*Y)->aliases_list)
	    free((*Y)->aliases_list);
	(*Y)->aliases_list  = NULL;
	(*Y)->aliases_count = 0;

	if ((*Y)->addr_list)
	    free((*Y)->addr_list);
	(*Y)->addr_list = NULL;
	(*Y)->addr_count = 0;

	for (x = 0; x < (*Y)->addr_name_count; x++) {
	    if ((*Y)->addr_name_list[x])
		free((*Y)->addr_name_list[x]);
	    (*Y)->addr_name_list[x] = NULL;
	}
	if ((*Y)->addr_name_list)
	    free((*Y)->addr_name_list);
	(*Y)->addr_name_list = NULL;
	(*Y)->addr_name_count = 0;

	(*Y)->service = NULL;

	if ((*Y)->port_list)
	    free((*Y)->port_list);
	(*Y)->port_list  = NULL;
	(*Y)->port_count = 0;

	for (x = 0; x < (*Y)->option_count; x++) {
	    if (SE_option_t_magic != (*Y)->option_list[x].type->magic)
		panic("CONNECTION PANIC",__FILE__,__LINE__,
		      "free_temporary_service_entry",
		      "Bad option type magic on service list",0);
	    (*Y)->option_list[x].type->
		free_options(& ((*Y)->option_list[x]));	    

	    if ((*Y)->option_list[x].prefix)
		free((*Y)->option_list[x].prefix);
	    (*Y)->option_list[x].prefix = NULL;
	}
	if ((*Y)->option_list)
	    free((*Y)->option_list);
	(*Y)->option_list = NULL;
	(*Y)->option_count = 0;

	/* Temporary entry is malloced ... */
	free(*Y);
    }
    /* If not temporary, we assume that this entry is on list
       and therefore that does not produce dangling pointer
    */
    (*Y) = NULL;
}

int parse_service_entries (filename,system, errors)
     CONST char *filename; 
     int system;
     int *errors;
{
    /*   hostname   service        options               */
    int max_count = 0;
    int count = 0;
    FILE * f;
    char buf[LONG_STRING];
    int c, l1;

    if (!system) {
	int err = can_open(filename,"r");
	
	if (err) {
	    DPRINT(Debug,2,(&Debug, 
			    "parse_service_entries=0: %s: %s (can_open)\n",
			    filename,error_description(err)));
	    return 0;
	}
    }

    f = fopen(filename,"r");
    if (!f) {
	int err = errno;
	DPRINT(Debug,2,(&Debug, 
			"parse_service_entries=0: %s: %s\n",
			filename,error_description(err)));
	return 0;
    }
    
    while(EOF != (c = fgetc(f)))
	if ('\n' == c)
	    max_count++;

    DPRINT(Debug,9,(&Debug, 
		    "parse_service_entries: %s, max_count=%d\n",
		    filename,max_count));
    
    if (!max_count) {
	fclose(f);
	return 0;
    }
    rewind(f);

    service_list = safe_realloc(service_list,
				(service_count + max_count) *
				sizeof (service_list[0]));

    while (count < max_count && 
	   (l1 = mail_gets(buf,sizeof buf, f)) > 0) {
	char *c,*c1, *options;
	struct service_type *st;

	if ('\n' == buf[l1 -1]) 
	    buf[l1 - 1] = '\0';
	else {
	    lib_error(CATGETS(elm_msg_cat, MeSet, MeTooLongLine,
			      "%.30s: Too long line: %.30s..."),
		      filename,buf);
	    (*errors) ++;
	    break;
	}
	l1--;

	while (l1-- > 0 && whitespace(buf[l1]))
	    buf[l1] = '\0';

	c = buf;
	while (*c && whitespace (*c)) /* skip leading whitespace */
	    c++;
	if ('#' == *c)
	    continue;
	if (!*c)
	    continue;

	c1 = strpbrk(c," \t");
	if (!c1) {
	    lib_error(CATGETS(elm_msg_cat, MeSet, MeBadLine,
			      "%.30s: Bad line: %.30s..."),
		      filename,buf);
	    (*errors) ++;
	    break;	    
	}
	*c1 = '\0';
	c1++;

	while (*c1 && whitespace (*c1)) /* skip leading whitespace */
	    c1++;
	if (!*c1) {
	    lib_error(CATGETS(elm_msg_cat, MeSet, MeBadLine,
			      "%.30s: Bad line: %.30s..."),
		      filename,buf);
	    (*errors) ++;
	    break;	    
	}
	
	options = strpbrk(c1," \t;");
	if (options) {
	    *options = '\0';
	    options++;
	}
	
	for (st = &SERVICE_TYPES[0]; st->name; st++) 
	    if (0 == istrcmp(c1,st->name))
		break;

	if (!st->name) {
	    lib_error(CATGETS(elm_msg_cat, MeSet, MeServiceType,
			      "%.30s: Bad service type %s"),
		      filename,c1);
	    (*errors) ++;
	    break;	    	    
	}

	zero_service_entry( & (service_list[service_count+count]),
			    c  /* hostname */,
			    st /* service */,
			    0  /* This is NOT temporary entry */);

	if (system)
	    service_list[service_count+count].flags |= SE_system;
		
	if (options) {
	    char *opt;
	    char * WALK = NULL;

	    for (opt = mime_parse_content_opts(options, &WALK); 
		 opt; 
		 opt = mime_parse_content_opts(NULL, &WALK)) {
		char *val = NULL;          /* malloced by dequote_opt */ 
		char * q = strchr(opt,'=');
		char * zopt = NULL;

		DPRINT(Debug,65,(&Debug, 
				 "mime_parse_content_opts gives: %s\n",
				 opt));
		
		if (q) 
		    *q++ = '\0';		    

		if (0 == strcmp(opt,"alias")) {
		    if (!q || !q[0]) {
			lib_error(CATGETS(elm_msg_cat, MeSet, MeOptionReqValue,
					  "%.30s: Option %s requires value"),
				  filename,opt);
			(*errors) ++;
			continue;
		    }

		    val = dequote_opt(q,strlen(q));		
		    add_alias_to_entry(& (service_list[service_count+count]),
				       val);
		    free(val);  /* add_alias_to_entry strdup's value */
		    service_list[service_count+count].flags |= SE_given_alias;

		} else if (0 == strcmp(opt,"addr")) {
		    char *q1 = NULL;
		    if (!q || !q[0]) {
			lib_error(CATGETS(elm_msg_cat, MeSet, MeOptionReqValue,
					  "%.30s: Option %s requires value"),
				  filename,opt);
			(*errors) ++;
			continue;
		    }
		    if ('"' != q[0])
			q1 = strchr(q,':');

		    if (!q1) { /* name given */
			add_addr_name_to_entry(&(service_list[service_count+count]),
					       /* Malloces result */
					       dequote_opt(q,strlen(q)),
					       0);
			service_list[service_count+count].flags |= 
			    SE_given_name_addr;
		    } else {  /* Addr? given */
			SOCKADDR result;
#ifndef USE_INET_ATON
			long tmp;
#endif
			char * port;

			/* Make comparision easier */
			bzero((void *)&result, sizeof result);

			*q1++ = '\0';
			port = qstrpbrk(q1,":/");
			if (port)
			    *port++ = '\0';
			val = dequote_opt(q1,strlen(q1));		

			/* inet_aton() is better but not available on
			   some systems so we need use inet_addr()
			*/

#ifdef I_NETINET_IN			
			if (0 == strcmp(q,"ip") &&
#ifdef USE_INET_ATON
			    inet_aton(q1,&result.sin.sin_addr)
#else
			    -1 != (tmp = inet_addr(q1)) 
#endif
			    ) {
			    int p = PORT_end;   /* No port given */

#ifndef USE_INET_ATON
			    memcpy(&(result.sin.sin_addr.s_addr),
				   &tmp,
				   sizeof (result.sin.sin_addr.s_addr));
#endif

			    result.sin.sin_family = AF_INET;
			    if (port)
				p = atoi(port);
			    result.sin.sin_port = htons(p);
			} else
#endif			
			    {
				lib_error(CATGETS(elm_msg_cat, MeSet,
						  MeBadAddrSpec,
						  "%.30s: Bad address specification %s:%s"),
					  filename,q,q1);	
				(*errors) ++;
				free(val); val= NULL;
				continue;			    
			    }	

			add_addr_to_entry(& (service_list[service_count+
							 count]),
					  &result);
			free(val); val = NULL;
			service_list[service_count+count].flags |= 
			    SE_given_addr;
		    }
		} else if (0 == strcmp(opt,"port")) {
		    int port;
		    if (!q || !q[0]) {
			lib_error(CATGETS(elm_msg_cat, MeSet, MeOptionReqValue,
					  "%.30s: Option %s requires value"),
				  filename,opt);
			(*errors) ++;
			continue;
		    }

		    port = atoi(q);

		    if (port == PORT_end) {
			lib_error(CATGETS(elm_msg_cat, MeSet, MeOptionPortBad,
					  "%.30s: Option port=%d unsupported"),
				  filename,
				  port);
			(*errors) ++;
			continue;
		    }

		    add_port_to_entry(& (service_list[service_count+count]),
				      port);
		    service_list[service_count+count].flags |= 
			SE_given_port;

#ifdef USE_DLOPEN
		} else if (NULL != (zopt = strchr(opt,':'))) {
		    int idx = -1;
		    int x;

		    *zopt++ = '\0';

		    for (x = 0; x < service_list[service_count+count].
			     option_count; x++) {
			if (0 == strcmp(opt,service_list[service_count+count].
			    option_list[x].prefix))
			    idx = x;
		    }
		    if (-1 == idx) {
			struct SE_option_type * Y = get_option_type(opt);
			if (!Y)
			    continue;

			idx = 
			    add_option_type_to_entry(& (service_list
							[service_count+count]),
						     Y,opt);
		    }

		    if (SE_option_t_magic != 
			service_list[service_count+count].
			option_list[idx].type->magic)
			panic("CONNECTION PANIC",__FILE__,__LINE__,
			      "parse_service_entries",
			      "Bad option type on service list",0);

		    if (!service_list[service_count+count].
			option_list[idx].type ->
			parse_on_option(& (service_list[service_count+count].
					   option_list[idx]),
					zopt,q)) {
			(*errors) ++;
			continue;
		    }					   
#endif
		} else {
		    lib_error(CATGETS(elm_msg_cat, MeSet, MeOptionUnspported,
				      "%.30s: Option %s unsupported"),
			      filename,opt);
		    (*errors) ++;
		    continue;
		}
	    }

	}

	count++;	    
    }

    service_count += count;
    DPRINT(Debug,9,(&Debug, 		    
		    "parse_service_entries: %s, %d parsed (%d total)\n",
		    filename,count,service_count));
    fclose(f);
    return 1;
}

void dump_service_entries(f,system)
     FILE *f; 
     int system;
{
    int x;

    for (x = 0; x < service_count; x++) {

	if (system &&
	    (service_list[x].flags & SE_system) == 0)
	    continue;
	if (!system &&
	    (service_list[x].flags & SE_system) != 0)
	    continue;
	
	dump_service_entry(f,&(service_list[x]));
    }
    fflush(f);
}
#endif


/*
 * Local Variables:
 *  mode:c
 *  c-basic-offset:4
 *  buffer-file-coding-system: iso-8859-1
 * End:
 */