getClients() {
return clients;
}
/**
* Is the serverRunning?
*
* @return True = yes, false = no;
*/
public boolean isServerRunning() {
return isServerRunning;
}
}
JXBStreamer/src/com/com/superhac/JXBStreamer/Core/InternalIPFinder.java 0000700 0001750 0001750 00000004510 10540072762 026117 0 ustar sjscott sjscott package com.superhac.JXBStreamer.Core;
/*
* InternalIPFinder.java
*
* Created on April 4, 2006, 10:00 PM
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.Enumeration;
/**
* A static class for getting the servers own binding IP address.
* @author sjscott
*/
public class InternalIPFinder {
/**
* Creates a new instance of InternalIPFinder
*/
public InternalIPFinder() {
}
public static String getLocalIPAddress()
{
String localIP="";
localIP = getSiteLocalIP();
return localIP;
}
private static String getSiteLocalIP()
{
String localIP ="";
try {
Enumeration interfaces = NetworkInterface.getNetworkInterfaces();
while (interfaces.hasMoreElements()) {
NetworkInterface nif = (NetworkInterface) interfaces.nextElement();
Enumeration addresses = nif.getInetAddresses();
//System.out.println("Interface " + nifs++ + ": " + nif.getDisplayName());
while (addresses.hasMoreElements()) {
InetAddress addr = (InetAddress) addresses.nextElement();
// if the SiteLocal is true this is the IP address of the host.
if(addr.isSiteLocalAddress())
{
localIP = addr.getHostAddress();
}
/* System.out.println("\tAddress " + naddrs++ + ": " +
addr.getCanonicalHostName());
System.out.println("\t\tIP: " + addr.getHostAddress());
System.out.println("\t\tlinklocal: " +
addr.isLinkLocalAddress());
System.out.println("\t\tsitelocal: " +
addr.isSiteLocalAddress());
System.out.println("\t\tloopback: " +
addr.isLoopbackAddress());
*/
}
}
}
catch (Exception e)
{
System.out.println("Problems getting local ip address!");
return localIP;
}
return localIP;
}
}
JXBStreamer/src/com/com/superhac/JXBStreamer/Core/FileHandlerObject.java 0000700 0001750 0001750 00000013511 10540072762 026267 0 ustar sjscott sjscott package com.superhac.JXBStreamer.Core;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.util.logging.Logger;
/**
* The FileHandlerObject maps Files to handles and provides services for
* fulfilling client requests on Files. E.g. get file data.
*
*
* More information can be found at Superhac.com
*
* @author Steven Scott (superhac007@gmail.com)
*/
public class FileHandlerObject {
/** The handle represting the file */
private int handle;
/** The file */
private File file;
/** The max position of the File */
private long maxPosition; // the real file size in bytes
/** The current position in the File */
private long currentFilePosition; // starts at zero and always at the
// position of the next read.
/**
* The number of bytes transfered from file. Running Total. inc on file
* reads!
*/
private long fileTransferBytes = 0;
/** The starting time of the handle being opened... */
private long startTime;
/** the File Stream representing the File */
private RandomAccessFile fstream;
/** Debug Logger */
private static Logger logger;
protected FileHandlerObject(int handle, File file) {
this.handle = handle;
this.file = file;
// init start time... This is used in calculating the transfer time
startTime = System.currentTimeMillis();
// open the file
try {
fstream = new RandomAccessFile(file, "r");
currentFilePosition = fstream.getFilePointer();
this.maxPosition = fstream.length();
} catch (FileNotFoundException e) {
System.out.println("Should not have happend(FIleHandler): " + e);
System.exit(1);
} catch (IOException e) {
System.out.println("Should not have happend(FIleHandler): " + e);
System.exit(1);
}
logger = com.superhac.JXBStreamer.Core.Debug.getLogger();
}
/**
* Read a number of bytes from file
*
* @param numberOfBytes
* the number of bytes to read
* @return A bytebuffer containing the read bytes.
*/
protected ByteBuffer read(int numberOfBytes) {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Reading and packing file data. Read bytes req: "
+ numberOfBytes + " Current POS: " + currentFilePosition
+ " Max Pos: " + maxPosition);
try {
byte data[] = new byte[numberOfBytes];
int bytesRead = fstream.read(data);
ByteBuffer buf = ByteBuffer.allocate(20000); // at most 20k...
// add check later
if (bytesRead == -1) // eof
{
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("End of File... Sending null. "
+ "Current POS: " + currentFilePosition
+ " Max Pos: " + maxPosition);
return null;
} else {
currentFilePosition = fstream.getFilePointer(); // increment
fileTransferBytes += bytesRead;
buf.putInt(bytesRead);
return buf.put(data, 0, bytesRead);
}
} catch (IOException e) {
System.out.println("Should not have happend(FIleHandler read): "
+ e);
System.exit(1);
}
// should never get here
return null;
}
/**
* Seek to a location withing the file...
*
* @param offset
* an amount to seek from the SeekType
* @param seekType
* (0 = forward from the beginning of the file, 1 = backward from
* the end of the file, 2 = forward from the current position, 3 =
* backwards from the current position)
* @return True if its a success or false if not.
*/
protected boolean seekFile(long offset, byte seekType) {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Seeking file data: offset: " + offset + " SeekType:"
+ seekType + " Current POS: " + currentFilePosition
+ " Max Pos: " + maxPosition);
boolean error = false;
long newOffset;
try {
switch (seekType) {
case XBMSPEncoderDecoder.XBMSP_FILE_SEEK_TYPE_FWDFROMBEG:
if (offset <= maxPosition) {
fstream.seek(offset);
} else {
error = true;
}
break;
case XBMSPEncoderDecoder.XBMSP_FILE_SEEK_TYPE_BCKFROMEND:
newOffset = maxPosition - offset;
if (newOffset >= 0 && newOffset <= maxPosition) {
fstream.seek(newOffset);
} else {
error = true;
}
break;
case XBMSPEncoderDecoder.XBMSP_FILE_SEEK_TYPE_FWDFROMCUR:
newOffset = currentFilePosition + offset;
if (newOffset <= maxPosition) {
fstream.seek(newOffset);
} else {
error = true;
}
break;
case XBMSPEncoderDecoder.XBMSP_FILE_SEEK_TYPE_BCKFROMCUR:
newOffset = currentFilePosition - offset;
if (newOffset >= 0) {
fstream.seek(newOffset);
} else {
error = true;
}
break;
default:
error = true;
}
} catch (IOException e) {
System.out.println("Should not have happend(FIleHandler seek): "
+ e);
System.exit(1);
}
// System.out.println("Offset: "+currentFilePosition+" Error: "+error +
// "Type: "+seekType);
return error;
}
/**
* Get the file name represented by FileHandleObject
*
* @return filename
*/
protected String getFileName() {
return file.getName();
}
/**
* Gets the File object of the file represented by FileHandleObject
*
* @return the File object
*/
protected File getFile() {
return file;
}
/**
* Gets the handle number
*
* @return handle number
*/
protected int getHandle() {
return handle;
}
/**
* Gets the file transfer rate in seconds. Based on the creation time of the
* object , the current system time and the number of bytes transfered. E.g.
* reads.
*
* @return The number of bytes per second transfered.
*/
protected long getFileTransferRate() {
long duration = (System.currentTimeMillis() - startTime) / 1000; // in
// secs
long bytesPerSec = 0;
if (fileTransferBytes > 0 && duration > 0)
bytesPerSec = fileTransferBytes / duration;
return bytesPerSec;
}
}
JXBStreamer/src/com/com/superhac/JXBStreamer/Core/XBMSPEncoderDecoder.java 0000700 0001750 0001750 00000045412 10540072762 026447 0 ustar sjscott sjscott package com.superhac.JXBStreamer.Core;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.util.logging.Logger;
/**
* This handles all the XMBSP packet Decoding and Encoding. This is used by the
* XBMSPServerMessageHandler's to decode and code messages.
*
*
* The protocol is documented here.
*
* More information can be found at Superhac.com
*
* @author Steven Scott (superhac007@gmail.com)
*/
public class XBMSPEncoderDecoder {
/* Indentifier message on inital connection */
protected static final String SERVER_VERSION = "XBMSP-1.0 1.0 JXBStreamer Media Server 1.0\n";
/* Packet types (e.g. type field) for CLIENT's */
protected static final byte XBMSP_PACKET_NULL = 10; // no payload
protected static final byte XBMSP_PACKET_SETCWD = 11;
protected static final byte XBMSP_PACKET_FILELIST_OPEN = 12; // no payload
protected static final byte XBMSP_PACKET_FILELIST_READ = 13;
protected static final byte XBMSP_PACKET_FILE_INFO = 14;
protected static final byte XBMSP_PACKET_FILE_OPEN = 15;
protected static final byte XBMSP_PACKET_FILE_READ = 16;
protected static final byte XBMSP_PACKET_FILE_SEEK = 17;
protected static final byte XBMSP_PACKET_CLOSE = 18;
protected static final byte XBMSP_PACKET_CLOSE_ALL = 19; // no payload
protected static final byte XBMSP_PACKET_SET_CONFIGURATION_OPTION = 20;
protected static final byte XBMSP_PACKET_AUTHENTICATION_INIT = 21;
protected static final byte XBMSP_PACKET_AUTHENTICATE = 22;
protected static final byte XBMSP_PACKET_UPCWD = 23;
/* Packet types (e.g. type field) for Server */
protected static final byte XBMSP_PACKET_OK = 1;
protected static final byte XBMSP_PACKET_ERROR = 2;
protected static final byte XBMSP_PACKET_HANDLE = 3;
protected static final byte XBMSP_PACKET_FILE_DATA = 4;
protected static final byte XBMSP_PACKET_FILE_CONTENTS = 5;
protected static final byte XBMSP_PACKET_AUTHENTICATION_CONTINUE = 6;
/** Packet types (e.g. type field) for Server discovery protocol */
protected static final byte XBMSP_PACKET_SERVER_DISCOVERY_QUERY = 90;
protected static final byte XBMSP_PACKET_SERVER_DISCOVERY_REPLY = 91;
/* Reponse ERROR CODES */
protected static final byte XBMSP_ERROR_OK = 0; /* Reserved */
protected static final byte XBMSP_ERROR_FAILURE = 1;
protected static final byte XBMSP_ERROR_UNSUPPORTED = 2;
protected static final byte XBMSP_ERROR_NO_SUCH_FILE = 3;
protected static final byte XBMSP_ERROR_INVALID_FILE = 4;
protected static final byte XBMSP_ERROR_INVALID_HANDLE = 5;
protected static final byte XBMSP_ERROR_OPEN_FAILED = 6;
protected static final byte XBMSP_ERROR_TOO_MANY_OPEN_FILES = 7;
protected static final byte XBMSP_ERROR_TOO_LONG_READ = 8;
protected static final byte XBMSP_ERROR_ILLEGAL_SEEK = 9;
protected static final byte XBMSP_ERROR_OPTION_IS_READ_ONLY = 10;
protected static final byte XBMSP_ERROR_INVALID_OPTION_VALUE = 11;
protected static final byte XBMSP_ERROR_AUTHENTICATION_NEEDED = 12;
protected static final byte XBMSP_ERROR_AUTHENTICATION_FAILED = 13;
/* seek types for FILE_SEEK */
protected static final byte XBMSP_FILE_SEEK_TYPE_FWDFROMBEG = 0;
protected static final byte XBMSP_FILE_SEEK_TYPE_BCKFROMEND = 1;
protected static final byte XBMSP_FILE_SEEK_TYPE_FWDFROMCUR = 2;
protected static final byte XBMSP_FILE_SEEK_TYPE_BCKFROMCUR = 3;
/* Fields within the packet */
/** Message length of msglen field. excludes the length field itself!! */
private int msgLen;
/** Message Type of msgType field. */
private byte type;
/**
* Message ID of the msgID field. msg identifier to keep req / resp insync,
* cannot use 0x00000000 OR 0xFFFFFFFF
*/
private int id;
/** complete raw payload of Decoding message */
private ByteBuffer payload;
/** complete raw payload of Encoded message */
private ByteBuffer packet;
/**
* payload specific fields: used in the decoding process for the DATA part
* of the packet.
*/
private String payloadString;
/**
* payload specific fields: used in the decoding process for the DATA part
* of the packet.
*/
private String payloadString2;
/**
* payload specific fields: used in the decoding process for the DATA part
* of the packet.
*/
private int payloadInt;
/**
* payload specific fields: used in the decoding process for the DATA part
* of the packet.
*/
private int payloadInt2;
/**
* payload specific fields: used in the decoding process for the DATA part
* of the packet.
*/
private long payloadInt64;
/**
* payload specific fields: used in the decoding process for the DATA part
* of the packet.
*/
private byte payloadByte;
/**
* payload specific fields: used in the decoding process for the DATA part
* of the packet.
*/
private byte[] payloadData;
/*
* Static header size in bytes (msglen, TYPE, ID) -- excludes the length
* field itself
*/
private int headerSize = 5;
/** debug logger */
private static Logger logger;
protected XBMSPEncoderDecoder() {
// if (com.superhac.JXBStreamer.Core.Debug.debug)
logger = com.superhac.JXBStreamer.Core.Debug.getLogger();
}
/**
* Call this after the message is ready to be transmitted.
*
* @return a buffer containing the encoded packet.
*/
protected ByteBuffer getPacket() {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Packing packet for transmission..");
// calculate the size of the packet
if (payload != null) {
payload.flip();
this.msgLen = headerSize + payload.remaining();
} else
this.msgLen = headerSize;
// System.out.println("msglen: "+this.msgLen);
// encode the message
this.packet = ByteBuffer.allocate(this.msgLen + 4); // + 4 for the
// msglen field
// header
packet.putInt(this.msgLen);
packet.put(this.type);
packet.putInt(this.id);
if (payload != null)
packet.put(payload);
// flip the buffer
packet.flip();
return packet;
}
/**
* Gets the msgID of the packet. (msgID)
*
* @return msgID
*/
private int getId() {
return id;
}
/**
* Sets the message ID of the packet (msgID)
*
* @param id
*/
private void setId(int id) {
this.id = id;
}
/**
* Sets the message length of the packet. (msgLen)
*
* @param msgLen
*/
private void setMsgLen(int msgLen) {
this.msgLen = msgLen;
}
/**
* Returns the packet type (type field)
*
* @return
*/
protected byte getType() {
return type;
}
/**
* sets the type
*
* @param type
*/
private void setType(byte type) {
this.type = type;
}
/**
* Takes the socket buffer thats passed in and decodes the message.
*
* @param buff
* the Buffer from the socket.
*/
protected void decodepacket(ByteBuffer buff) // this should throw an
// exception when the packet
// cannot be decoded
{
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Decoding packet.. Socket Buffer size: "
+ buff.remaining());
/** couldn's match packet type */
// boolean typeNotIdentified = false;
// start decoding header
this.msgLen = buff.getInt();
this.type = buff.get();
this.id = buff.getInt();
if (this.msgLen == headerSize) // the size of the header only or
// greater then packet size
return; // theres not payload or the msglen is greater then packet
// size! e.g. XBMSP_PACKET_NULL
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger
.info("Decoding packet.. Socket Buffer size after XBMSP header: "
+ buff.remaining());
// allocate the payload
this.payload = ByteBuffer.allocate(msgLen); // the size
while (buff.hasRemaining()) {
this.payload.put(buff.get());
}
this.payload.flip(); // flip for reading!
// start the parsing of the payload
switch (this.type) {
case XBMSP_PACKET_SETCWD: // change dir
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadString = decodePayloadString();
break;
case XBMSP_PACKET_UPCWD:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadInt = decodePayloadInt();
break;
case XBMSP_PACKET_FILELIST_READ:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadInt = decodePayloadInt();
break;
case XBMSP_PACKET_FILE_INFO:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadString = decodePayloadString();
break;
case XBMSP_PACKET_FILE_OPEN:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadString = decodePayloadString();
break;
case XBMSP_PACKET_FILE_READ:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadInt = decodePayloadInt();
this.payloadInt2 = decodePayloadInt();
break;
case XBMSP_PACKET_FILE_SEEK:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadInt = decodePayloadInt();
this.payloadByte = decodePayloadByte();
this.payloadInt64 = decodePayloadInt64();
break;
case XBMSP_PACKET_CLOSE:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadInt = decodePayloadInt();
break;
case XBMSP_PACKET_SET_CONFIGURATION_OPTION:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadString = decodePayloadString();
this.payloadString2 = decodePayloadString();
break;
case XBMSP_PACKET_AUTHENTICATION_INIT:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadString = decodePayloadString();
break;
case XBMSP_PACKET_AUTHENTICATE:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("");
this.payloadInt = decodePayloadInt();
this.payloadData = decodePayloadData();
break;
default:
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Packet not identifed... Hacker? lmfao!");
// typeNotIdentified = true;
}
// if typeNotIdentified is true throw exception.. TODO!
}
/**
* Decodes a String at the current payload buffer position.
*
* @return
*/
private String decodePayloadString() {
int stringSize = payload.getInt();
// if its zero then the string is null
if (stringSize == 0)
return null;
byte[] dir = new byte[stringSize];
// get all the string bytes
for (int i = 0; i < stringSize; i++)
dir[i] = payload.get();
// copy the bytes to a new string!
try {
return new String(dir, "US-ASCII");
} catch (UnsupportedEncodingException e) {
System.out.println("ERROR: " + e);
System.exit(1);
}
return null;
}
/**
* Decodes a Int at the current payload buffer position.
*
* @return
*/
private int decodePayloadInt() {
return payload.getInt();
}
/**
* Decodes a Byte at the current payload buffer position.
*
* @return
*/
private byte decodePayloadByte() {
return payload.get();
}
/**
* Decodes a Long(64 bits) at the current payload buffer position.
*
* @return
*/
private long decodePayloadInt64() {
return payload.getLong();
}
/**
* Decodes a Byte Array at the current payload buffer position for whatever
* remains in the buffer.
*
* @return
*/
private byte[] decodePayloadData() {
byte[] payloadData = new byte[payload.remaining()];
int size = payload.limit();
for (int i = 0; i < size; i++)
payloadData[i] = payload.get();
return payloadData;
}
/**
* Encodes a packet OK response to this instance of XBMSPEncoderDecoder. An
* encoded message is always based on a message recieved from the client.
* Hence we use the orginal XBMSPEncoderDecoder instance of the recieved
* message to encode the response.
*
* @return a new XBMSPEncoderDecoder with the response packet.
*/
protected XBMSPEncoderDecoder encodePacketOk() {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Encoded Packet Okay response.");
// create a new packet
XBMSPEncoderDecoder outgoingPacket = new XBMSPEncoderDecoder();
// set the msg length
outgoingPacket.setMsgLen(headerSize);
// set the type
outgoingPacket.setType(XBMSP_PACKET_OK);
// set message ID to the received message ID
outgoingPacket.setId(this.getId());
return outgoingPacket;
}
/**
* Encodes a packet ERROR response to this instance of XBMSPEncoderDecoder.
* An encoded message is always based on a message recieved from the client.
* Hence we use the orginal XBMSPEncoderDecoder instance of the recieved
* message to encode the response.
*
* @param errorCode
* the error code as defined by the XBMSP protocol.
* @param errorMessage
* an optional TEXT message
* @return a new XBMSPEncoderDecoder with the response packet.
*/
protected XBMSPEncoderDecoder encodePacketError(byte errorCode,
String errorMessage) {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Encoded Packet Error response. Code:" + errorCode);
XBMSPEncoderDecoder outgoingPacket = new XBMSPEncoderDecoder();
ByteBuffer payload = ByteBuffer.allocate(2048);
// create a new packet
// set the type
outgoingPacket.setType(XBMSP_PACKET_ERROR);
// set message ID to the received message ID
outgoingPacket.setId(this.getId());
// set error code in payload section
payload.put(errorCode);
// optionally pack an error string. int32 length+string
if (errorMessage != null) {
// prepend the string length
int stringLength = errorMessage.length();
payload.putInt(stringLength);
// add string to payload.. Convert string to ACSII bytes
try {
payload.put(errorMessage.getBytes("US-ASCII"));
} catch (UnsupportedEncodingException e) {
System.out.println("ERROR: " + e);
System.exit(1);
}
}
// set the payload on the outgoing packet
outgoingPacket.setPayload(payload);
return outgoingPacket;
}
/**
* Encodes a packet PacketHandle response to this instance of
* XBMSPEncoderDecoder. An encoded message is always based on a message
* recieved from the client. Hence we use the orginal XBMSPEncoderDecoder
* instance of the recieved message to encode the response.
*
* @param handle
* the handle number of the file or directory
* @return a new XBMSPEncoderDecoder with the response packet.
*/
protected XBMSPEncoderDecoder encodePacketHandle(int handle) {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Encoded Packet Handle response.");
XBMSPEncoderDecoder outgoingPacket = new XBMSPEncoderDecoder();
ByteBuffer payload = ByteBuffer.allocate(100); // only 1 int
// create a new packet
// set the type
outgoingPacket.setType(XBMSP_PACKET_HANDLE);
// set message ID to the received message ID
outgoingPacket.setId(this.getId());
// set the handle in the payload
payload.putInt(handle);
// set the payload on the outgoing packet
outgoingPacket.setPayload(payload);
return outgoingPacket;
}
/**
* Encodes a packet PacketFileData response to this instance of
* XBMSPEncoderDecoder. An encoded message is always based on a message
* recieved from the client. Hence we use the orginal XBMSPEncoderDecoder
* instance of the recieved message to encode the response.
*
* @param name
* The name of the file or handle(file.getName())
* @param data
* The XML encoded String with the file data. (e.g. file size,
* accessTime, etc..)
* @return a new XBMSPEncoderDecoder with the response packet.
*/
protected XBMSPEncoderDecoder encodePacketFileData(String name, String data) {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Encoded File data response. (XML Data).");
XBMSPEncoderDecoder outgoingPacket = new XBMSPEncoderDecoder();
byte bytes[];
ByteBuffer payload = ByteBuffer.allocate(2000);
// create a new packet
// set the type
outgoingPacket.setType(XBMSP_PACKET_FILE_DATA);
// set message ID to the received message ID
outgoingPacket.setId(this.getId());
if (name != null && data != null) // a entry
{
// pack string 1
payload.putInt(name.length());
bytes = name.getBytes();
payload.put(bytes);
// pack string 2
payload.putInt(data.length());
bytes = data.getBytes();
payload.put(bytes);
} else // the end of the list was hit. set lengths to zero on both
// strings
{
payload.putInt(0x00000000);
payload.putInt(0x00000000);
}
// set the payload on the outgoing packet
outgoingPacket.setPayload(payload);
return outgoingPacket;
}
/**
* Encodes a packet encodePacketFileContents response to this instance of
* XBMSPEncoderDecoder. An encoded message is always based on a message
* recieved from the client. Hence we use the orginal XBMSPEncoderDecoder
* instance of the recieved message to encode the response.
*
* @param data
* the raw file data for the request
* @return a new XBMSPEncoderDecoder with the response packet.
*/
protected XBMSPEncoderDecoder encodePacketFileContents(ByteBuffer data) {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Encoded File Contents.");
XBMSPEncoderDecoder outgoingPacket = new XBMSPEncoderDecoder();
// set the type
outgoingPacket.setType(XBMSP_PACKET_FILE_CONTENTS);
// set message ID to the received message ID
outgoingPacket.setId(this.getId());
if (data != null) {
outgoingPacket.setPayload(data);
} else // no more data
{
ByteBuffer payload = ByteBuffer.allocate(4);
payload.putInt(0x00000000);
outgoingPacket.setPayload(payload);
}
return outgoingPacket;
}
/**
* Sets the payload of the packet
*
* @param payload
*/
private void setPayload(ByteBuffer payload) {
this.payload = payload;
}
/**
* Gets the first byte from the payload.. (message data section)
*
* @return
*/
protected byte getPayloadByte() {
return payloadByte;
}
/**
* Gets the first byte[] from the payload.. (message data section)
*
* @return
*/
protected byte[] getPayloadData() {
return payloadData;
}
/**
* Gets the first Int from the payload.. (message data section)
*
* @return
*/
protected int getPayloadInt() {
return payloadInt;
}
/**
* Gets the second Int from the payload.. (message data section)
*
* @return
*/
protected int getPayloadInt2() {
return payloadInt2;
}
/**
* Gets the first long(INT64) from the payload.. (message data section)
*
* @return
*/
protected long getPayloadInt64() {
return payloadInt64;
}
/**
* Gets the first String from the payload.. (message data section)
*
* @return
*/
protected String getPayloadString() {
return payloadString;
}
/**
* Gets the Second String from the payload.. (message data section)
*
* @return
*/
protected String getPayloadString2() {
return payloadString2;
}
}
JXBStreamer/src/com/com/superhac/JXBStreamer/Core/DirectoryHandlerObject.java 0000700 0001750 0001750 00000015173 10540072762 027362 0 ustar sjscott sjscott package com.superhac.JXBStreamer.Core;
import java.io.File;
import java.util.ArrayList;
import java.util.logging.Logger;
/**
* The DirectoryHandlerObject maps directories to handles and provides services
* for fulfilling client requests on directories. E.g. get a list of files in a
* directory.
*
*
* More information can be found at Superhac.com
*
* @author Steven Scott (superhac007@gmail.com)
*/
public class DirectoryHandlerObject {
/** The Directory Handle assigned by the XBMSPServerMessageHandler */
private int handle;
/** The Directory Path. will be null if it is the Virtual Root */
private File path;
/** A list of the files in the directory. */
private ArrayList files = new ArrayList();
/**
* the last path seqment of all virtual roots. E.g. the last the directory.
* No files!
*/
private ArrayList virtualRoot = null;
/** how many files in directory */
private int totalDirectoryEntries;
/** The current Directory listing position were on */
private int directoryListingPosition = 0;
/** debug logger */
private static Logger logger;
/** If this is a directory handle to the virtual root this is set */
private boolean isVirtualRoot = false;
/**
* All regular non-Virtual root paths will use this constructor.
*
* @param handle
* the handle assigned to this path.
* @param path
* the acutal directory path.
*/
protected DirectoryHandlerObject(int handle, File path) {
// if (com.superhac.JXBStreamer.Core.Debug.debug)
logger = com.superhac.JXBStreamer.Core.Debug.getLogger();
this.handle = handle;
this.path = path;
buildDirectoryList();
}
/**
* Only use this constructor if its the virtual root directory.
*
* @param handle
* handle the handle assigned to this path.
* @param virtualRoot
* The virtual root File list.
*/
protected DirectoryHandlerObject(int handle, ArrayList virtualRoot) {
logger = com.superhac.JXBStreamer.Core.Debug.getLogger();
this.handle = handle;
this.virtualRoot = virtualRoot;
this.path = null;
isVirtualRoot = true;
buildVirtualRootList();
}
/**
* Builds the list of files(or directories) contained with this directory.
* Not to be used for the virtual root.
*/
private void buildDirectoryList() {
// clear out array
files.removeAll(files);
// get the listing of the current directory
File[] children = path.listFiles();
// add some kind of filters a some point... like to remove . files
// add each file as FILE to the arraylist
for (int i = 0; i < children.length; i++)
files.add(children[i]);
// set the total number of Directory entries
totalDirectoryEntries = files.size();
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Build directory list. Total Entries:"
+ totalDirectoryEntries);
}
/**
* Build the directory list for the Virtual Root directory. Only used when
* its the virtual root.
*/
private void buildVirtualRootList() {
files.removeAll(files);
// File[] files = new File[virtualRoot.size()];
// copy array list
files = (ArrayList) virtualRoot.clone();
// set the total number of Directory entries
totalDirectoryEntries = files.size();
}
/**
* Get the handle number for this directory.
*
* @return The handle number.
*/
protected int getHandle() {
return handle;
/** String[0] = name, String[1] = XML Data */
}
/**
* Gets the next directory item(file) requested by the client.
*
* @return String[0] is the name of the file, String[1] = contains the XML
* data for client response.
*/
protected String[] getNextEntry() {
String[] payloadStrings = new String[2];
/**
* if there are no more entries reset the directoryListingPosition back
* to 0 and send null strings
*/
if (directoryListingPosition == totalDirectoryEntries) {
payloadStrings[0] = null;
payloadStrings[1] = null;
// reset position
directoryListingPosition = 0;
// refresh the list... if there were new files added they will show
// up!
if (isVirtualRoot)
buildVirtualRootList();
else
buildDirectoryList();
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Last directory entry. Reset List..");
return payloadStrings;
}
// System.out.println("current position in dir: "+
// directoryListingPosition );
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger
.info("Reading and packing next directory entry at position: "
+ directoryListingPosition);
File entry = files.get(directoryListingPosition);
// build the String Name and the XML Data payload
payloadStrings[0] = entry.getName();
// call the XML function for String[1]
payloadStrings[1] = XBMSPxmlEncoder.encodeEntry(entry);
// increment the current position
directoryListingPosition++;
return payloadStrings;
}
/**
* Gets the file index number of the named file within the directory.
*
* @param name
* The name of the file
* @return the index number of the requested filename.
*/
protected int getFileIndexNumber(String name) {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Getting file index number in directory for file <"
+ name + "?");
for (int i = 0; i < files.size(); i++)
if (files.get(i).getName().compareTo(name) == 0) // matched
return i;
return -1;
/** this needs to throw an exception is the file does not exists */
}
/**
* Gets a specfic directory item specified by index.
*
* @param index
* The index number of the requested file. Get from
* getFileIndexNumber(String name).
* @return String[0] is the name of the file, String[1] = contains the XML
* data for client response.
*/
protected String[] getEntryDataByIndex(int index) {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Getting entry data(xml) by index...");
String[] payloads = new String[2];
payloads[0] = files.get(index).getName();
payloads[1] = XBMSPxmlEncoder.encodeEntry(files.get(index));
return payloads;
}
/**
* This gets the File Object for the index number requested.
*
* @param index
* The index number of the requested file. Get from
* getFileIndexNumber(String name).
* @return The file object of the request.
*/
protected File getFileByIndex(int index) {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Get file by index....");
File file = files.get(index);
return file;
}
/**
* Gets the path(File) represented by this DirectoryHandlerObject.
*
* @return The path.
*/
protected File getPath() {
return path;
}
}
JXBStreamer/src/com/com/superhac/JXBStreamer/Core/XBMSPServer.java 0000700 0001750 0001750 00000027342 10540072762 025052 0 ustar sjscott sjscott package com.superhac.JXBStreamer.Core;
import java.io.File;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;
import java.util.logging.Logger;
/**
* This is the main class that is used for running a XBMSP server. The server
* uses non-blocking socket IO and runs as a thread.
*
*
* More information can be found at Superhac.com
*
* @author Steven Scott (superhac007@gmail.com)
*/
public class XBMSPServer implements Runnable {
/**
* XBMSP server port to listen to for incoming connections. Default setting
* is 1400.
*/
private int port = 1400;
/**
* The file directories that make up the virtual root directory. The last
* part of the path becomes a directory in the virtual root.
*/
private ArrayList virtualRoot;
/** Activates the XBMSP autoDiscovery server if set. */
private boolean autoDiscoveryEnabled = true;
/** Activates the server if set. (Binds the port for listening). */
private boolean startServer = false;
/** Stops the server while running. */
private boolean stopServer = false;
/** is the server runnning? */
private boolean serverRunning = false;
/** the Selector for managing the connections. */
private Selector selector;
/** The XBMSP discovery portocol server. */
private XBMSPDiscoverServer discoveryServer;
/** Contains all the message handlers for each connected client. */
private ArrayList smhList = new ArrayList();
/** debuging logger instance */
private static Logger logger;
/** The timer used is polling for inactive clients */
private Timer timer;
/**
* The amount of nonactivity before the server disconnects a client (in
* seconds)
*/
private int maximumClientIdleTime = 1800; // in seconds (30 minutes)
/**
* Creates an instance of the XBMSP Server that runs as a thread. The
* instance threads itself and does not stop running as a thread until the
* virtual machine is terminated.
*/
public XBMSPServer() {
// gets the logger instance
logger = com.superhac.JXBStreamer.Core.Debug.getLogger();
// create a new discovery server...
discoveryServer = new XBMSPDiscoverServer(port);
// Run the server as a thread. It threads itself!
Runnable runnable = this;
Thread thread = new Thread(runnable);
thread.start();
// start the dead client monitor
// check for dead clients every 5 seconds
timer = new Timer();
timer
.scheduleAtFixedRate(new CheckForClientTimeoutsTask(this), 0,
5000);
}
/**
* Main loop of the Server running as a Thread. Comes from impementing
* Runnable
*/
public void run() {
while (true) {
if (startServer) {
if (autoDiscoveryEnabled)
discoveryServer.startServer();
serverListeningLoop();
}
// take nap for while the server is NOT listening for connection
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* The main socket listening loop. The sockets are bound and messages are
* routed.
*
*/
private void serverListeningLoop() {
try {
// create a selector for geting IO
selector = Selector.open();
// create a SSC object
ServerSocketChannel ssc = ServerSocketChannel.open();
// configure it for non-blocking IO
ssc.configureBlocking(false);
// get the ServerSocket from the SSC
ServerSocket ss = ssc.socket();
// Bind the Server Socket to a port
ss.bind(new InetSocketAddress(port)); // bind to port
// register for accepting incomming connections
SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
// buffer for reading
ByteBuffer buffer = ByteBuffer.allocate(2048);
// if we make it this far the server is running sucessfully
serverRunning = true;
while (!stopServer) {
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Waiting for packet...");
// main loop wait for events
selector.select();
// we got an event
Set skeys = selector.selectedKeys();
Iterator it = skeys.iterator();
while (it.hasNext()) {
// get a key
SelectionKey rsk = (SelectionKey) it.next();
// A new connection
if ((rsk.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
// accept Connection
Socket socket = ss.accept();
SocketChannel sc = socket.getChannel();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);
// socket.setTcpNoDelay(true);
// create a new handler object for connection
XBMSPServerMessageHandler smh = new XBMSPServerMessageHandler(
sc, virtualRoot);
// add it to the connections list
// synchronize be cause of ServerStatus
synchronized (this) {
smhList.add(smh);
}
// send version information
String version = XBMSPEncoderDecoder.SERVER_VERSION;
ByteBuffer buf = ByteBuffer.wrap(version
.getBytes("US-ASCII"));
sc.write(buf);
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("New connection created..");
// remove the key.. were done with it
// selector.selectedKeys().remove(rsk);
it.remove();
}
// its a read // route to right handler
else if ((rsk.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
SocketChannel sc = (SocketChannel) rsk.channel();
// remove the key.. were done with it
// selector.selectedKeys().remove(rsk);
it.remove();
for (int i = 0; i < smhList.size(); i++) {
if (sc.equals(smhList.get(i).getSocketChannel())) {// its
// a
// match
buffer.clear();
int numBytesRead = sc.read(buffer);
if (numBytesRead == -1) {
// No more bytes can be read from the
// channel
if (com.superhac.JXBStreamer.Core.Debug.debug)
logger.info("Client Disconnected");
synchronized (this) {
smhList.remove(i);
}
sc.close();
} else {
buffer.flip();
smhList.get(i).IncommingMessage(buffer);
}
}
}
}
}
}
key.selector().close();
ssc.close();
synchronized (this) {
smhList.removeAll(smhList);
}
serverRunning = false;
stopServer = false;
startServer = false;
} catch (IOException e) {
System.out.println("ERROR: " + e);
}
}
/**
* Provides detailed information about each connected client.
*
* @return The server status object which contains info about each connected
* client.
*/
public ServerStatus getServerStatus() {
ArrayList clients = new ArrayList();
for (XBMSPServerMessageHandler smh : smhList)
clients.add(smh.getStatus());
return new ServerStatus(serverRunning, clients);
}
/**
* Is the server running. E.g. Listening for incoming connections.
*
* @return True if the server is awaiting comming connections and false if
* not.
*/
public boolean isServerRunning() {
return serverRunning;
}
/**
* Stops the server from accepting connections and also disconnects any
* connected clients.
*
*/
public void stopServer() {
// stop discovery server
if (autoDiscoveryEnabled)
discoveryServer.stopServer();
// stop regular server
stopServer = true;
selector.wakeup();
}
/**
* Starts the server so it can recieve incoming connections.
*
*/
public void startServer() {
startServer = true;
}
/**
* Gets the binding port for the XBMSP server.
*
* @return The port number the server is listening on.
*/
public int getPort() {
return port;
}
/**
* Set the port number the server will listen on.
*
* @param port
* The port number the server will bind to.
*/
public void setPort(int port) {
if (serverRunning) {
stopServer();
this.port = port;
while (serverRunning) {
// waits until the server stops. Need this to impose a delay
// between stopping and starting
}
startServer();
} else
this.port = port;
}
/**
* Is the the XBMSP server configured for the AutoDiscovery Service(UDP)?
* Clients can broadcast on port 1400 and the server will respond with
* identifying information that can be used to connect to the server.
*
* @return True if the Discovery Server is running and False if not.
*/
public boolean isAutoDiscoveryEnabled() {
return autoDiscoveryEnabled;
}
/**
* Clients can broadcast on port 1400 and the server will respond with
* identifying information that can be used to connect to the server.
*
* @param autoDiscoveryEnabled
* True if it should be enabled and false if not.
*/
public void setAutoDiscoveryEnabled(boolean autoDiscoveryEnabled) {
this.autoDiscoveryEnabled = autoDiscoveryEnabled;
}
/**
* Set the virtual root directory. This allows multiple directories to be
* shared that are spread over different paths. The client is presented with
* a virtual root directory that consists of the supplied paths as a single
* dirctory.
*
* @param virtualRoot
* An arraylist of files that make up the virtual root directory
*/
public void setVirtualRoot(ArrayList virtualRoot) {
this.virtualRoot = virtualRoot;
}
/**
* Returns an ArrayList of the message handlers. The message handlers handle
* the communicate between the client and the server. Each connected client
* has its own message handler. As a packet comes into the server it is
* routed to the appropraite message handler for that client.
*
* @return The current message handlers for the clients
*/
protected ArrayList getServerMessageHandlers() {
return smhList;
}
/**
* Gets the maximum client idle time before being disconnected by the
* server.
*
* @return The currently set Idle time in seconds.
*/
protected int getMaximumClientIdleTime() {
return maximumClientIdleTime;
}
/**
* Sets the maximum client idle time before being disconnected by the
* server.
*
* @param maximumClientIdleTime
* The maximum amount of idle time before the server disconnects
* the client.
*/
protected void setMaximumClientIdleTime(int maximumClientIdleTime) {
this.maximumClientIdleTime = maximumClientIdleTime;
}
}
/**
* This is a inner class of XBMSPServer that is used to check the idle time of
* connected clients. If the time a client has been idle for exceeds the
* maximumClientIdleTime then the client is disconnected. Operates by the task
* being schduled by a Timer (timer.scheduleAtFixedRate).
*
* @author sjscott
*
*/
class CheckForClientTimeoutsTask extends TimerTask {
int maximumDelay;
XBMSPServer caller;
CheckForClientTimeoutsTask(XBMSPServer caller) {
this.caller = caller;
maximumDelay = caller.getMaximumClientIdleTime();
}
public void run() {
ArrayList clients = caller
.getServerMessageHandlers();
ArrayList remove = new ArrayList();
for (XBMSPServerMessageHandler client : clients)
if (client.getLastTransmissionDelay() > maximumDelay)
remove.add(client);
// if any are over the set idel time remove
for (int i = 0; i < remove.size(); i++) {
synchronized (this) {
clients.remove(remove.get(i));
}
// close the clients socket!
try {
remove.get(i).getSocketChannel().close();
} catch (IOException e) {
}
}
}
}
JXBStreamer/src/com/com/superhac/JXBStreamer/Core/.emptyDir 0000700 0001750 0001750 00000000236 10540072762 023716 0 ustar sjscott sjscott This file was generated by Together to prevent this folder from being deleted during synchronization with the CVS repositiory. Please do not delete this file. JXBStreamer/src/com/com/superhac/JXBStreamer/Core/XBMSPxmlEncoder.java 0000700 0001750 0001750 00000004525 10540072762 025702 0 ustar sjscott sjscott package com.superhac.JXBStreamer.Core;
import java.io.File;
import java.io.UnsupportedEncodingException;
import java.util.logging.Logger;
/**
* This class handles the encoding of the XML file data in the XBMSP protocol.
*
*
* More information can be found at