root/as3/OSCemote/branches/saqoosha/server/flosc-0.3.1/OscServer.java

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

/**
 *
 * OscServer
 * <BR><BR>
 * OpenSoundControl UDP Server for Gateway.
 *
 * Based on CommServer by Derek Clayton and dumpOSC by Matt Wright.
 *
 * Thanks to Jesse Gilbert (j@resistantstrain.net) for helping me with
 * the static socket.
 *
 * @author  Ben Chun        ben@benchun.net
 * @version 1.0
 */

public class OscServer extends Thread {
    private DatagramSocket oscSocket;       // incoming UDP socket
    private int port;                       // incoming UDP port
    private Gateway gateway;                // Gateway for this server
    private static OscSocket outSocket;     // outgoing UDP socket
    static 
    {
        try
            {
                outSocket = new OscSocket();
            }
        catch( SocketException se )
            {
                se.printStackTrace();
            }
    }
    
    /**
     * Constructor for the OscServer.
     *
     * @param   port     UDP port for OSC communication.
     * @param   gateway  parent Gateway.
    */
    public OscServer(int port, Gateway gateway) {
        this.port = port;
        this.gateway = gateway;
        System.out.println("OscServer created...");
    }

    /**
     * Thread run method.  Monitors incoming messages.
    */  
    public void run() {
        try{
            // --- create a new UDP OSC socket
            oscSocket = new DatagramSocket(port);
            Debug.writeActivity("UDP OSC server started on port: " + port);
            while(true) {
                byte[] datagram  = new byte[1024];
                DatagramPacket packet = new DatagramPacket(datagram, datagram.length);

                // block until a datagram is received
                oscSocket.receive(packet);

                // parse the packet
                Debug.writeActivity("Received UDP packet, parsing OSC...");
                OscPacket oscp = new OscPacket();
                oscp.address = packet.getAddress();
                oscp.port = packet.getPort();
                parseOscPacket(datagram, packet.getLength(), oscp);
                
                // then send it as XML to all the flash clients
                gateway.broadcastMessage( oscp.getXml() );

                // DEBUG
                //System.out.println("** raw packet **");
                //OscPacket.printBytes( datagram );
                //System.out.println("** constructed packet **");
                //OscPacket.printBytes( oscp.getByteArray() );

            }
        } catch(IOException ioe) {
            Debug.writeActivity("Server error...Stopping UDP OSC server");
            // kill this server
            killServer();
        }
    }

    /**
     * This method is based on dumpOSC::ParseOSCPacket.  It verifies
     * that the packet is well-formed and puts the data into an
     * OscPacket object, or else prints useful error messages about
     * what went wrong.
     *
     * @param   datagram  a byte array containing the OSC packet
     * @param   n         size of the byte array
     * @param   packet    the OscPacket object to put data into
     */
    public void parseOscPacket(byte[] datagram, int n, OscPacket packet) {
        int size, i;

        if ( (n % 4) != 0 ) {
            Debug.writeActivity("SynthControl packet size (" + n +
                          ") not a multiple of 4 bytes, dropped it.");
            return;
        }

        String dataString = new String(datagram);
        if ( ( n >= 8 ) && dataString.startsWith( "#bundle" ) ) {
            /* This is a bundle message. */
            
            if ( n < 16 ) {
                Debug.writeActivity("Bundle message too small (" + n +
                              " bytes) for time tag, dropped it.");
                return;
            }

            /* Get the time tag */
            Long time = new Long( Bytes.toLong( Bytes.copy(datagram, 8, 8) ) );
            packet.setTime(time.longValue());

            i = 16; /* Skip "#bundle\0" and time tags */
            while( i<n ) {
                size = ( Bytes.toInt( Bytes.copy(datagram, i, i+4 ) ) );
                if ((size % 4) != 0) {
                    Debug.writeActivity("Bad size count" + size +
                                  "in bundle (not a multiple of 4)");
                    return;
                }
                if ( (size + i + 4) > n ) {
                    Debug.writeActivity("Bad size count" + size + "in bundle" +
                                  "(only" + (n-i-4) + "bytes left in entire bundle)");
                    return;
                }
                
                /* Recursively handle element of bundle */
                byte[] remaining =  Bytes.copy(datagram, i+4);
                parseOscPacket(remaining, size, packet);
                i += (4 + size);
            }
        } else {
            /* This is not a bundle message */      
            Vector nameAndData = getStringAndData(datagram, n);

            String name = (String) nameAndData.firstElement();
            OscMessage message = new OscMessage(name);

            byte[] data = (byte[]) nameAndData.lastElement();
            Vector[] typesAndArgs = getTypesAndArgs(data);
            message.setTypesAndArgs(typesAndArgs[0], typesAndArgs[1]);

            packet.addMessage(message);
        }
    }

    /**
     * Takes a byte array starting with a string padded with null
     * characters so that the length of the entire block is a multiple
     * of 4, and seperates it into a String and a byte array of the
     * remaining data.  These are then returned in a Vector.
     *
     * @param   block           block of data beginning with a string
     * @param   stringLength    number of characters in the string
    */  
    public Vector getStringAndData(byte[] block, int stringLength) {
        Vector v = new Vector();
        int i;
        
        if ( stringLength %4 != 0) {
            Debug.writeActivity("printNameAndArgs: bad boundary");
            return v;
        }

        for (i = 0; block[i] != '\0'; i++) {
            if (i >= stringLength) {
                Debug.writeActivity("printNameAndArgs: Unreasonably long string");
                return v;
            }
        }
        // v.firstElement() is the String
        v.addElement( new String(Bytes.copy(block, 0, i)) );

        i++;
        for (; (i % 4) != 0; i++) {
            if (i >= stringLength) {
                Debug.writeActivity("printNameAndArgs: Unreasonably long string");
                return v;
            }
            if (block[i] != '\0') {
                Debug.writeActivity("printNameAndArgs: Incorrectly padded string.");
                return v;
            }
        }
        // v.elementAt(1) is the position in the orginal byte[] where the data starts
        v.addElement( new Integer(i) );
        // v.lastElement() is the byte[] of data
        v.addElement( Bytes.copy( block, i ) );
        return v;
    }

    /**
     * Returns an array of Vectors containing types and arguments.
     *
     * @param   block   byte array containing types and arguments
    */
    public Vector[] getTypesAndArgs( byte[] block ) {
        // TBD : throw exceptions or something when there are no type tags
        int n = block.length;
        Vector[] va = new Vector[2];
        if (n != 0) {
            if (block[0] == ',') {
                if (block[1] != ',') {
                    /* This message begins with a type-tag string */
                    va = getTypeTaggedArgs( block );
                } else {
                    /* Double comma means an escaped real comma, not a
                     * type string */
                    va = getHeuristicallyTypeGuessedArgs( block );
                }
            } else {
                va = getHeuristicallyTypeGuessedArgs( block );
            }
        }
        return va;
    }

    /**
     * Returns Vectors containing the types and arguments from a
     * type-tagged byte array
     *
     * @param   block   a byte array with type-tagged data
    */
    public Vector[] getTypeTaggedArgs( byte[] block ) {
        Vector typeVector = new Vector();
        Vector argVector = new Vector();
        int p = 0;

        /* seperate the block into the types byte array and the
         * argument byte array*/
        Vector typesAndArgs = getStringAndData(block, block.length);
        byte[] args = (byte[]) typesAndArgs.lastElement();
        
        for (int thisType=1; block[thisType] != 0; thisType++) {
            switch (block[thisType]) {

            case '[' :
                typeVector.addElement(new Character('['));
                break;

            case ']' :
                typeVector.addElement(new Character(']'));
                break;

            case 'i': case 'r': case 'm': case 'c':
                typeVector.addElement(new Character('i'));
                argVector.addElement( new Integer( Bytes.toInt( Bytes.copy(args, p, p+4) )) );
                p += 4;
                break;
                
            case 'f':
                typeVector.addElement(new Character('f'));
                argVector.addElement( new Float( Bytes.toFloat( Bytes.copy(args, p, p+4) )) );
                p += 4;
                break;
                
            case 'h': case 't':
                typeVector.addElement(new Character('h'));
                argVector.addElement( new Long( Bytes.toLong( Bytes.copy(args, p, p+8) )) );
                p += 8;
                break;
                
            case 'd':
                typeVector.addElement(new Character('d'));
                argVector.addElement( new Double( Bytes.toDouble( Bytes.copy(args, p, p+8) )) );
                p += 8;
                break;
                
            case 's': case 'S':
                typeVector.addElement(new Character('s'));
                byte[] remaining = Bytes.copy(args, p);
                Vector v = getStringAndData( remaining, remaining.length );
                argVector.addElement( (String)v.firstElement() );
                p += ((Integer)v.elementAt(1)).intValue();
                break;
                
            case 'T':
                typeVector.addElement(new Character('T')); 
                break;
            case 'F':
                typeVector.addElement(new Character('F'));
                break;
            case 'N':
                typeVector.addElement(new Character('N'));
                break;
            case 'I':
                typeVector.addElement(new Character('I'));
                break;

            default:
                Debug.writeActivity( "[Unrecognized type tag " +
                               block[thisType] + "]" );
            }
        }

        Vector[] returnValue = new Vector[2];
        returnValue[0] = typeVector;
        returnValue[1] = argVector;
        return returnValue;
    }
        

    /**
     * Returns the arguments from a non-type-tagged byte array
     *
     * @param   block   a byte array containing data
    */
    public Vector[] getHeuristicallyTypeGuessedArgs( byte[] block ) {
        // TBD : handle packets without type tags
        Debug.writeActivity("Bad OSC packet: No type tags");
        return new Vector[2];
    }


   /**
     * Sends an OscPacket via an OscSocket.  the packet contains the
     * address and port information.
     *
     * @param packet  the OscPacket to send
     */
    public void sendPacket(OscPacket packet) {

        try {
            Debug.writeActivity("OscServer sending UDP packet...");
            outSocket.send(packet);
        } catch(IOException ioe) {
            Debug.writeActivity("sendPacket error...Stopping UDP OSC server");
            // kill this server
            killServer();
        }
    }


    /**
     * Stops the UDP server.
    */
    public void killServer() {
        // --- close the socket
        oscSocket.close();
        Debug.writeActivity("UDP OSC server stopped");
    }
}