/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 *

 * 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 (c) 1999 by Sun Microsystems, Inc.

 * All rights reserved.

 *

 */

//  ServerDATable.java: Abstract class for DA Table in the DA/SA server.

//  Author:           James Kempf

//  Created On:       Wed May 20 08:30:46 1998

//  Last Modified By: James Kempf

//  Last Modified On: Tue Mar  9 12:36:37 1999

//  Update Count:     124

//

package com.sun.slp;

import java.util.*;

import java.net.*;

/**

 * ServerDATable is an abstract class that provides the interface for DA

 * and scope discovery, storage of DA information from incoming DAAdverts,

 * and forwarding of registrations and deregistration to DAs having

 * the same scopes. A variety of implementations are possible.

 * The getServerDATable() method creates the right one from a subclass.

 * We keep separate track of the superclass DA table and the server

 * DA table so that these two classes can co-exist in the same JVM.

 * Note that the code for forwarding registrations must keep track of

 * only those registrations that were done on this host. It does this

 * by saving the registrations as they come in. The forwarding code

 * is optimized so that forwarding of a new message is fast, while

 * forwarding of a message due to discovery of a new DA is somewhat

 * slower. This helps assure that SA clients get good service.

 *

 * The ServerDATable also does active discovery for the SA server/DA,

 * in a separate thread.

 *

 * @author James Kempf

 */

abstract class ServerDATable extends DATable {

    // The active discovery object.

    protected static ActiveDiscoverer activeDiscoverer = null;

    // The table of regs to forward. Keys are the reg URL and locale, values

    //  are the SSrvReg objects.

    protected Hashtable forwardRegs = new Hashtable();

    // This acts as a guard protecting an non-initialized DA table:

    //  If the DA Table hasn't been populated by active discovery yet,

    //  other threads accessing the DA table will block on readyLock.

    private static Object readyLock = new Object();

    // Keeps track of which DAs support which SPIs. The actual mapping

    //  is DA InetAddress to LinkedList of SPI Strings. recordNewDA

    //  populates this.

    protected Hashtable daSPIsHash = new Hashtable();

    /**

     * Get the right server DA table from the subclass.

     *

     * @return Table for handling DAs in the server.

     */

    static ServerDATable getServerDATable()

	throws ServiceLocationException {

	ServerDATable table = null;

	synchronized (readyLock) {

	    // Note that we are expecting this subclass. We will get a

	    //  cast exception if somebody instantiated with a

	    //  DATable subclass.

	    if (daTable != null) {

		return (ServerDATable)daTable;

	    }

	    conf = SLPConfig.getSLPConfig();

	    // Call the superclass method to link it.

	    daTable = linkAndInstantiateFromProp();

	    table = (ServerDATable)daTable;

	    // Advertise for *all* scopes. This is because we need to

	    //  be able to support clients that do user scoping.

	    Vector useScopes = new Vector();

	    activeDiscoverer =

		new ActiveDiscoverer(Defaults.version,

				     table,

				     useScopes,

				     conf.getMulticastAddress());

	    activeDiscoverer.start();

	}	// readyLock

	return table;

    }

    /**

     * Record a new DA.

     *

     * @param URL The DAAdvert URL.

     * @param scopes The scopes.

     * @param version DA version number.

     * @param attrs Attributes of DA.

     * @param spis SPIs supported by DA

     * @return True if recorded, false if not.

     */

    abstract long

	recordNewDA(ServiceURL url,

		    Vector scopes,

		    long timestamp,

		    int version,

		    Vector attrs,

		    String spis);

    /**

     * Return a hashtable in ServiceTable.findServices() format (e.g.

     * URL's as keys, scopes as values) for DAs matching the query.

     *

     * @param query Query for DA attributes.

     */

    abstract Hashtable returnMatchingDAs(String query)

	throws ServiceLocationException;

    /**

     * Forward a registration or deregistration to all DAs that have matching

     * scopes.

     *

     * @param msg Registration or deregistration message, server side.

     * @param source The address of the source.

     */

    void forwardSAMessage(SrvLocMsg msg, InetAddress source)

	throws ServiceLocationException {

	SrvLocHeader hdr = msg.getHeader();

	// If the message is not from this host (on any interface)

	//  then don't forward it.

	if (!conf.isLocalHostSource(source)) {

	    return;

	}

	// Record it so we can forward to a new DA.

	if (msg instanceof SSrvReg || msg instanceof CSrvReg) {

	    ServiceURL url;

	    if (msg instanceof SSrvReg) {

		url = ((SSrvReg)msg).URL;

	    } else {

		url = ((CSrvReg)msg).URL;

	    }

	    String key = makeKey(url, hdr.locale); // need locale also...

	    forwardRegs.put(key, msg);  // fresh doesn't matter.

	} else {

	    SSrvDereg smsg = (SSrvDereg)msg;

	    // Only remove if tags are null. Otherwise, the updated record

	    //  will be sought.

	    if (smsg.tags == null) {

		String key = makeKey(smsg.URL, hdr.locale);

		forwardRegs.remove(key);

	    }

	}

	// We only forward registrations to v2 DAs because we are

	//  acting as an SA server here. There is no requirement

	//  for v2 SAs to communicate with v1 DAs.

	// Get a hashtable of DAs that match the scopes in the message.

	Hashtable daScopeRec = findDAScopes(hdr.scopes);

	// We are only concerned with the unicast key, since it contains

	//  the DAs to which forwarding is required.

	Vector daRecs = (Vector)daScopeRec.get(UNICAST_KEY);

	// If there are no daRecs, then simply return.

	if (daRecs == null) {

	    return;

	}

	// Otherwise, forward the registration to all DAs in the vector.

	int i, n = daRecs.size();

	for (i = 0; i < n; i++) {

	    DARecord rec = (DARecord)daRecs.elementAt(i);

	    Vector daAddresses = rec.daAddresses;

	    int j, m = daAddresses.size();

	    for (j = 0; j < m; j++) {

		InetAddress addr = (InetAddress)daAddresses.elementAt(j);

		// Don't forward if it's the host from which the registration

		//  came. Otherwise, we're hosed.

		if (!source.equals(addr)) {

		    forwardRegOrDereg(addr, msg);

		}

	    }

	}

    }

    // Make a key for the service agent message table.

    private String makeKey(ServiceURL url, Locale locale) {

	return url.toString() + "/" + locale.toString();

    }

    /**

     * Handle an incoming DAAdvert. Presence must be recorded in the

     * implementation specific server DA table and any registrations need

     * to be forwarded if the boot timestamp is different from the

     * old boot timestamp.

     *

     * @param advert Incoming DAAdvert.

     */

    void handleAdvertIn(CDAAdvert advert) {

	SrvLocHeader hdr = advert.getHeader();

	// Remove if DA is going down.

	if (advert.isGoingDown()) {

	    InetAddress addr = null;

	    try {

		addr = InetAddress.getByName(advert.URL.getHost());

	    } catch (UnknownHostException ex) {

		conf.writeLog("unknown_da_address",

			      new Object[] {advert.URL.getHost()});

		return;

	    }

	    if (removeDA(addr, hdr.scopes)) {

		if (conf.traceDATraffic()) {

		    conf.writeLog("sdat_delete_da",

				  new Object[] {

			advert.URL,

			    hdr.scopes});

		}

	    }

	} else {

	    // verify the DAAdvert

	    if (advert.authBlock != null) {

		try {

		    AuthBlock.verifyAll(advert.authBlock);

		} catch (ServiceLocationException e) {

		    if (conf.traceDrop()) {

			conf.writeLog("sdat_daadvert_vrfy_failed",

				      new Object[] {advert.URL});

		    }

		    return;

		}

	    }

	    long timestamp =

		recordNewDA(advert.URL,

			    hdr.scopes,

			    advert.timestamp,

			    hdr.version,

			    advert.attrs,

			    advert.spis);

	    // Don't forward if the advert was rejected, or if the

	    //  old timestamp greater than or equal to the new timestamp.

	    //  If the old timestamp is greater than or equal to the new,

	    //  it means that we have already forwarded to this DA.

	    //  IF the old timestamp is less, it means that

	    //  the DA has crashed and come up again since we last saw

	    //  it, so we may have missed forwarding something to it.

	    if (timestamp >= advert.timestamp) {

		if (conf.traceDATraffic()) {

		    conf.writeLog("sdat_add_da_no_forward",

				  new Object[] {

			advert.URL,

			    hdr.scopes,

			    new Long(timestamp)});

		}

		return;

	    }

	    if (conf.traceDATraffic()) {

		conf.writeLog("sdat_add_da",

			      new Object[] {

		    advert.URL,

			hdr.scopes,

			new Long(advert.timestamp)});

	    }

	    // Forward existing registrations to the new advert.

	    forwardRegistrations(advert.URL, hdr.scopes,

				 advert.timestamp, hdr.version);

	}

    }

    //

    // Private methods.

    //

    private void

	forwardRegistrations(ServiceURL url,

			     Vector scopes,

			     long timestamp,

			     int version) {

	// Wait a random amount of time before forwarding.

	try {

	    Thread.currentThread().sleep(conf.getRandomWait());

	} catch (InterruptedException ex) {

	}

	// Get the registrations to forward.

	Enumeration regs = forwardRegs.elements();

	// Get the address of the DA.

	InetAddress addr = null;

	String host = url.getHost();

	try {

	    addr = InetAddress.getByName(host);

	} catch (UnknownHostException ex) {

	    if (conf.traceDrop() || conf.traceDATraffic()) {

		conf.writeLog("sdat_drop_fwd",

			      new Object[] {

		    host});

	    }

	    return;

	}

	ServiceTable serviceTable = null;

	try {

	    serviceTable = ServiceTable.getServiceTable();

	} catch (ServiceLocationException ex) {

	    // By this time, we should have it.

	}

	// Forward the registrations. Keep track of any deleted elements.

	Vector deleted = new Vector();

	while (regs.hasMoreElements()) {

	    SrvLocMsg reg = (SrvLocMsg)regs.nextElement();

	    ServiceURL regurl;

	    if (reg instanceof SSrvReg) {

		regurl = ((SSrvReg)reg).URL;

	    } else {

		regurl = ((CSrvReg)reg).URL;

	    }

	    SrvLocHeader hdr = reg.getHeader();

	    // Get the record and modify the reg to reflect the

	    //  record. We must do this because the SA may have

	    //  changed the record since it was first registred

	    //  and we do not keep track of the changes here.

	    ServiceStore.ServiceRecord rec =

		serviceTable.getServiceRecord(regurl, hdr.locale);

	    // If the record is null, it means that the entry was

	    //  aged out.

	    if (rec == null) {

		deleted.addElement(reg);

	    } else {

		// Check that the scopes match.

		Vector sscopes = (Vector)hdr.scopes.clone();

		DATable.filterScopes(sscopes, scopes, false);

		if (sscopes.size() <= 0) {

		    continue;

		}

		if (reg instanceof SSrvReg) {

		    SSrvReg sreg = (SSrvReg)reg;

		    hdr.scopes = (Vector)hdr.scopes.clone();

		    sreg.attrList = (Vector)rec.getAttrList().clone();

		    sreg.URLSignature = rec.getURLSignature();

		    sreg.attrSignature = rec.getAttrSignature();

		}

		forwardRegOrDereg(addr, reg);

	    }

	}

	// Remove any deleted elements from the hashtable.

	//  We do this in a separate loop because enumerations

	//  aren't synchronized.

	int i, n = deleted.size();

	for (i = 0; i < n; i++) {

	    SrvLocMsg reg = (SrvLocMsg)deleted.elementAt(i);

	    SrvLocHeader hdr = reg.getHeader();

	    ServiceURL regurl;

	    if (reg instanceof SSrvReg) {

		regurl = ((SSrvReg)reg).URL;

	    } else {

		regurl = ((CSrvReg)reg).URL;

	    }

	    String key = makeKey(regurl, hdr.locale);

	    forwardRegs.remove(key);

	}

    }

    // Forward the registration or deregistration to the URL.

    private void forwardRegOrDereg(InetAddress addr, SrvLocMsg rqst) {

	SrvLocHeader hdr = rqst.getHeader();

	// Don't forward to myself! Otherwise, nasty recursion happens.

	if (conf.isLocalHostSource(addr)) {

	    return;

	}

	// If security is on, only forward if this DA can verify the authblocks

	if (conf.getHasSecurity()) {

	    LinkedList spis = (LinkedList)daSPIsHash.get(addr);

	    if (spis == null) {

		// internal error; skip this DA to be safe

		return;

	    }

	    Hashtable auths = null;

	    if (rqst instanceof SSrvReg) {

		auths = ((SSrvReg)rqst).URLSignature;

	    } else if (rqst instanceof SSrvDereg) {

		auths = ((SSrvDereg)rqst).URLSignature;

	    } else {

		// shouldn't even be forwarding this!

		return;

	    }

	    // If each authblock is equiv to at least one SPI, forward the reg

	    Enumeration abs = auths.elements();