/*
* 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.
*
*/
// SunDATable.java: A DATable implementation that uses the IPC connection.
// Author: James Kempf
// Created On: Mon May 11 15:00:23 1998
// Last Modified By: James Kempf
// Last Modified On: Thu Mar 11 15:00:58 1999
// Update Count: 71
//
package com.sun.slp;
import java.util.*;
import java.net.*;
import java.io.*;
/**
* The SunDATable class uses the IPC connection to obtain DA information
* from the SA server. By convention, the SA server answers service
* requests for the service type "directory-agent.sun" and including
* a filter for the scopes formatted as:
*
* "(&(|(scopes=<scope1>)(scopes=<scope2>)(scopes=<scope3>)...)(version=2))"
*
* with a collection of URLs that fit the request. The scope of the
* request is the hostname of the local machine, which will not be
* forwarded to any DAs. The URLs contain the
* DA IP address in the host field and a list of scopes in the URL
* part in the form of an attribute value assignment, i.e.:
*
* service:directory-agent.sun:// 199.200.200.5/scopes=eng, corp, freeb
*
* The DA/scope table is initially obtained for all scopes in the
* useScopes list, then refreshed periodically when the
* time stamp runs out. The time stamp is determined as the minimum
* expiration time of the service URLs.
*
* @author James Kempf
*/
class SunDATable extends DATable {
// The scopes identifier.
final static String SCOPES_ID = "424242SUN-TABLE-SCOPES424242";
// DA version number.
final static String VERSION_ID = "424242SUN-TABLE-VERSION424242";
// The scopes which reside on the SA only.
private Vector saOnlyScopes = new Vector();
// The cached vector of DA equivalence classes.
private Vector cache = null;
// The time when the cache should be refreshed.
private long timeStamp = -1;
/**
* Construct a DATable. We get a cached table of accessable
* DAs and scopes and the SA scope names to use for querying.
*/
SunDATable() throws ServiceLocationException {
// Remove the common scopes from the SA scopes. This will leave
// the private, SA only scopes.
saOnlyScopes = conf.getSAOnlyScopes();
Assert.slpassert(saOnlyScopes.size() > 0,
"no_sa_scopes",
new Object[0]);
// Initialize the cache. We want the scopes that can be dynamically
// discovered. If we have been configured with scopes, then
// it will be those. If not, then we want whatever we can discovery.
// we only want the default version for client side.
cache = getWireTable(conf.getConfiguredScopes(), Defaults.version);
}
/**
* Return a hashtable of DA equivalence classes and multicast
* scopes. Multicast scopes are stored in the special hashtable
* key MULTICAST_KEY. Unicast DA equivalence classes are stored
* under the key UNICAST_KEY.
*
* @param scopes Scope list for DAs needed.
* @return Hashtable with DA addresses as keys and scopes to contact
* them with as values. Any scopes not associated with a
* DA come back stored under the key MULTICAST_KEY.
* Unicast DA equivalence classes are stored
* under the key UNICAST_KEY.
*/
synchronized Hashtable findDAScopes(Vector scopes)
throws ServiceLocationException {
Hashtable ret = new Hashtable();
Vector equivClasses = null;
// Refresh the local cache if necessary.
if (timeStamp <= System.currentTimeMillis()) {
Vector useScopes = conf.getConfiguredScopes();
cache = getWireTable(useScopes, Defaults.version);
}
equivClasses = (Vector)cache.clone();
int i;
// Sort through the local cache, matching against the input parameter.
// Collect multicast scopes.
Vector multicastScopes = (Vector)scopes.clone();
for (i = 0; i < equivClasses.size(); i++) {
DARecord rec = (DARecord)equivClasses.elementAt(i);
Vector daScopes = (Vector)rec.scopes.clone();
// Filter multicast scopes first. Remove any from the multicast
// scope list that are in daScopes.
filterScopes(multicastScopes, daScopes, true);
// Now filter daScopes. Remove any from the daScopes that are
// not in the input scopes.
filterScopes(daScopes, scopes, false);
// Remove this record if there are none left.
if (daScopes.size() <= 0) {
/*
* 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.
*/
equivClasses.removeElementAt(i);
i--;
continue;
}
}
// Install the unicast and multicast scopes if any.
if (multicastScopes.size() > 0) {
ret.put(MULTICAST_KEY, multicastScopes);
}
if (equivClasses.size() > 0) {
ret.put(UNICAST_KEY, equivClasses);
}
return ret;
}
/**
* Remove a DA by address. We only remove it from the wire table
* so if it's down temporarily, we'll get it back again.
*
* @param address The host address of the DA.
* @param scopes The scopes.
* @return True if removed, false if not.
*/
boolean removeDA(InetAddress address, Vector scopes) {
// Sort through the table of equivalence classes in cache.
boolean foundit = false;
int i;
for (i = 0; i < cache.size(); i++) {
DARecord rec = (DARecord)cache.elementAt(i);
Vector daAddresses = rec.daAddresses;
// Ignore scopes, delete if there. Scopes will always be the
// ones for which this DA is to be removed.
int j, m = daAddresses.size();
for (j = 0; j < m; j++) {
InetAddress daaddr = (InetAddress)daAddresses.elementAt(j);
// If they are equal, remove it, exit loop.
if (address.equals(daaddr)) {
foundit = true;
daAddresses.removeElementAt(j);
// If the cache entry is empty, remove it.
if (daAddresses.size() <= 0) {
cache.removeElementAt(i);
}
break;
}
}
}
return foundit;
}
// Return a vector of DARecord equivalence classes by going out to the
// wire for them. Merge any that are in the current process'
// DAAddresses property.
private Vector getWireTable(Vector scopes, int version)
throws ServiceLocationException {
Vector ret = new Vector();
// Get replies from the SA server. These will be CSrvMsg replies.
CSrvMsg msg = getSrvReply(scopes, version);
// Process reply into the vector of equivalence classes by adding to
// to those from the preconfigured DAs.
processReply(msg, ret);
// Return vector.
return ret;
}
private CSrvMsg getSrvReply(Vector scopes, int version)
throws ServiceLocationException {
// Form the query.
StringBuffer buf = new StringBuffer();
int i, n = scopes.size();
for (i = 0; i < n; i++) {
buf.append("(");
buf.append(SCOPES_ID);
buf.append("=");
buf.append((String)scopes.elementAt(i));
buf.append(")");
}
// Add logical disjunction if there is more than one scope.
if (i > 1) {
buf.insert(0, "(|");
buf.append(")");
}
// Add version number restriction.
if (i > 0) {
buf.insert(0, "(&");
}
buf.append("(");
buf.append(VERSION_ID);
buf.append("=");
buf.append((new Integer(version)).toString());
buf.append(")");
// Add closing paren if there were any scopes.
if (i > 0) {
buf.append(")");
}
// Create the message object. Note that if scope vector is
// empty, the query is the null string, and so all DAs
// will be returned.
CSrvMsg msg = new CSrvMsg(Defaults.locale,
Defaults.SUN_DA_SERVICE_TYPE,
saOnlyScopes,
buf.toString());
// Send it down the pipe to the IPC process. It's a bad bug
// if the reply comes back as not a CSrvMsg.
SrvLocMsg rply =
Transact.transactTCPMsg(conf.getLoopback(), msg, true);
// Check error code.
if (rply == null ||
rply.getErrorCode() != ServiceLocationException.OK) {
short errCode =
(rply == null ?
ServiceLocationException.INTERNAL_SYSTEM_ERROR :
rply.getErrorCode());
throw
new ServiceLocationException(errCode,
"loopback_error",
new Object[] {
new Short(errCode)});
}
return (CSrvMsg)rply;
}
// Process CSrvMsg reply into DA equivalence class vector
private void processReply(CSrvMsg msg, Vector ret)
throws ServiceLocationException {
int shortTimer = Integer.MAX_VALUE;
// Get the URLs.
Vector serviceURLs = msg.serviceURLs;
// Process each service URL.
int i, n = serviceURLs.size();
for (i = 0; i < n; i++) {
ServiceURL url = (ServiceURL)serviceURLs.elementAt(i);
// If the time to live is less than the current minimum,
// save it.
int lifetime = url.getLifetime();
if (lifetime < shortTimer) {
shortTimer = lifetime;
}
// Get the host name and URL part.
String daaddr = url.getHost();
String urlpart = url.getURLPath();
// Parse URL part into scope list. Be
// sure not to include the initial `/' in the parse.
StringTokenizer tk =
new StringTokenizer(urlpart.substring(1,
urlpart.length()),
";");
Vector daScopes = null;
while (tk.hasMoreElements()) {
String attrExp = tk.nextToken();
// Convert to an SLP attribute.
ServiceLocationAttribute attr =
new ServiceLocationAttribute("(" + attrExp + ")", false);
// Depending on the attribute id, do something.
String id = attr.getId();
Vector vals = attr.getValues();
if (id.equals(SCOPES_ID)) {
daScopes = vals;
} else {
throw
new ServiceLocationException(
ServiceLocationException.PARSE_ERROR,
"loopback_parse_error",
new Object[] {url});
}
}
// Add it to the equivalence class.
addToEquivClass(daaddr, daScopes, ret);
}
// Reset the timestamp.
timeStamp = System.currentTimeMillis() + (long)(shortTimer * 1000);
}
}