udpmessagesocket.java

Java SIP

/*
 * This file was derived from libdissipate, an open source SIP library. The original file 
 * was modified on 1/23/2001.  Please see
 * http://www.div8.net/dissipate for more information.
 *
 * Copyright (c) 2000 Billy Biggs <[e-mail]>
 *
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 * 
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 * License for more details.
 * 
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 *
 */
/**
 * class UDPMessageSocket
 * 
 * This is the UDP implementation of the MessageSocket class.  It is used
 * for performing operations on a new or existing UDP socket.
 *
 * This code has been generated using C2J++
 * C2J++ is based on Chris Laffra's C2J ([e-mail])
 * Read general disclaimer distributed with C2J++ before using this code
 * For information about C2J++, send mail to [e-mail]
 */
package org.mitre.jsip;

import java.net.SocketException;
import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.io.IOException;

public class UDPMessageSocket extends MessageSocket
{

    /**
     * UDPMessageSocket
     */
    public UDPMessageSocket()
    {
	type = UDP;

	didcomplain = false;

	// set up the receive socket??????????

    }

    /**
     * connect
     * @param portnum
     * @return int
     */
    public int connect(String hostname, int portnum)
    {
	fSendPort = portnum;
	
	sendSocket = null;
	try {
	    InetAddress raddr = InetAddress.getByName( hostname );
	    sendSocket = new DatagramSocket();
	    sendSocket.connect( raddr, portnum );
	} catch (UnknownHostException uhe) {
	    System.err.println("Unable to connect to host: " + hostname);
	    return -1;
	} catch (SocketException se) {
	    System.err.println("Unable to set up socket to remote host: " + se);
	    didcomplain =  true;
	    return -1;
	}

	return 0;
    }

    /**
     * connect
     * @param portnum
     * @return int
     */
    public int connect(InetAddress host, int portnum)
    {
	fSendPort = portnum;
	
	sendSocket = null;
	try {
	    sendSocket = new DatagramSocket();
	    sendSocket.connect( host, portnum );
	} catch (SocketException se) {
	    System.err.println("Unable to set up socket to remote host: " + se);
	    didcomplain =  true;
	    return -1;
	}

	return 0;
    }

    /**
     * send
     * @param sendbuffer
     * @param length
     * @return int
     */
    public int send(String sendbuffer, int length)
    {
	int numbytes;
	int retries = 0;

	DatagramPacket dp = new DatagramPacket(sendbuffer.getBytes(), sendbuffer.length());
  	fSendThread = new DatagramSendThread( dp, sendSocket, fRetryTimer );
  	fSendThread.start();

	return 0;
    }

    /**
     * receive
     * @param recvbuffer
     * @param maxlength
     * @return int
     */
    public int receive(byte[] recvbuffer, int maxlength)
    {
	int numbytes = 0;
	DatagramPacket dp = null;

	try {
	    dp = new DatagramPacket(recvbuffer, maxlength);

	    fSocket.receive(dp);
	} catch (IOException ioe) {
	    System.err.println( "UDPMessageSocket::receive(): recvfrom() failed: " + ioe);
	    return -1;
	}

	// not sure about this
	// *** LOOK AT *** don't need to send all this stuff to the thread
	DatagramReplyThread drt = new DatagramReplyThread( dp, fSocket, fRetryTimer );
	drt.start();
	
	return numbytes;
    }

    /**
     * listen
     * @param portnum
     * @return int
     */
    public int listen(MessageQueue queue)
    {
	// setup port on fSocket
	bind();

	byte[] recvbuffer = new byte[DEFAULT_MAX_DATAGRAM_SIZE];
	int maxlength = DEFAULT_MAX_DATAGRAM_SIZE;

	DatagramPacket dp = new DatagramPacket( recvbuffer, maxlength );

	DatagramReplyThread drt = new DatagramReplyThread( dp, fSocket, queue, fRetryTimer );
	drt.start();

	return 0;
    }

    /**
     * accept
     * @return int
     */
    public void accept()
    {
//	return socketfd;
    }

    /**
     * listenOnEvenPort
     * @return int
     */
    public int listenOnEvenPort()
    {
	return 0;
    }
    
    protected void bind() 
    {
	// bind to the specific local port 
	try {
	    if ( localPort != 0 ) {
		fSocket = new DatagramSocket(localPort);
	    } else {
		fSocket = new DatagramSocket();
	    }
	} catch (SocketException se) {
	    System.err.println( "Unable to bind to port " + localPort + " because " + se );
	    System.err.println( "Going to die until you fix this" );
	    System.exit( -1 );
	}
    }

    public void close() {
	if ( fSocket != null ) fSocket.close();
	if ( sendSocket != null ) sendSocket.close();

	fSocket = null;
	sendSocket = null;
    }

    // class variables
    protected boolean didcomplain;

    protected DatagramSocket fSocket, sendSocket;
    protected DatagramPacket fSendDatagram, fReceiveDatagram;

    protected int fSendPort;                      // fReceivePort = localPort;
    protected DatagramReplyThread fReplyThread;
    protected DatagramSendThread fSendThread;

    protected int fRetryTimer = 10000;
    protected int fRetryCount = 0;

    public final static int DEFAULT_MAX_DATAGRAM_SIZE = 1024;
    public final static int DEFAULT_MAX_RETRIES = 5;
}

// ***********************************************************************************************

/**
 * A class for dealing with the problems of waiting
 * for a datagram response.
 */
class DatagramReplyThread extends Thread
{
    private final static boolean fDebugOn = true;
    
    DatagramPacket fRecvPacket;
    DatagramSocket fRecvSocket;
    MessageQueue fRecvQueue;
    int fWaitTime = 50000;

    public  int fReceivedState = 0;//neither received nor failed
    public final static int DEFAULT_MAX_DATAGRAM_SIZE = 1024;
    
    /**
     * @param recvPacket The packet in which to stuff our results.
     * @param recvSocket The socket on which to receive data.
     * @param totalWaitTime The amount of time to wait for a response.
     */
    public DatagramReplyThread(DatagramPacket recvPacket,
			       DatagramSocket recvSocket,
			       int totalWaitTime)
    {
	fRecvPacket = recvPacket;
	fRecvSocket = recvSocket;
	fWaitTime = totalWaitTime;
    }//DatagramReplyThread
    
    public DatagramReplyThread(DatagramPacket recvPacket,
			       DatagramSocket recvSocket,
			       MessageQueue  queue,
			       int totalWaitTime) {
	fRecvPacket = recvPacket;
	fRecvSocket = recvSocket;
	fRecvQueue = queue;
	fWaitTime = totalWaitTime;
    }

    /**
     * perform all the useful stuff here
     */
    public synchronized void run()
    {
	if (fDebugOn)
	    System.out.println("DatagramReplySlave running...");

	for (;;) {
	    DatagramPacket dp = new DatagramPacket( new byte[DEFAULT_MAX_DATAGRAM_SIZE],
						    DEFAULT_MAX_DATAGRAM_SIZE );
	    try {
		if (fDebugOn)
		    System.out.println("DatagramReplySlave receiving...");
		fRecvSocket.receive( dp );
		fReceivedState = 1;//received OK!
		if (fDebugOn)
		    System.out.println("DatagramReplySlave received OK!");
	    }
	    catch (IOException receiveEx) {
		System.err.println("receive failed! " + receiveEx);
		fReceivedState = -1;
	    }; //receive failed!
	
	    // see if we can create a new message and put it in the queue
	    try {
		SipMessage message = new SipMessage( new String( dp.getData() ) );
		fRecvQueue.AddQueueItem(message);
	    } catch (BadHeaderException bhe) {
		System.err.println("Error parsing incoming message. Rejecting because " +
				   bhe.toString());
	    }

	    //	    fRecvPacket.setData( new byte[1024] );
	}
    } //run
    
} /* class DatagramReplySlave */

// **************************************************************************************

/**
 * a class for dealing with the problems of sending a datagrams
 */
class DatagramSendThread extends Thread
{
    
    protected final static boolean fDebugOn = true;
    
    DatagramPacket fSendPacket;
    DatagramSocket fSendSocket;
    public  int fSendState = 0;//neither received nor failed
    protected int fRetryInterval; //in msec
    
    /**
     * @param sendPacket
     */
    public DatagramSendThread(DatagramPacket sendPacket,
			      DatagramSocket sendSocket,
			      int retryTime)
    {
	fSendPacket = sendPacket;
	fSendSocket = sendSocket;
	fRetryInterval = retryTime;
	
    }//DatagramSendThread
    
    
    /**
     * proceed with all of the time-consuming stuff here
     */
    public void run()
    {
	if (fDebugOn)
	    System.out.println("DatagramSendThread running...");
	
	try {
	    if (fDebugOn)
		System.out.println("DatagramSendThread sending " + 
				   fSendPacket.getLength() + " bytes...");
	    fSendSocket.send(fSendPacket);
	    fSendState = 0;//sent OK!
	    if (fDebugOn)
     	        System.out.println("DatagramSendThread sent ok!");
	}
	catch (IOException sendEx) {
	    if (fDebugOn)
		System.err.println("send failed! " + sendEx);
	    fSendState = -1;
	}
  	finally {
  	    if ( fSendSocket != null ) fSendSocket.close();
  	}
    } // run
    
    
}/* class DatagramSendThread */