/*

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

 * All rights reserved.

 *

 */

//  SLPHeaderV2.java:   Base class for Service Location Messages

//  Author:           James Kempf

//  Created On:       Thu Oct  9 08:50:31 1997

//  Last Modified By: James Kempf

//  Last Modified On: Wed Jan  6 15:24:26 1999

//  Update Count:     472

//

package com.sun.slp;

import java.util.*;

import java.net.*;

import java.io.*;

/**

 * The SLPHeaderV2 class serves as the header class for all SLPv2 messages.

 * It contains instance variables for SLP message header contents,

 * and implements the SLPHeaderV2 interface.

 *

 * @author James Kempf

 */

class SLPHeaderV2 extends SrvLocHeader implements Cloneable {

    // Support for options.

    private int optOff = 0;

    Hashtable optTable = new Hashtable();

    // Maximum message size (24 bits).

    private final static int MAX_MESSAGE_LENGTH = 0xffffff;

    // Location of flag byte.

    static final int FLAG_BYTE = 4;

    // Various header flags.

    protected static final int NOFLAG   = 0x00;

    static final int           OVERFLOW = 0x80;  // needed by Transact.

    protected static final int FRESH    = 0x40;

    protected static final int MCAST    = 0x20;

    // Header sizes. Note that this doesn't include the language tag,

    //  which is variable.

    protected static final int REST_HEADER_BYTES = 12;

    protected static final int HEADER_BYTES =

	VERSION_FUNCTION_BYTES + REST_HEADER_BYTES;

    // Maximum protected scopes allowed.

    protected static final int MAX_PROTECTED_SCOPES = 255;

    // Registered option classes.

    protected static Hashtable optClasses = new Hashtable();

    // Manditory option range.

    protected static int MANDATORY_OPTION_LOW = 0x4000;

    protected static int MANDATORY_OPTION_HIGH = 0x7fff;

    // Sizes of option id and extension fields (in bytes).

    protected static int OPT_ID_SIZE = 2;

    protected static int OPT_OFF_SIZE = 2;

    // Interfaces for options to use.

    interface OptionParser {

	// Parse the option from the data stream. We include the header also,

	//  in case it is needed.

	abstract SLPOption parse(SLPHeaderV2 hdr, DataInputStream dsr)

	    throws ServiceLocationException, IOException;

    }

    interface SLPOption {

	// Externalize the option to the byte array stream. We include the

	//  header also, in case it is needed.

	abstract void externalize(SLPHeaderV2 hdr, ByteArrayOutputStream baos)

	    throws ServiceLocationException;

    }

    // Register an option parsing class.

    static void registerOptionClass(int id, Class optClass) {

	Integer key = new Integer(id);

	// We should probably check if it implements SLPOption.OptionParser,

	//  but...

	optClasses.put(key, optClass);

    }

    //

    // Header instance variables.

    //

    // For the incoming message side.

    SLPHeaderV2() {

	super();

	version = Defaults.version;

    }

    // Initialize the new SLPHeaderV2 from the input stream. Version and

    //  function code have already been removed from the stream.

    void parseHeader(int functionCode, DataInputStream dis)

	throws ServiceLocationException, IOException {

	this.functionCode = functionCode;

	nbytes += 2;  // for version and function code...

	// Get length.

	length = getInt24(dis);

	// Get flags.

	byte[] b = new byte[2];

	dis.readFully(b, 0, 2);

	nbytes += 2;

	byte flags   = (byte) ((char)b[0] & 0xFF);

	overflow = ((flags & OVERFLOW) != NOFLAG);

	fresh = ((flags & FRESH) != NOFLAG);

	mcast = ((flags & MCAST) != NOFLAG);

	// We could check for null on reserved part of flags field, but

	//  in the spirit of "be liberal in what you receive" we don't.

	// Get option offset.

	optOff = getInt24(dis);

	// Check option offset for sanity.

	if (optOff > length) {

	    throw

		new ServiceLocationException(

				ServiceLocationException.PARSE_ERROR,

				"option_error",

				new Object[] {

		    new Integer(optOff), new Integer(length)});

	}

	// Get transaction id.

	xid = (short)getInt(dis);

	// Get language code.

	StringBuffer buf = new StringBuffer();

	getString(buf, dis);

	locale = SLPConfig.langTagToLocale(buf.toString());

	// Everything went OK coming in, so set the error code.

	errCode = ServiceLocationException.OK;

    }

    // By default, the header parses the client side message. A server

    //  side subclass must replace this. We do this so that the amount of code

    //  in the client is minimized, since this class must be in both.

    SrvLocMsg parseMsg(DataInputStream dis)

	throws ServiceLocationException,

	       IOException,

	       IllegalArgumentException {

	SrvLocMsg rply = null;

	// Get the error code, if not SAAdvert.

	if (functionCode != SrvLocHeader.SAAdvert) {

	    errCode = (short)getInt(dis);

	}

	// Switch and convert according to function code.

	switch (functionCode) {

	case SrvLocHeader.SrvRply:

	    rply = new CSrvMsg(this, dis);

	    break;

	case SrvLocHeader.AttrRply:

	    rply = new CAttrMsg(this, dis);

	    break;

	case SrvLocHeader.SrvTypeRply:

	    rply = new CSrvTypeMsg(this, dis);

	    break;

	case SrvLocHeader.DAAdvert:

	    rply = new CDAAdvert(this, dis);

	    break;

	case SrvLocHeader.SrvAck:

	    // We act as a SrvAck.

	    rply = this;

	    iNumReplies = 1;

	    break;

	case SrvLocHeader.SAAdvert:

	    rply = new CSAAdvert(this, dis);

	    break;

	default:

	    throw

		new ServiceLocationException(

				ServiceLocationException.PARSE_ERROR,

				"function_code_error",

				new Object[] {

		    new Integer(functionCode)});

	}

	// Check for size overflow.

	if (nbytes > length) {

	    throw

		new ServiceLocationException(

				ServiceLocationException.PARSE_ERROR,

				"length_overflow",

				new Object[] {

		    new Integer(nbytes), new Integer(length)});

	}

	return rply;

    }

    // Construct a header for output. Used by the client side code to

    //  construct an initial request and the server side code to construct

    //  a reply.

    SLPHeaderV2(int functionCode, boolean fresh, Locale locale)

	throws ServiceLocationException {

	// Check for proper function code and nonnull locale.

	Assert.slpassert(((functionCode <= SAAdvert) &&

	    (functionCode >= SrvReq)),

		      "function_code_error",

		      new Object[] {new Integer(functionCode)});

	Assert.slpassert((locale != null),

		      "null_locale_error",

		      new Object[0]);

	this.version = Defaults.version;

	this.functionCode = functionCode;

	this.locale = locale;

	this.xid = getUniqueXID();  // client can change it later if they want.

	this.fresh = fresh;

	// If there's not enough for the error code (if any), then signal

	//  an error. The assumption here is that the message is going

	//  via UDP or multicast.

	byte[] ltag =

	    getStringBytes(SLPConfig.localeToLangTag(locale), Defaults.UTF8);

	int headerLen = ltag.length + HEADER_BYTES;

	int payLen =  packetLength - headerLen;

	if (payLen < SHORT_SIZE) {

	    throw

		new ServiceLocationException(

				ServiceLocationException.BUFFER_OVERFLOW,

				"buffer_overflow",

				new Object[] {

		    new Integer(headerLen + SHORT_SIZE),

			new Integer(packetLength)});

	}

    }

    // Externalize the message by converting it to bytes and writing

    //  it to the output stream.

    public void

	externalize(ByteArrayOutputStream baos, boolean mcast, boolean isTCP)

	throws ServiceLocationException {

	// Convert the locale to a tag. We need the length.

	byte[] ltagBytes =

	    getStringBytes(SLPConfig.localeToLangTag(locale), Defaults.UTF8);

	int ltagLen = ltagBytes.length;

	// Set the multicast flag.

	this.mcast = mcast;

	// We need to get stuff into another stream first, so we can correctly

	//  calculate the length.

	ByteArrayOutputStream bbaos = new ByteArrayOutputStream();

	// Need to put in the error code. There will only be an error code

	//  if error codes are applicable for this message type. Note

	//  that room for the error code was reserved in the initial

	//  calculation of the header, so there should always be room

	//  for it, even if the packet overflowed otherwise.

	if (functionCode == SrvLocHeader.SrvAck ||

	    functionCode == SrvLocHeader.SrvTypeRply ||

	    functionCode == SrvLocHeader.SrvRply ||

	    functionCode == SrvLocHeader.AttrRply ||

	    functionCode == SrvLocHeader.DAAdvert) {

	    putInt(errCode, bbaos);

	}

	// Put in the previous responders, if there are any. Note that

	//  there may be only when the error code is not put out.

	//  We check against the packet size during parsing so that

	//  we don't overflow the packet and throw a special exception

	//  if an overflow happens. We only put out the previous

	//  responders list if the request is going by multicast, but

	//  we need to put out an empty vector for unicast requests.

	int prevResLen =

	    packetLength - (payload.length + HEADER_BYTES + ltagLen);

	Vector resp = previousResponders;

	if (resp != null) {

	    resp = (mcast ? resp:new Vector());

	    parsePreviousRespondersOut(resp, bbaos, prevResLen);

	}

	// If the error code is OK, then insert the rest of the message

	//  and parse the options. If there was an error,

	//  this step is skipped because the data isn't relevant.

	if (errCode == ServiceLocationException.OK) {

	    bbaos.write(payload, 0, payload.length);

	    // Externalize any options.

	    optOff = externalizeOptions(bbaos, ltagLen);

	}

	byte[] payloadBytes = bbaos.toByteArray();

	// Set the length here to the actual length of the packet.

	length = HEADER_BYTES + ltagLen + payloadBytes.length;

	// If we exceed the 24 bit length size, we are hosed.

	if (length > MAX_MESSAGE_LENGTH) {

	    throw

		new ServiceLocationException(

				ServiceLocationException.PARSE_ERROR,

				"max_msg_size_exceeded",

				new Object[0]);

	}

	// Truncate if necessary. We will always have room for a header

	//  and error code because we check when creating the object.

	//  Note that no URL block will be truncated because the spec

	//  says it can't be.

	if (!isTCP && (length > packetLength)) {

	    overflow = true;

	    length = packetLength;

	    byte[] newBytes = new byte[packetLength];

	    System.arraycopy(payloadBytes, 0, newBytes, 0,

			     length - (HEADER_BYTES + ltagLen));

	    payloadBytes = newBytes;

	}

	//

	// Write out the header.

	//

	// Write version and function code.

	baos.write((byte) (0xFF & version));

	baos.write((byte) (0xFF & functionCode));

	// Put length in.

	putInt24(length, baos);

	// Put in flags.

	byte flags = (byte)NOFLAG;

	if (overflow) {

	    flags = (byte)(flags | OVERFLOW);

	} else {

	    flags = (byte)(flags & ~OVERFLOW);

	}

	if (fresh) {

	    flags = (byte)((flags | FRESH) & 0xFF);

	} else {

	    flags = (byte)((flags & ~FRESH) & 0xFF);

	}

	if (mcast) {

	    flags = (byte)((flags | MCAST) & 0xFF);

	} else {

	    flags = (byte)((flags & ~MCAST) & 0xFF);

	}

	// Write out flags.

	baos.write((byte) (0xFF & flags));

	baos.write((byte)0);

	putInt24(optOff, baos);  // write option offset,  if any.

	putInt(xid, baos);  // write xid.

	putInt(ltagLen, baos);  // write lang size.

	baos.write(ltagBytes, 0, ltagBytes.length);  // write lang tag.

	//

	// Write the body.

	//

	baos.write(payloadBytes, 0, payloadBytes.length);

    }

    //

    // Option handling.

    //

    // Parse any options.

    void parseOptions(DataInputStream dsr)

	throws ServiceLocationException,

	       IOException,

	       IllegalArgumentException {

	// If no options return.

	if (optOff == 0) {

	    return;

	}

	int optNext = 0;

	// Parse any options in the data stream.

	do {

	    // Parse extension id.

	    int optId = getInt(dsr);

	    // Parse extension offset.

	    optNext = getInt(dsr);

	    // Lookup an option parser.

	    Integer key = new Integer(optId);

	    Class optClass = (Class)optClasses.get(key);

	    // May be an exception if class is null.

	    if (optClass == null) {

		// In mandatory range. Throw an exception.

		if ((optId >= MANDATORY_OPTION_LOW) &&

		    (optId <= MANDATORY_OPTION_HIGH)) {