/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2001,2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 */

//  DATable.java:     Interface for DATables.
//  Author:           James Kempf
//  Created On:       Mon May 11 13:46:02 1998
//  Last Modified By: James Kempf
//  Last Modified On: Mon Feb 22 15:47:37 1999
//  Update Count:     53
//


package com.sun.slp;

/**
 * DATable is an abstract class that provides the interface for DA
 * and scope discovery. A variety of implementations are possible.
 * The getDATable() method creates the right one from a subclass.
 *
 * @author James Kempf
 */

import java.util.*;
import java.net.*;

abstract class DATable extends Object {

    protected static DATable daTable;
    protected static SLPConfig conf;

    // System property naming the DATable implementation class to use.

    final static String DA_TABLE_CLASS_PROP = "sun.net.slp.DATableClass";

    // SA only scopes property.

    final static String SA_ONLY_SCOPES_PROP = "sun.net.slp.SAOnlyScopes";

    // Hashtable key for multicast scopes.

    final static String MULTICAST_KEY = "&&**^^MULTICASTxxxKEY^^**&&";

    // Hashtable key for DA equivalence classes.

    final static String UNICAST_KEY = "&&**^^UNICASTxxxKEY^^**&&";

    /**
     * A record for all DAs supporting exactly the same set of scopes.
     *
     * @author James Kempf
     */


    public static class DARecord extends Object {

	// The scopes supported.

	Vector scopes = null;		// String scope names

	Vector daAddresses = new Vector();  // InetAddress DA addresses

    }

    /**
     * Return a hashtable containing two entries:
     *
     * MULTICAST_KEY - Vector of scopes from the incoming vector that are not
     * supported by any known DA.
     *
     * UNICAST_KEY - Vector of DATable.DARecord objects containing
     * equivalence classes of DAs that all support the same set of scopes.
     * Only DAs supporting one or more scopes in the incoming vector
     * are returned.
     *
     * Note that the equivalence classes don't necessarily mean that the
     * set of scopes are mutually exclusive. For example, if DA1 supports
     * scopes A, B, and C; and DA2 supports scopes C and D, then they
     * are in separate equivalence classes even though they both support
     * C. But if DA2 supports A, B, and C; then it is in the same equivalence
     * class.
     *
     * @param scopes The scopes for which DAs are required.
     * @return A Hashtable with the multicast scopes and DAAddresses.
     */

    abstract Hashtable findDAScopes(Vector scopes)
	throws ServiceLocationException;

    /**
     * Remove a DA by address.
     *
     * @param address The host address of the DA.
     * @param scopes The scopes.
     * @return True if removed, false if not.
     */

    abstract boolean removeDA(InetAddress address, Vector scopes);

    /**
     * Return a vector of scopes that the SA or UA client should use.
     * Note that if no DAs are around, SA adverts must be used to
     * find SAs. We must sort through the returned DAs and apply
     * the scope prioritization algorithm to them.
     *
     * @return Vector of scopes for the SA or UA client to use.
     */

    synchronized Vector findScopes() throws ServiceLocationException {

	// First, get the DA addresses v.s. scopes table from the DAtable.
	//  This will also include DA addresses from the configuration file,
	//  if any. We don't filter on any scopes, since we want all of
	//  them. We are only interested in v2 scopes here.

	Vector scopes = new Vector();
	Hashtable daRec = daTable.findDAScopes(scopes);
	Vector daEquivClasses = (Vector)daRec.get(UNICAST_KEY);

	if (daEquivClasses != null) {

	    // Go through the equivalence classes and pull out scopes.

	    int i, n = daEquivClasses.size();

	    for (i = 0; i < n; i++) {
		DARecord rec = (DARecord)daEquivClasses.elementAt(i);
		Vector v = rec.scopes;

		int j, m = v.size();

		for (j = 0; j < m; j++) {
		    Object s = v.elementAt(j);

		    // Unicast scopes take precedence over multicast scopes,
		    //  so insert them at the beginning of the vector.

		    if (!scopes.contains(s)) {
			scopes.addElement(s);

		    }
		}
	    }
	}

	return scopes;
    }

    /**
     * Get the right DA table implementation. The property
     * sun.net.slp.DATableClass determines the class.
     *
     * @return The DATable object for this process' SLP requests.
     */


    static DATable getDATable() {

	// Return it right up front if we have it.

	if (daTable != null) {
	    return daTable;

	}

	conf = SLPConfig.getSLPConfig();

	// Link and instantiate it.

	daTable = linkAndInstantiateFromProp();

	return daTable;

    }

    // Link and instantiate the class in the property.

    static protected DATable linkAndInstantiateFromProp() {

	// Get the property.

	String className = System.getProperty(DA_TABLE_CLASS_PROP);

	if (className == null) {
	    Assert.slpassert(false,
			  "no_da_table",
			  new Object[] {DA_TABLE_CLASS_PROP});
	}

	Class tclass = null;

	// Link the class and instantiate the object.

	try {

	    tclass = Class.forName(className);
	    daTable = (DATable)tclass.newInstance();
	    return daTable;

	} catch (ClassNotFoundException ex) {

	    Assert.slpassert(false,
			  "no_da_table_class",
			  new Object[] {className});

	} catch (InstantiationException ex) {

	    Assert.slpassert(false,
			  "instantiation_exception",
			  new Object[] {className});

	} catch (IllegalAccessException ex) {

	    Assert.slpassert(false,
			  "access_exception",
			  new Object[] {className});

	}

	// We won't reach this point, since the assertions will capture
	//  any errors and kill the program.

	return null;
    }

    //
    // Utility functions for DA filtering and handling scopes.
    //

    // Filter scopes, removing any not on the filter list if inVector is
    //  false and removing any in the filter list if inVector is true.

    public static void
	filterScopes(Vector scopes, Vector filter, boolean inVector) {

	int i = 0;

	// Null or empty filter vector means that all should be accepted.

	if (filter != null && !(filter.size() <= 0)) {

	    while (i < scopes.size()) {
		String scope = (String)scopes.elementAt(i);

		if ((!inVector && !filter.contains(scope)) ||
		    (inVector && filter.contains(scope))) {
		    scopes.removeElementAt(i);

		} else {
		    i++;

		}
	    }
	}
    }

    // Add a new address to the equivalence class.

    static boolean addToEquivClass(String daaddr, Vector scopes, Vector ret) {

	// Create the InetAddress object.

	InetAddress addr = null;

	try {

	    addr = InetAddress.getByName(daaddr);

	} catch (UnknownHostException ex) {

	    if (conf.traceAll()) {
		conf.writeLog("unknown_da_address",
			      new Object[] {daaddr});

	    }

	    return false;
	}

	// Go through the existing vector.

	int i, n = ret.size();
	boolean equivalent = false;
	DARecord rec = null;

    outer: for (i = 0; i < n && equivalent == false; i++) {
	rec = (DARecord)ret.elementAt(i);
	Vector dascopes = rec.scopes;

	int j, m = dascopes.size();

	for (j = 0; j < m; j++) {
	    String scope = (String)dascopes.elementAt(j);

	    if (!scopes.contains(scope)) {
		continue outer;

	    }
	}

	equivalent = true;
    }

	// Make a new record if not equivalent.

	if (!equivalent) {
	    rec = new DATable.DARecord();
	    rec.scopes = (Vector)scopes.clone();

	    ret.addElement(rec);

	}


	// Add to record. Optimize, by putting the local address at the
	//  beginning of the vector.

	Vector interfaces = conf.getInterfaces();

	if (interfaces.contains(addr)) {
	    rec.daAddresses.insertElementAt(addr, 0);

	} else {
	    rec.daAddresses.addElement(addr);

	}

	return true;
    }

    /**
     * Validate the scope names. We check that they are all strings,
     * that none are the empty string. In addition, we collate to
     * remove duplicates, and lower case.
     */

    static void validateScopes(Vector scopes, Locale locale)
	throws ServiceLocationException {

	// Check for empty vector.

	if (scopes == null || scopes.size() <= 0) {
	    throw
		new ServiceLocationException(
				ServiceLocationException.PARSE_ERROR,
				"no_scope_vector",
				new Object[0]);
	}

	// Check for all strings and none empty.

	int i;
	Hashtable ht = new Hashtable();

	for (i = 0; i < scopes.size(); i++) {
	    Object o = scopes.elementAt(i);

	    if (!(o instanceof String)) {
		throw
		    new ServiceLocationException(
				ServiceLocationException.PARSE_ERROR,
				"non_string_element",
				new Object[] {scopes});
	    }

	    String str = (String)o;

	    if (str.length() <= 0) {
		throw
		    new ServiceLocationException(
				ServiceLocationException.PARSE_ERROR,
				"null_element",
				new Object[] {scopes});
	    }

	    // Lower case, trim.

	    str = str.toLowerCase(locale).trim();

	    // Squeeze out spaces.

	    StringBuffer buf = new StringBuffer();
	    StringTokenizer tk =
		new StringTokenizer(str, ServiceLocationAttribute.WHITESPACE);
	    String tok = null;

	    while (tk.hasMoreTokens()) {

		// Add a single embedded whitespace for each group found.

		if (tok != null) {
		    buf.append(" ");

		}

		tok = tk.nextToken();
		buf.append(tok);
	    }

	    str = buf.toString();

	    // If it wasn't already seen, put it into the hashtable.

	    if (ht.get(str) == null) {
		ht.put(str, str);
		scopes.setElementAt(str, i);

	    } else {
		/*
		 *  Must decrement the index 'i' otherwise the next iteration
		 *  around the loop will miss the element immediately after
		 *  the element removed.
		 *
		 *  WARNING: Do not use 'i' again until the loop has
		 *           iterated as it may, after decrementing,
		 *           be negative.
		 */
		scopes.removeElementAt(i);
		i--;
		continue;
	    }
	}
    }

}