tcpconnection.java

SMC takes a state machine stored in a .sm file and generates a State pattern in twelve programming l

//
// The contents of this file are subject to the Mozilla Public
// License Version 1.1 (the "License"); you may not use this file
// except in compliance with the License. You may obtain a copy
// of the License at http://www.mozilla.org/MPL/
// 
// Software distributed under the License is distributed on an
// "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
// implied. See the License for the specific language governing
// rights and limitations under the License.
// 
// The Original Code is State Machine Compiler (SMC).
// 
// The Initial Developer of the Original Code is Charles W. Rapp.
// Portions created by Charles W. Rapp are
// Copyright (C) 2000 - 2003 Charles W. Rapp.
// All Rights Reserved.
// 
// Contributor(s): 
//
// Name
//  TcpConnection.java
//
// Description
//  Both TCP client and server sockets are TCP connections.
//
// RCS ID
// $Id: TcpConnection.java,v 1.2 2007/08/05 13:21:09 cwrapp Exp $
//
// CHANGE LOG
// $Log: TcpConnection.java,v $
// Revision 1.2  2007/08/05 13:21:09  cwrapp
// Version 5.0.1 check-in. See net/sf/smc/CODE_README.txt for more information.
//
// Revision 1.1  2005/05/28 12:49:21  cwrapp
// Added Ant examples 1 - 7.
//
// Revision 1.0  2004/05/31 13:27:57  charlesr
// Initial revision
//

package smc_ex6;

import java.io.IOException;
import java.lang.reflect.Method;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public abstract class TcpConnection
    implements DatagramSocketListener,
               TimerListener
{
// Member methods.

    public final synchronized void close()
    {
        _fsm.Close();
        return;
    }

    public final synchronized void handleReceive(DatagramPacket packet,
                                                 AsyncDatagramSocket dgram_socket)
    {
        TcpSegment segment = new TcpSegment(packet);
        Object[] args = new Object[1];

        // Generate the appropriate transition based on the
        // header flags.
        args[0] = segment;

        // DEBUG
//          System.out.println("Receive event from " +
//                             packet.getAddress() +
//                             ":" +
//                             Integer.toString(packet.getPort()) +
//                             ":\n" +
//                             segment);

        try
        {
            _transition_table[segment.getFlags()].invoke(_fsm, args);
        }
        catch (Exception jex)
        {
            System.err.println(jex);
            jex.printStackTrace();
        }

        return;
    }

    public final void handleError(Exception e,
                                  AsyncDatagramSocket dgram_socket)
    {
        // TODO
        // Generate the appropriate transition.
    }

    public final synchronized void handleTimeout(String name)
    {
        if (name.compareTo("CONN_ACK_TIMER") == 0)
        {
            _fsm.ConnAckTimeout();
        }
        else if (name.compareTo("TRANS_ACK_TIMER") == 0)
        {
            _fsm.TransAckTimeout();
        }
        else if (name.compareTo("CLOSE_ACK_TIMER") == 0)
        {
            _fsm.CloseAckTimeout();
        }
        else if (name.compareTo("CLOSE_TIMER") == 0)
        {
            _fsm.CloseTimeout();
        }
        else if (name.compareTo("SERVER_OPENED") == 0)
        {
            _fsm.Opened();
        }
        else if (name.compareTo("CLIENT_OPENED") == 0)
        {
            _fsm.Opened(_address, _port);
        }
        else if (name.compareTo("OPEN_FAILED") == 0)
        {
            _fsm.OpenFailed(_errorMessage);
            _errorMessage = null;
        }

        return;
    }

    // Server socket constructor.
    protected TcpConnection(TcpConnectionListener listener)
    {
        _listener = listener;
        _fsm = new TcpConnectionContext(this);
        _sequence_number = 0;
        _async_socket = null;
        _address = null;
        _port = -1;
        _server = null;
        _errorMessage = null;

        // Turn on FSM debugging.
        // _fsm.setDebugFlag(true);

        return;
    }

    // "Accepted" socket constructor.
    protected TcpConnection(InetAddress address,
                            int port,
                            DatagramSocket socket,
                            int sequence_number,
                            TcpServer server,
                            TcpConnectionListener listener)
    {
        _async_socket = new AsyncDatagramSocket(socket, this);
        _address = address;
        _port = port;
        _sequence_number = sequence_number;
        _server = server;
        _errorMessage = null;
        _listener = listener;
        _fsm = new TcpConnectionContext(this);

        // Turn on FSM debugging.
        // _fsm.setDebugFlag(true);

        _async_socket.start();

        return;
    }

    protected final synchronized void passiveOpen(int port)
    {
        _fsm.PassiveOpen(port);
        return;
    }

    protected final synchronized void activeOpen(InetAddress address, int port)
    {
        _fsm.ActiveOpen(address, port);
        return;
    }

    protected final synchronized void acceptOpen(TcpSegment segment)
    {
        _fsm.AcceptOpen(segment);
        return;
    }

    protected final void setListener(TcpConnectionListener listener)
        throws IllegalStateException
    {
        if (_listener != null)
        {
            throw(new IllegalStateException("Socket listener already set"));
        }
        else
        {
            _listener = listener;
        }

        return;
    }

    protected synchronized void transmit(byte[] data, int offset, int length)
    {
        _fsm.Transmit(data, offset, length);
        return;
    }

    //-----------------------------------------------------------
    // State Map Actions.
    //
    /* package */ InetAddress getFarAddress()
    {
        return (_address);
    }

    /* package */ int getFarPort()
    {
        return (_port);
    }

    /* package */ int getSequenceNumber()
    {
        return (_sequence_number);
    }

    /* package */ void openServerSocket(int port)
    {
        DatagramSocket socket;

        try
        {
            // Create the asynchronous datagram socket listener and
            // start it running.
            socket = new DatagramSocket(port);
            _async_socket = new AsyncDatagramSocket(socket, this);
            _async_socket.start();

            // Set the sequence number.
            _sequence_number = ISN;

            startTimer("SERVER_OPENED", MIN_TIMEOUT);
            
        }
        catch (Exception jex)
        {
            _errorMessage = jex.getMessage();
            startTimer("OPEN_FAILED", MIN_TIMEOUT);
        }

        return;
    }

    /* package */ void openClientSocket(InetAddress address,
                                        int port)
    {
        DatagramSocket socket;

        try
        {
            socket = new DatagramSocket();

            _address = address;
            _port = port;
            _async_socket =
                    new AsyncDatagramSocket(socket, this);
            _async_socket.start();

            // Set the sequence number.
            _sequence_number = ISN;

            startTimer("CLIENT_OPENED", MIN_TIMEOUT);
        }
        catch (Exception jex)
        {
            // Do not issue a transition now since we are already
            // in a transition. Set a 1 millisecond timer and
            // issue transition when timer expires.
            _errorMessage = jex.toString();
            startTimer("OPEN_FAILED", MIN_TIMEOUT);
        }

        return;
    }

    /* package */ void openSuccess()
    {
        _listener.opened(this);
        return;
    }

    /* package */ void openFailed(String reason)
    {
        _listener.openFailed(reason, this);
        return;
    }

    /* package */ void closeSocket()
    {
        _async_socket.closeDatagramSocket();
        _async_socket = null;
        _address = null;
        _port = -1;
        return;
    }

    /* package */ void halfClosed()
    {
        if (_listener != null)
        {
            _listener.halfClosed(this);
        }

        return;
    }

    /* package */ void closed(String reason)
    {
        if (_listener != null)
        {
            _listener.closed(reason, this);
            _listener = null;
        }

        return;
    }

    /* package */ void clearListener()
    {
        _listener = null;
        return;
    }

    /* package */ void transmitted()
    {
        if (_listener != null)
        {
            _listener.transmitted(this);
        }

        return;
    }