/*
* 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 (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();
while (abs.hasMoreElements()) {
AuthBlock ab = (AuthBlock)abs.nextElement();
// check each DA SPI
boolean daSPImatch = false;
for (int SPIi = 0; SPIi < spis.size(); SPIi++) {
if (AuthBlock.checkEquiv((String)spis.get(SPIi), ab)) {
daSPImatch = true;
break;
}
}
if (!daSPImatch) {
return;
}
}
}
if (conf.traceDATraffic()) {
conf.writeLog("sdat_forward",
new Object[] {
Integer.toHexString(hdr.xid),
addr});
}
// Send it via TCP. DAs should understand TCP, and it's reliable.
SrvLocMsg rply = null;
try {
// Construct the client side message, for outgoing.
if (rqst instanceof SSrvReg) {
SSrvReg rrqst = (SSrvReg)rqst;
CSrvReg msg = new CSrvReg(hdr.fresh,
hdr.locale,
rrqst.URL,
hdr.scopes,
rrqst.attrList,
rrqst.URLSignature,
rrqst.attrSignature);
rply = msg;
} else if (rqst instanceof SSrvDereg) {
SSrvDereg drqst = (SSrvDereg)rqst;
CSrvDereg msg = new CSrvDereg(hdr.locale,
drqst.URL,
hdr.scopes,
drqst.tags,
drqst.URLSignature);
rply = msg;
} else if (rqst instanceof CSrvReg) {
rply = rqst;
}
rply = Transact.transactTCPMsg(addr, rply, false);
} catch (ServiceLocationException ex) {
if (conf.traceDATraffic()) {
conf.writeLog("sdat_forward_exception",
new Object[] {
Integer.toHexString(hdr.xid),
addr,
new Integer(ex.getErrorCode()),
ex.getMessage()});
}
}
// Report any errors.
if (rply == null ||
rply.getErrorCode() != ServiceLocationException.OK) {
if (conf.traceDATraffic()) {
conf.writeLog("sdat_forward_err",
new Object[] {
Integer.toHexString(hdr.xid),
addr,
(rply == null ? "<null>":
Integer.toString(rply.getErrorCode()))});
}
}
}
}