/*

 * 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.

 *

 */

//  ServiceTable.java: Storage of all services.

//  Author:           James Kempf

//  Created On:       Fri Oct 10 14:23:25 1997

//  Last Modified By: James Kempf

//  Last Modified On: Thu Apr  1 10:33:46 1999

//  Update Count:     461

//

package com.sun.slp;

import java.util.*;

import java.io.*;

import java.security.*;

import java.net.*;

/**

 * The ServiceTable object records all service registrations. Note

 * that any exceptions internal to the service table are processed

 * and either returned as SrvRply objects or are reported.

 *

 * @author James Kempf

 */

class ServiceTable extends Object {

    // Key for SDAAdvert class.

    static final String SDAADVERT = "com.sun.slp.SDAAdvert";

    private static final String locationMsg = "Service table";

    //

    // Instance variables.

    //

    // The service store.

    protected ServiceStore store = null;

    //

    // Class variables.

    // System properties.

    static protected SLPConfig conf = null;

    // Singleton objects for the service tables.

    static protected ServiceTable table = null;

    // The ager thread.

    static protected AgerThread thrAger = null;

    // Time to sleep. Adjusted depending on incoming URLs.

    private static long sleepyTime = Defaults.lMaxSleepTime;	

    //

    // Creation of singleton.

    //

    // Protected constructor.

    protected ServiceTable() {

	if (thrAger != null) {

	    return;

	}

	// Create the ager thread.

	thrAger = new AgerThread();

	// Set the priority low, so other things (like active discovery)

	//  take priority.

	thrAger.setPriority(Thread.MIN_PRIORITY);

	thrAger.start();

    }

    /**

     * Return an SA service store.

     *

     * @return The distinguished table object.

     */

    static ServiceTable getServiceTable()

	throws ServiceLocationException {

	if (conf == null) {

	    conf = SLPConfig.getSLPConfig();

	}

	if (table == null) {

	    table = createServiceTable();

	}

	return table;

    }

    /**

     * Return a service table object.

     *

     * @return The service table object.

     */

    private static ServiceTable createServiceTable()

	throws ServiceLocationException {

	ServiceTable table = new ServiceTable();

	table.store = ServiceStoreFactory.createServiceStore();

	return table;

    }

    //

    // Support for serializated registrations.

    //

    /**

     * If any serialized registrations are pending, then unserialize

     * and register.

     */

    public void deserializeTable() {

	// If there are any serialized registrations, then get

	//  them and perform registrations.

	String serializedURL = conf.getSerializedRegURL();

	if (serializedURL != null) {

	    ServiceStore serStore = getStoreFromURL(serializedURL);

	    if (serStore != null) {

		registerStore(serStore);

	    }

	}

    }

    /**

     * Serialize the table to the URL.

     *

     * @param URL String giving the URL to which the store should be

     * serialized.

     */

    void serializeServiceStore(String URL) {

	// Open an object output stream for the URL, serialize through

	//  the factory.

	try {

	    URL url = new URL(URL);

	    URLConnection urlConn = url.openConnection();

	    OutputStream os = urlConn.getOutputStream();

	    BufferedWriter di =

		new BufferedWriter(new OutputStreamWriter(os));

	    // Serialize the store.

	    ServiceStoreFactory.serialize(di, store);

	} catch (MalformedURLException ex) {

	    conf.writeLog("st_serialized_malform",

			  new Object[] {URL});

	} catch (UnsupportedEncodingException ex) {

	    conf.writeLog("st_unsupported_encoding",

			  new Object[] {URL});

	} catch (IOException ex) {

	    conf.writeLog("st_serialized_ioexception",

			  new Object[] {URL, ex});

	} catch (ServiceLocationException ex) {

	    conf.writeLog("st_serialized_sle",

			  new Object[] {URL, ex.getMessage()});

	}

    }

    // Read proxy registrations from the URL.

    private ServiceStore getStoreFromURL(String serializedURL) {

	ServiceStore serStore = null;

	// Open an object input stream for the URL, deserialize through

	//  the factory.

	try {

	    URL url = new URL(serializedURL);

	    InputStream is = url.openStream();

	    BufferedReader di = new BufferedReader(new InputStreamReader(is));

	    // Deserialize the objects.

	    serStore =

		ServiceStoreFactory.deserializeServiceStore(di);

	} catch (MalformedURLException ex) {

	    conf.writeLog("st_serialized_malform",

			  new Object[] {serializedURL});

	} catch (UnsupportedEncodingException ex) {

	    conf.writeLog("st_unsupported_encoding",

			  new Object[] {serializedURL});

	} catch (IOException ex) {

	    conf.writeLog("st_serialized_ioexception",

			  new Object[] {

		serializedURL,

		    ex.getMessage()});

	} catch (ServiceLocationException ex) {

	    conf.writeLog("st_serialized_sle",

			  new Object[] {

		serializedURL,

		    ex.getMessage()});

	}

	return serStore;

    }

    // Walk the table, performing actual registrations on all records.

    private void registerStore(ServiceStore serStore) {

	// Walk the table.

	Enumeration en = serStore.getServiceRecordsByScope(null);

	boolean hasURLSig = conf.getHasSecurity();

	boolean hasAttrSig = conf.getHasSecurity();

	PermSARegTable pregTable = 	SARequester.getPermSARegTable();

	while (en.hasMoreElements()) {

	    ServiceStore.ServiceRecord rec =

		(ServiceStore.ServiceRecord)en.nextElement();

	    ServiceURL surl = rec.getServiceURL();

	    Vector scopes = rec.getScopes();

	    Vector attrs = rec.getAttrList();

	    Locale locale = rec.getLocale();

	    Hashtable urlSig = null;

	    Hashtable attrSig = null;

	    // Note that we can't use the Advertiser to register here,

	    //  because we may not be listening yet for registrations.

	    //  We need to do this all by hand.

	    try {

		// Create a registration message for refreshing.

		CSrvReg creg = new CSrvReg(false,

					   locale,

					   surl,

					   scopes,

					   attrs,

					   null,

					   null);

		// We externalize to a server side message if authentication

		//  is needed. This creates the auth blocks for the scopes.

		//  Doing this in any other way is alot more complicated,

		//  although doing it this way seems kludgy.

		if (hasURLSig || hasAttrSig) {

		    ByteArrayOutputStream baos = new ByteArrayOutputStream();

		    creg.getHeader().externalize(baos, false, true);

		    ByteArrayInputStream bais =

			new ByteArrayInputStream(baos.toByteArray());

		    bais.read();	// pop off version and function code...

		    bais.read();

		    DataInputStream dis = new DataInputStream(bais);

		    SLPHeaderV2 hdr = new SLPHeaderV2();

		    hdr.parseHeader(SrvLocHeader.SrvReg, dis);

		    SSrvReg sreg = new SSrvReg(hdr, dis);

		    // Now we've got it, after much effort. Get the auths.

		    urlSig = sreg.URLSignature;

		    attrSig = sreg.attrSignature;

		}

		store.register(surl, attrs, scopes, locale, urlSig, attrSig);

		// Now we've got to put the registration into the

		//  PermSARegTable. Again, we do everything by hand

		//  because we can't use Advertiser.

		if (surl.getIsPermanent()) {

		    pregTable.reg(surl, creg);

		}

		// Report registration.

		if (conf.regTest()) {

		    conf.writeLog("st_reg_add",

				  new Object[] {

			locationMsg,

			    locale,

			    surl.getServiceType(),

			    surl,

			    attrs,

			    scopes});

		}

	    } catch (ServiceLocationException ex) {

		String msg = ex.getMessage();

		conf.writeLog("st_serialized_seex",

			      new Object[] {

		    new Integer(ex.getErrorCode()),

			surl,

			(msg == null ? "<no message>":msg)});

	    } catch (Exception ex) {

		String msg = ex.getMessage();

		conf.writeLog("st_serialized_seex",

			      new Object[] {

		    surl,

			(msg == null ? "<no message>":msg)});

	    }

	}

    }

    //

    // Record aging.

    //

    //

    // Run the thread that ages out records.

    //

    private class AgerThread extends Thread {

	public void run() {

	    setName("SLP Service Table Age-out");

	    long alarmTime = sleepyTime;  // when to wake up next

	    long wentToSleep = 0;	    // what time we went to bed

	    while (true) {

		try {

		    // Record when we went to sleep.

		    wentToSleep = System.currentTimeMillis();

		    // Sleep for the minimum amount of time needed before we

		    //  must wake up and check.

		    sleep(alarmTime);

		} catch (InterruptedException ie) {

		    // A new registration came in. Calculate how much time

		    //  remains until we would have woken up. If this is

		    //  less than the new sleepyTime, then we set the alarm

		    //  for this time. If it is more, then we set the alarm

		    //  for the new sleepyTime.

		    long remainingSleepTime =

			(wentToSleep + alarmTime) - System.currentTimeMillis();

		    remainingSleepTime =		// just in case...

			((remainingSleepTime <= 0) ? 0 : remainingSleepTime);

		    alarmTime = sleepyTime;

		    if (remainingSleepTime < alarmTime) {

			alarmTime = remainingSleepTime;

		    }

		    continue;  // we don't have to walk yet...

		}

		// Walk the table, get the new alarm and sleepy times.

		if (table != null) {

		    table.ageStore();

		    alarmTime = sleepyTime;

		}

	    }

	}

    }

    /**

     * Age the service store.

     */

    // this method cannot be private... due to compiler weakness

    void ageStore() {

	try {

	    // We synchronize in case somebody registers and tries to

	    //  change sleepy time.

	    synchronized (store) {

		Vector deleted = new Vector();

		sleepyTime = store.ageOut(deleted);

		// Track unregistered services.

		int i, n = deleted.size();

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

		    ServiceStore.ServiceRecord rec =

			(ServiceStore.ServiceRecord)deleted.elementAt(i);

		    ServiceURL surl = rec.getServiceURL();

		    trackRegisteredServiceTypes(); // it's deleted...

		}

	    }

	} catch (RuntimeException ex) {

	    reportNonfatalException(ex, new Vector(), store);

	} catch (ServiceLocationException ex) {

	    reportNonfatalException(ex, new Vector(), store);

	}

    }

    //

    // SLP Service Table operations (register, deregister, etc.)

    //

    /**

     * Process the registration and record if no errors found.

     *

     * @param req Service registration request message.

     * @return SrvLocMsg A service registration acknowledgement.

     */

    SrvLocMsg register(SSrvReg req) {

	SrvLocHeader hdr = req.getHeader();

	Locale locale = hdr.locale;

	boolean fresh = hdr.fresh;

	Vector scopes = hdr.scopes;

	ServiceURL surl = req.URL;

	String serviceType = req.serviceType;

	Vector attrList = req.attrList;

	Hashtable urlSig = req.URLSignature;

	Hashtable attrSig = req.attrSignature;

	short errorCode =

	    (fresh ? ServiceLocationException.INVALID_REGISTRATION :

	    ServiceLocationException.INVALID_UPDATE);

	try {

	    // If a sig block came in, verify it.

	    if (urlSig != null) {

		AuthBlock.verifyAll(urlSig);

	    }

	    if (attrSig != null) {