xref: /illumos-gate/usr/src/lib/libslp/javalib/com/sun/slp/Listener.java (revision 9a70fc3b)

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

//  Listener.java:    Organize basic listening for slpd and specifically
//                    support datagram listening.
//  Author:           James Kempf
//  Created On:       Mon May 18 12:43:50 1998
//  Last Modified By: James Kempf
//  Last Modified On: Thu Jan  7 08:39:19 1999
//  Update Count:     54
//

package com.sun.slp;

import java.util.*;
import java.net.*;
import java.io.*;

/**
 * This class supplies the basic listening function for the DA
 * and SA. On creation, a StreamListener is created to listen for
 * clients that need to initiate unicast connections. The main object
 * listens on the SLP multicast address for SLP multicasts, and
 * passes the results off to the RequestHandler for direction to
 * the proper table. The RequestHandler object is executed in a different
 * thread to maximize throughput. Note that unicast datagram requests
 * may also enter through this class, since many systems don't distinguish
 * between the multicast and datagram queues for a port.
 *
 * @author James Kempf, Erik Guttman
 */

class Listener extends Thread {

    private DatagramSocket dss = null; 	    // SLP multicast/broadcast socket.
    private InetAddress interfac = null;    // Interface on which we listen.
    private int pktsize = 0;	    	    // MTU of network packet.
    private Vector groups = new Vector();   // Multicast groups monitored.

    static private SLPConfig config = null; // Config object for properties
    static private Hashtable listeners =
			new Hashtable();    // Listeners keyed by interface.

    // Initialize the complex of listener/sender objects on the interface.
    //  This includes a datagram listener, a DAAdvertiser (which shares
    //  the same socket as the datagram listener) if a DA, and a
    //  stream listener.

    static void initializeInterfaceManagers(InetAddress interfac)
	throws ServiceLocationException {

	// If we've done the intializtion, forget it.

	if (listeners.get(interfac) != null) {
	    return;

	}

	// Get config object.

	if (config == null) {
	    config = SLPConfig.getSLPConfig();

	}

	// Create a listener object for this interface.

	Listener listener = new Listener(interfac);

	// Start thread to listen for incoming datagram request.

	listener.start();

	// Create a stream listener object for this interface.

	StreamListener.initializeStreamListenerOnInterface(interfac);

	// We wait until this point to advertise ourselves as DAs. At
	//  this point, we have the listeners up to handle any messages
	//  that might come in as a result.

    }

    // Return the socket for the listener on the designated interface.
    //  DAAdvertisers and the SLPv1 codes uses this to share the
    //  same socket as the main datagram listener.

    static DatagramSocket returnListenerSocketOnInterface(
						InetAddress interfac) {

	Listener listener = (Listener)listeners.get(interfac);

	if (listener != null) {
	    return listener.dss;
	}

	return null;
    }

    // Add the listener on the interface to the multicast group.

    static void
	addListenerToMulticastGroup(InetAddress interfac, InetAddress maddr)
	throws ServiceLocationException {

	Listener listener = (Listener)listeners.get(interfac);

	// Ignore if we haven't got it.

	if (listener == null) {
	    return;

	}

	DatagramSocket dss = listener.dss;

	// Only add if we're multicast.

	if (dss instanceof MulticastSocket) {
	    MulticastSocket mss = (MulticastSocket)dss;

	    try {
		mss.joinGroup(maddr);

		// Record the groups monitored.

		listener.groups.addElement(maddr);

	    } catch (IOException ex) {
		new ServiceLocationException(
				ServiceLocationException.NETWORK_INIT_FAILED,
				"socket_initializtion_failure",
				new Object[] {maddr, ex.getMessage()});

	    }
	}
    }

    // Refresh the listener socket on the interface. If there is no
    //  listener, then simply return a new send socket.

    static DatagramSocket
	refreshSocketOnInterface(InetAddress interfac) {

	Listener listener = (Listener)listeners.get(interfac);

	if (listener == null) {
	    return config.refreshMulticastSocketOnInterface(interfac, null);

	}

	listener.dss.close();

	listener.dss =
	    config.refreshMulticastSocketOnInterface(interfac,
						     listener.groups);

	return listener.dss;

    }

    // Create a Listener for the interface.

    private Listener(InetAddress interfac) throws ServiceLocationException {

	// Get packet size.

	this.pktsize = config.getMTU();

	this.interfac = interfac;

	// Get a socket for this interface.

	this.dss = config.getMulticastSocketOnInterface(interfac, false);

	// Record here so we can use standard utility to add to multicast
	// group.

	listeners.put(interfac, this);

	// If we're multicasting, add to the default SLP group.

	addListenerToMulticastGroup(interfac, config.getMulticastAddress());

    }

    // Listen on multicast for incoming requests, spawn a RequestHandler
    //  to process the datagram.

    public void run()  {

	boolean retry = true;
	String castName = "Multicast";

	if (config.isBroadcastOnly()) {
	    castName = "Broadcast";

	}

	setName("SLP "+castName+" Datagram Listener:"+
		dss.getLocalAddress()+"/"+
		dss.getLocalPort());

	// Loop forever, receiving datagrams and spawning a request handler
	//  to handle it.

	while (true) {
	    byte[] inbuf = new byte[pktsize];
	    DatagramPacket incoming = new DatagramPacket(inbuf, pktsize);

	    // Block on datagram receive.

	    try {
		dss.receive(incoming);

		if (config.traceMsg()) {
		    config.writeLog("request_in",
				    new Object[] {incoming.getAddress(),
						      interfac});
		}

		RequestHandler rh =
		    new RequestHandler(incoming, interfac, config);
		rh.start();

	    } catch (IOException ex) {

		// Die if we can't retry.

		Assert.slpassert(retry,
			      "datagram_io_error",
			      new Object[] {dss.getLocalAddress(),
						ex.getMessage()});

		retry = false;

		config.writeLog("datagram_io_error",
				new Object[] {dss.getLocalAddress(),
						  ex.getMessage()});

		// Close cast socket, get a new one and try again.

		dss.close();
		dss = config.refreshMulticastSocketOnInterface(interfac,
							       groups);

	    }
	}
    }
}